measurements for the different violation types, comparison for differenct generation config

17 files changed, 432 insertions, 139 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
index 1745bc35..58ac7aea 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
@@ -35,7 +35,7 @@ class Main {
                 
                 //human input has different package declaration
 //              reader = new GraphReader(Yakindumm2PackageImpl.eINSTANCE);
-                val human = new RWInformation("inputs/Fake_Random_Random/", "outputs/", 1);
+                val human = new RWInformation("inputs/config7/", "outputs/", 1);
                 calculateAllModels(human.inputFolder, human.outputFolder,human.numRuns, reader);
                 
                 
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
index 45986ecf..cdce185a 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
@@ -1,5 +1,6 @@
 package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
 
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.EuclideanDistance
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.JSDistance
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.KSDistance
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.StateData
@@ -8,6 +9,7 @@ import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.predictor.LinearModel
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import java.util.ArrayList
@@ -21,6 +23,7 @@ class PartialInterpretationMetricDistance {
         
         var KSDistance ks;
         var JSDistance js;
+        var EuclideanDistance ed;
         var Map<Object, StateData> stateAndHistory;
         var OLSMultipleLinearRegression regression;
         List<StateData> samples;
@@ -32,6 +35,7 @@ class PartialInterpretationMetricDistance {
         new(){
                 ks = new KSDistance(Domain.Yakinduum);
                 js = new JSDistance(Domain.Yakinduum);
+                ed = new EuclideanDistance(Domain.Yakinduum);
                 regression = new OLSMultipleLinearRegression();
                 regression.noIntercept = false;
                 stateAndHistory = new HashMap<Object, StateData>();
@@ -44,6 +48,7 @@ class PartialInterpretationMetricDistance {
                 metrics.add(new OutDegreeMetric());
                 metrics.add(new NodeActivityMetric());
                 metrics.add(new MultiplexParticipationCoefficientMetric());
+                metrics.add(new TypedOutDegree());
                 
                 val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
                 var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
@@ -51,6 +56,24 @@ class PartialInterpretationMetricDistance {
                 var mpc = ks.mpcDistance(metricSamples.mpcSamples);
                 var na = ks.naDistance(metricSamples.naSamples);
                 var outDegree = ks.outDegreeDistance(metricSamples.outDegreeSamples);
+                var typedOutDegree = ks.typedOutDegreeDistance(metricSamples.typedOutDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree, typedOutDegree);
+        }
+        
+        def MetricDistanceGroup calculateMetricEuclidean(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                metrics.add(new TypedOutDegree());
+                
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
+                var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
+                
+                var mpc = ed.mpcDistance(metricSamples.mpcSamples);
+                var na = ed.naDistance(metricSamples.naSamples);
+                var outDegree = ed.outDegreeDistance(metricSamples.outDegreeSamples);
                 
                 return new MetricDistanceGroup(mpc, na, outDegree);
         }
@@ -132,14 +155,13 @@ class PartialInterpretationMetricDistance {
         }
         
         def double[] calculateFeature(int step, int violations){
-                var features = newDoubleArrayOfSize(5);
+                var features = newDoubleArrayOfSize(2);
                 //constant term
                 features.set(0, 1);
                 
                 features.set(1, 1.0 / step);
-                features.set(2, violations);
-                features.set(3, Math.pow(violations, 2));
-                features.set(4, Math.pow(violations, 0.5));
+//              features.set(2, violations);
+//              features.set(3, Math.pow(violations, 2));
                 
                 return features;
         }
@@ -149,6 +171,14 @@ class MetricDistanceGroup{
         var double mpcDistance;
         var double naDistance;
         var double outDegreeDistance;
+        var double typedOutDegreeDistance;
+        
+        new(double mpcDistance, double naDistance, double outDegreeDistance, double typedOutDegreeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+                this.typedOutDegreeDistance = typedOutDegreeDistance;
+        }
         
         new(double mpcDistance, double naDistance, double outDegreeDistance){
                 this.mpcDistance = mpcDistance;
@@ -156,6 +186,10 @@ class MetricDistanceGroup{
                 this.outDegreeDistance = outDegreeDistance;
         }
         
+        def double getTypedOutDegreeDistance(){
+                return this.typedOutDegreeDistance;
+        }
+        
         def double getMPCDistance(){
                 return this.mpcDistance
         }
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
index 33d10fa3..613f0f43 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
@@ -1,9 +1,25 @@
 package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
 
+import java.text.DecimalFormat
+import java.util.HashMap
+import java.util.List
 import org.eclipse.xtend.lib.annotations.Accessors
 
-class CostDistance {
-
+abstract class CostDistance {
+        def abstract double naDistance(List<Double> samples);   
+        def abstract double mpcDistance(List<Double> samples);
+        def abstract double outDegreeDistance(List<Double> samples);
+        
+        def protected pmfFromSamples(double[] samples, DecimalFormat formatter){
+                var length = samples.length;
+                var pmfMap = new HashMap<String, Double>();
+                
+                for(sample : samples){
+                        pmfMap.put(formatter.format(sample), pmfMap.getOrDefault(formatter.format(sample), 0.0) + 1.0 / length);
+                }
+                
+                return pmfMap;
+        }
 }
 
 class StateData{
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
new file mode 100644
index 00000000..b945d97b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
@@ -0,0 +1,73 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import com.google.common.collect.Sets
+import java.text.DecimalFormat
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.Set
+
+class EuclideanDistance extends CostDistance{
+        var MetricSampleGroup g;
+        var HashMap<String, Double> mpcPMF;
+        var HashMap<String, Double> naPMF;
+        var HashMap<String, Double> outDegreePMF;
+        var DecimalFormat formatter;
+        
+        new(Domain d){
+                var metrics = RepMetricsReader.read(d);
+                this.g = metrics;
+                
+                var mpcSamples = metrics.mpcSamples;
+                var naSamples = metrics.naSamples.stream.mapToDouble([it]).toArray();
+                var outDegreeSamples = metrics.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                
+                //needs to format the number to string avoid precision issue
+                formatter = new DecimalFormat("#0.00000");  
+                
+                mpcPMF = pmfFromSamples(mpcSamples, formatter);
+                naPMF = pmfFromSamples(naSamples, formatter);
+                outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
+        }
+        
+        override naDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, naPMF);
+        }
+        
+        override mpcDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, mpcPMF);
+        }
+        
+        override outDegreeDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, outDegreePMF);
+        }
+        
+        
+        def private euclideanDistance(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
+                var keys = Sets.union(pmf1.keySet(), pmf2.keySet());
+                var pmfList1 = pmfMapToList(pmf1, keys);
+                var pmfList2 = pmfMapToList(pmf2, keys);
+                var distance = 0.0;
+                for(var i = 0; i < pmfList1.size(); i++){
+                        distance += Math.pow(pmfList1.get(i) + pmfList2.get(i), 2);
+                }
+                
+                return Math.sqrt(distance);
+        }       
+        
+        def private pmfMapToList(Map<String, Double> map, Set<String> keys){
+                var list = new ArrayList<Double>();
+                for(key : keys){
+                        var value = map.getOrDefault(key, 0.0);
+                        list.add(value);
+                }
+                return list;
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
index ced9eadb..df65b81f 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
@@ -7,7 +7,7 @@ import java.text.DecimalFormat
 import java.util.HashMap
 import java.util.List
 
-class JSDistance {
+class JSDistance extends CostDistance {
         var HashMap<String, Double> mpcPMF;
         var HashMap<String, Double> naPMF;
         var HashMap<String, Double> outDegreePMF;
@@ -27,17 +27,6 @@ class JSDistance {
                 outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
         }
         
-        def private pmfFromSamples(double[] samples, DecimalFormat formatter){
-                var length = samples.length;
-                var pmfMap = new HashMap<String, Double>();
-                
-                for(sample : samples){
-                        pmfMap.put(formatter.format(sample), pmfMap.getOrDefault(formatter.format(sample), 0.0) + 1.0 / length);
-                }
-                
-                return pmfMap;
-        }
-        
         def private combinePMF(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
                 var pmfMap = new HashMap<String, Double>();
                 
@@ -68,7 +57,7 @@ class JSDistance {
                 return distance;
         }
         
-        def double mpcDistance(List<Double> samples){
+        override double mpcDistance(List<Double> samples){
                 // map list to array
                 var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
                 //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
@@ -76,7 +65,7 @@ class JSDistance {
                 return jsDivergence(map, mpcPMF);
         }
         
-        def double naDistance(List<Double> samples){
+        override double naDistance(List<Double> samples){
                 // map list to array
                 var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
                 
@@ -85,7 +74,7 @@ class JSDistance {
                 return jsDivergence(map, naPMF);
         }
         
-        def double outDegreeDistance(List<Double> samples){
+        override double outDegreeDistance(List<Double> samples){
                 // map list to array
                 var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
                 //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
index 58e0a8a3..86f5f23c 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
@@ -2,46 +2,65 @@ package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
 
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import java.util.HashMap
+import java.util.HashSet
 import java.util.List
+import java.util.Set
 import org.apache.commons.math3.stat.inference.KolmogorovSmirnovTest
 
-class KSDistance {
+class KSDistance extends CostDistance {
         var static ksTester = new KolmogorovSmirnovTest();
-        var double[] mpcSamples;
-        var double[] naSamples;
-        var double[] outDegreeSamples;
-        
+        var MetricSampleGroup g;
         new(Domain d){
                 var metrics = RepMetricsReader.read(d);
-                mpcSamples = metrics.mpcSamples;
-                naSamples = metrics.naSamples.stream.mapToDouble([it]).toArray();
-                outDegreeSamples = metrics.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                this.g = metrics;
         }
         
-        def double mpcDistance(List<Double> samples){
-                // map list to array
-                var arr = samples.stream.mapToDouble([it]).toArray();
-                
+        override double mpcDistance(List<Double> samples){
                 //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
-                if(arr.size < 2) return 1;
-                return ksTester.kolmogorovSmirnovStatistic(mpcSamples, arr);
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.mpcSamples, samples);
         }
         
-        def double naDistance(List<Double> samples){
-                // map list to array
-                var arr = samples.stream.mapToDouble([it]).toArray();
-                
+        override double naDistance(List<Double> samples){
                 //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
-                if(arr.size < 2) return 1;
-                return ksTester.kolmogorovSmirnovStatistic(naSamples as double[], arr);
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.naSamples as double[], samples);
         }
         
-        def double outDegreeDistance(List<Double> samples){
+        override double outDegreeDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.outDegreeSamples, samples);
+        }
+        
+        def double typedOutDegreeDistance(HashMap<String, List<Integer>> map){
+                var value = 0.0;
                 // map list to array
-                var arr = samples.stream.mapToDouble([it]).toArray();
+                val keySet = new HashSet<String>(map.keySet);
+                keySet.addAll(g.typedOutDegreeSamples.keySet);
+                for(key : keySet){
+                        if(!map.containsKey(key) ){
+                                value += 1;
+                        }else if(!g.typedOutDegreeSamples.containsKey(key)){
+                                value += map.get(key).size * 100;       
+                        }else{
+                                var double[] rep = g.typedOutDegreeSamples.get(key).stream().mapToDouble([it|it]).toArray();
+                                var double[] ins = map.get(key).stream().mapToDouble([it|it]).toArray();
+                                if((rep.size < 2 || ins.size < 2) ){
+                                        if(rep.size < 2 && rep.containsAll(ins)){
+                                                value += 0;
+                                        }else{
+                                                value += 1;
+                                        }
+                                }else if(rep.size >= 2 && ins.size >= 2){
+                                        value += ksTester.kolmogorovSmirnovStatistic(rep, ins);
+                                }
+                        }
+                } 
                 
-                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
-                if(arr.size < 2) return 1;
-                return ksTester.kolmogorovSmirnovStatistic(outDegreeSamples, arr);
+                
+                return value;
         }
 }
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
index 5c161f4b..b4c57bd8 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
@@ -2,13 +2,14 @@ package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
 
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
 import java.util.ArrayList
+import java.util.HashSet
 import java.util.List
 import org.eclipse.emf.common.util.EList
 import org.eclipse.emf.ecore.EObject
 import org.eclipse.emf.ecore.EReference
 
 class EMFGraph extends Graph{   
-        def void init (EObject root, List<Metric> metrics, String name, List<String> referenceTypes){
+        def void init (EObject root, List<Metric> metrics, String name, List<EReference> referenceTypes){
                 val otherContents = root.eAllContents.toList();
                 otherContents.add(root);
                 init(otherContents, metrics, name, referenceTypes);
@@ -21,13 +22,15 @@ class EMFGraph extends Graph{
          * @param name: name of the instance model
          * @param ReferenceTypes: reference types defined in the meta model
          */
-        def void init(List<EObject> objects, List<Metric> metrics, String name, List<String> referenceTypes){
+        def void init(List<EObject> objects, List<Metric> metrics, String name, List<EReference> referenceTypes){
                 objects.forEach[it|
-                        statistic.addNode(it);
+                        var types = new HashSet(it.eClass.EAllSuperTypes.map[it|it.name]);
+                        types.add(it.eClass.name);
+                        statistic.addNodeWithAllTypes(it, types);
                 ]
                 
                 referenceTypes.forEach[it|
-                        statistic.addType(it);
+                        statistic.addEdgeType(it.name);
                 ];
                 
                 objects.forEach[source|
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
index cf4aedba..6b400b0d 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
@@ -2,11 +2,15 @@ package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
 
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
-import java.util.ArrayList
-import java.util.List
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
 
 abstract class Graph {
         
@@ -42,11 +46,17 @@ abstract class Graph {
                 
                 for(metric : this.metrics){
                         if(metric instanceof MultiplexParticipationCoefficientMetric){
-                                sample.mpcSamples = metric.evaluateSamples(this.statistic);                             
+                                sample.mpcSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;                                
                         }else if(metric instanceof NodeActivityMetric){
-                                sample.naSamples = metric.evaluateSamples(this.statistic);
+                                sample.naSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
                         }else if(metric instanceof OutDegreeMetric){
-                                sample.outDegreeSamples = metric.evaluateSamples(this.statistic);
+                                sample.outDegreeSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
+                        }else if(metric instanceof TypedOutDegree){
+                                sample.typedOutDegreeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, List<Integer>>;
+                        }else if(metric instanceof NodeTypeMetric){
+                                sample.nodeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
+                        }else if (metric instanceof EdgeTypeMetric){
+                                sample.edgeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
                         }
                 }
                 
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
index 7ed58094..9b8fd0e3 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
@@ -5,20 +5,22 @@ import com.google.common.collect.Multimap
 import java.util.HashMap
 import java.util.HashSet
 import java.util.List
+import java.util.Map
+import java.util.Set
 import org.eclipse.emf.ecore.EObject
 
 class GraphStatistic {
         val incomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
         val outcomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
-        
+
         val edgeTypes = new HashSet<String>();
-        val nodes = new HashSet<EObject>();
-                
+        val nodeToType = new HashMap<EObject, Set<String>>();   
+
         /**
          * Add an edge type to to the graph
          * @param type: type to add
          */
-        def void addType(String type){
+        def void addEdgeType(String type){
                 if(edgeTypes.contains(type)){
                         return;
                 }
@@ -28,15 +30,20 @@ class GraphStatistic {
         }
         
         /**
-         * Add a node to he graph 
+         * Add a node to the graph with one type in its type hierarchy
          * @param node: node to add
          */
-         def void addNode(EObject n){
-                if(nodes.contains(n)){
-                        return;
-                }
-                
-                nodes.add(n);
+         def void addNodeWithType(EObject n, String Type){
+                var types = nodeToType.getOrDefault(n, new HashSet<String>());
+                types.add(Type);
+                nodeToType.put(n, types);
+         }
+         
+         /**
+          * Add a node to the graph with all types in its type hierarchy
+          */
+         def void addNodeWithAllTypes(EObject n, Set<String> types){
+                nodeToType.put(n, types);
          }
          
          /**
@@ -82,7 +89,7 @@ class GraphStatistic {
           }
           
           /**
-           * calculate the number of edge types for a given degree.
+           * calculate the number of edge types for a given node.
            */
           def int numOfEdgeTypes(EObject o){
                 var count = 0;
@@ -100,8 +107,17 @@ class GraphStatistic {
                 return edgeTypes.toList();
           }
           
+          def Map<EObject, Set<String>> getNodeToTypesMap(){
+                return nodeToType;
+          }
+          
           def List<EObject> getAllNodes(){
-                return nodes.toList();
+                return nodeToType.keySet().toList();
           }
+          
+          def HashMap<String, Multimap<EObject, EObject>> getOutgoingEdges(){
+                return outcomingEdges; 
+          }
+          
 }
 
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
index 14337ab0..91d7c5f9 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
@@ -4,11 +4,13 @@ import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.BooleanElementImpl
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialComplexTypeInterpretationImpl
 import java.util.ArrayList
 import java.util.List
 
 class PartialInterpretationGraph extends Graph{
+        val typeToExclude = "undefinedpart";
+        val classSuffix = " class";
         
         /**
          * Define a new PartialInterpretationGraph by parse every element from a PartialInterpretation
@@ -16,17 +18,21 @@ class PartialInterpretationGraph extends Graph{
         new(PartialInterpretation partial, List<Metric> metrics, String name){          
                 //the edge types are defined in terms of RelationDeclaration
                 partial.problem.relations.filter(RelationDeclaration).forEach[
-                        this.statistic.addType(it.name);
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        this.statistic.addEdgeType(it.name.split(" ").get(0));
                 ]
                 // add all elements
-                val elements = getElements(partial);
-                for(element : elements){
-                        statistic.addNode(element)
+                val typeInterpretations = getTypes(partial);
+                for(type : typeInterpretations){
+                        var typeName = type.interpretationOf.name.replace(classSuffix, '');
+                        for(node : type.elements){
+                                this.statistic.addNodeWithType(node, typeName);
+                        }
                 }
                 
                 for(relationInterpretation : partial.partialrelationinterpretation) {
-                        val type = relationInterpretation.interpretationOf.name
-                        
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        val type = relationInterpretation.interpretationOf.name.split(" ").get(0);
                         for(edge : relationInterpretation.relationlinks.filter(BinaryElementRelationLink)){
                                 statistic.addEdge(edge.param1, edge.param2, type);
                         }                       
@@ -62,8 +68,11 @@ class PartialInterpretationGraph extends Graph{
                 output.add(stateInfo);
         }
         
-        private def getElements(PartialInterpretation partial){
-                return partial.newElements.filter[!(it instanceof BooleanElementImpl)] + partial.problem.elements;
+        private def getTypes(PartialInterpretation partial){
+                //only the complex type interpretations are the ones defined in meta model
+                //do not care about undefined types as it will be included in the class type
+                return partial.partialtypeinterpratation.filter(PartialComplexTypeInterpretationImpl)
+                                                                                                .filter[!it.interpretationOf.name.toLowerCase.contains(typeToExclude)];
         }
         
         override getStatistic() {
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend
index fc56e142..8f1feb9d 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend
@@ -17,10 +17,18 @@ import org.eclipse.emf.ecore.resource.Resource
 import org.eclipse.emf.ecore.resource.ResourceSet
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
 import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage
 
 class GraphReader{
         val ResourceSet resSet = new ResourceSetImpl();
-        val referenceTypes = new ArrayList<String>();
+        val referenceTypes = new ArrayList<EReference>();
+        
+        def static void main(String[] args){
+                var g = new GraphReader(YakindummPackage.eINSTANCE);
+        }
         
         new(EPackage metaModel) {
                 Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("*",new XMIResourceFactoryImpl)
@@ -28,7 +36,7 @@ class GraphReader{
                 //find all reference types in the meta model
                 metaModel.eAllContents.forEach[
                         if(it instanceof EReference){
-                                referenceTypes.add(it.name);
+                                referenceTypes.add(it);
                         }
                 ]
         }
@@ -45,7 +53,10 @@ class GraphReader{
                 metrics.add(new OutDegreeMetric());
                 metrics.add(new NodeActivityMetric());
                 metrics.add(new MultiplexParticipationCoefficientMetric());
-                                
+                metrics.add(new TypedOutDegree());              
+                metrics.add(new NodeTypeMetric());
+                metrics.add(new EdgeTypeMetric());
+                
                 //check all files in the directory with xmi
                 for(String name : dir.list.filter[it| it.endsWith(".xmi")]){
                         val file = new File(name);
@@ -71,7 +82,7 @@ class GraphReader{
                         }
                 } catch(Exception e) {
                         e.printStackTrace();
-                        throw new FileNotFoundException(getURI(path, name).toString + "reason: " + e.message)
+                        throw new Exception(getURI(path, name).toString());
                 }
         }
         
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend
index 867ddd1a..2ea12581 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend
@@ -1,79 +1,43 @@
 package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io
 
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
-import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
-import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
-import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
-import java.io.File
-import java.util.List
-import java.util.Scanner
 import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl.YakindummPackageImpl
 
 /**
  * Read the sample of the distribution of a metric provided the csv file of the metric
  */
 class RepMetricsReader {
         static def read(Domain d){
-                var domainRepPath = CsvDataName.REP_PATH + d.name + '/';
+                var reader = new GraphReader(YakindummPackageImpl.eINSTANCE);
+                
+                
+                var domainRepPath = DataName.REP_PATH + d.name + '/';
                 var rep = new MetricSampleGroup()
-                rep.mpcSamples = readFile(domainRepPath + CsvDataName.MPC_REP, MultiplexParticipationCoefficientMetric.valueName,
-                                                          MultiplexParticipationCoefficientMetric.countName).map[Double.parseDouble(it)];
-                rep.naSamples = readFile(domainRepPath+CsvDataName.NA_REP, NodeActivityMetric.valueName, NodeActivityMetric.countName
-                                                        ).map[Double.parseDouble(it)];
-                rep.outDegreeSamples = readFile(domainRepPath+CsvDataName.OUT_D_REP, OutDegreeMetric.valueName, OutDegreeMetric.countName
-                                                        ).map[Double.parseDouble(it)];
+                var out_d = readMetrics(reader, domainRepPath + DataName.OUT_D_REP);
+                rep.mpcSamples = readMetrics(reader, domainRepPath + DataName.MPC_REP).mpcSamples;
+                rep.outDegreeSamples = out_d.outDegreeSamples;
+                rep.naSamples = readMetrics(reader, domainRepPath + DataName.NA_REP).naSamples;
+                rep.typedOutDegreeSamples = out_d.typedOutDegreeSamples;
+                rep.edgeTypeSamples = out_d.edgeTypeSamples;
+                rep.nodeTypeSamples = out_d.nodeTypeSamples;
                 return rep;
         }
         
         /**
-         * read metric data and parse it to samples
+         * Read representative model
          */
-        private static def List<String> readFile(String filename, String valueDataName, String countDataName){
-                var s = new Scanner(new File(filename));
-                val counts = newArrayList();
-                val values = newArrayList();
-                //read data from csv
-                while(s.hasNext()){
-                        var data = s.nextLine().split(',');     
-                        
-                        if(data.size >= 1){
-                                if(data.get(0).equals(countDataName)){
-                                        //add all data with parsing them as integers
-                                        counts.addAll(data.subList(1, data.size()).map[Integer.parseInt(it)]);
-                                }else if(data.get(0).equals(valueDataName)){
-                                        //add all data without parsing (there can be either double or string, to be parsed later)
-                                        values.addAll(data.subList(1, data.size()));
-                                }
-                        }
-                }
-                
-                return createSamples(counts, values);
+        private static def readMetrics(GraphReader r, String path){
+                var model = r.readModels(path).head;
+                return model.evaluateAllMetricsToSamples();
         }
         
-        // create samples from values and counts
-        private static def List<String> createSamples(List<Integer> counts, List<String> values){
-                val samples = newArrayList();
-                
-                if(counts.size() != values.size()){
-                        throw new RuntimeException("counts and values should have the same size!");
-                }
-                
-                for(var i = 0; i < counts.size(); i++){
-                        for(var j = 0; j < counts.get(i); j++){
-                                samples.add(values.get(i));
-                        }
-                }
-                
-                return samples;
-        }
-        
-        
 }
 
-class CsvDataName{
+class DataName{
         public static val REP_PATH = 'data/';
-        public static val MPC_REP = 'mpc_rep.csv';
-        public static val NA_REP = 'na_rep.csv';
-        public static val OUT_D_REP = 'out_d_rep.csv';
+        public static val MPC_REP = 'mpc_rep';
+        public static val NA_REP = 'na_rep';
+        public static val OUT_D_REP = 'out_d_rep';
 }
 
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend
new file mode 100644
index 00000000..0c0fe3b8
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend
@@ -0,0 +1,41 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.util.ArrayList
+import java.util.HashMap
+
+class EdgeTypeMetric extends Metric {
+        
+        override evaluate(GraphStatistic g) {
+                var map = evaluateSamples(g) as HashMap<String, Double>;
+                var output = new ArrayList<String[]>();
+                output.add(newArrayList('Edge Type'));
+                
+                var keys = map.keySet;
+                var values = newArrayList();
+                for(key : keys){
+                        values.add(map.get(key)+'');
+                }
+                
+                output.add(keys);
+                output.add(values);
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                val map = new HashMap<String, Double>();
+                var outgoingEdges = g.outgoingEdges;
+                
+                //get the total number of edges
+                val edgeCount = outgoingEdges.values.fold(0, [r, t| r + t.asMap.values.fold(0, [r1, t1| r1 + t1.size])]) as double;
+                outgoingEdges.forEach[k, v|
+                        var value = v.asMap.values.fold(0, [r, t| r + t.size]) / edgeCount;
+                        map.put(k, value);
+                ]
+                
+                        
+                return map;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend
index 38ef72f2..cb242a5b 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend
@@ -4,5 +4,5 @@ import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatis
 
 abstract class Metric {
         abstract def String[][] evaluate(GraphStatistic g);
-        abstract def double[] evaluateSamples(GraphStatistic g);
+        abstract def Object evaluateSamples(GraphStatistic g);
 }
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend
index 8cd3daee..4e25bb86 100644
--- a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend
@@ -1,9 +1,13 @@
 package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
 
+import java.util.HashMap
 import java.util.List
 
 class MetricSampleGroup{
         public var List<Double> mpcSamples;
         public var List<Double> naSamples;
         public var List<Double> outDegreeSamples;
+        public var HashMap<String, List<Integer>> typedOutDegreeSamples;
+        public var HashMap<String, Double> nodeTypeSamples;
+        public var HashMap<String, Double> edgeTypeSamples;
 }
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeTypeMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeTypeMetric.xtend
new file mode 100644
index 00000000..94eaa445
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeTypeMetric.xtend
@@ -0,0 +1,44 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.util.ArrayList
+import java.util.HashMap
+
+class NodeTypeMetric extends Metric {
+        
+        
+        override evaluate(GraphStatistic g) {
+                var map = evaluateSamples(g) as HashMap<String, Double>;
+                var output = new ArrayList<String[]>();
+                output.add(newArrayList('Node Type'));
+                var keys = map.keySet;
+                var values = newArrayList();
+                
+                for(key : keys){
+                        values.add(map.get(key)+'');
+                }
+                
+                output.add(keys);
+                output.add(values);
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                var map = new HashMap<String, Double>();
+                var nodes = g.allNodes;
+                var single = 1.0 / nodes.size();
+                for(node : nodes){
+                        var classes = new ArrayList(node.eClass.ESuperTypes);
+                        classes.add(node.eClass);
+                        
+                        for(cl : classes){
+                                var value = map.getOrDefault(cl.name, 0.0);
+                                map.put(cl.name, value + single);
+                        }       
+                }
+                
+                return map;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedOutDegree.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedOutDegree.xtend
new file mode 100644
index 00000000..3b5dbcc5
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedOutDegree.xtend
@@ -0,0 +1,60 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+
+class TypedOutDegree extends Metric{
+        
+        def private calculateMetric(GraphStatistic g){
+                var outgoingEdges = g.outgoingEdges;
+                //record metric as a list of samples for each node type / edge type pair
+                var metric = new HashMap<String, List<Integer>>();
+                var nodeToTypes = g.nodeToTypesMap;
+                
+                for(edgeType : outgoingEdges.keySet){
+                        for(node : outgoingEdges.get(edgeType).keySet){
+                                //find all classes the node belongs to
+                                var classes = nodeToTypes.get(node);
+                                for(cl : classes){
+                                        // get or create entry for node type / edge type pair
+                                        var key = cl + ' ' + edgeType;
+                                        var typeCount = metric.get(key);
+                                        if(typeCount === null){
+                                                typeCount = new ArrayList<Integer>();
+                                                metric.put(key, typeCount);
+                                        }
+                                        
+                                        // get or create sample list
+                                        typeCount.add(outgoingEdges.get(edgeType).get(node).size);
+                                }
+                        }
+                }
+                
+                return metric;
+        }
+        
+        override evaluate(GraphStatistic g) {
+                var metric = calculateMetric(g);
+                var output = new ArrayList<String[]>();
+                
+                output.add(newArrayList('Typed Out Degree'));
+                for(key : metric.keySet){
+                        var samples = metric.get(key);
+                        var String[] outputForOnePair = newArrayOfSize(samples.size+1);
+                        outputForOnePair.set(0, key);
+                        for(var i = 0; i < samples.size; i++){
+                                outputForOnePair.set(i+1, samples.get(i)+'');
+                        }
+                        output.add(outputForOnePair);
+                }
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                return calculateMetric(g);
+        }
+        
+}
\ No newline at end of file