Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs	(revision 8627)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs	(revision 8725)
@@ -19,35 +19,43 @@
     public List<double> PartialInformationContent { get; private set; }
     public List<double> DensityBasinInformation { get; private set; }
+    public List<double> TotalEntropy { get; private set; } 
     public List<double> QualityDelta { get; private set; }
     public double InformationStability { get; private set; }
     public int Regularity { get; private set; }
+    public int Diversity { get; private set; }
     public Peak PeakInformationContent { get; private set; }
     public Peak PeakPartialInformationContent { get; private set; }
     public Peak PeakDensityBasinInformation { get; private set; }
+    public Peak PeakTotalEntropy { get; private set; }
 
-    public InformationAnalysis(IEnumerable<double> qualities, int nQuantiles) {
+    public InformationAnalysis(IList<double> qualities, int nQuantiles) {
       InformationContent = new List<double>();
       PartialInformationContent = new List<double>();
       DensityBasinInformation = new List<double>();
+      TotalEntropy = new List<double>();
       QualityDelta = new List<double>();
       PerformAnalysis(qualities, nQuantiles);
     }
 
-    private void PerformAnalysis(IEnumerable<double> qualities, int nQuantiles) {
+    private void PerformAnalysis(IList<double> qualities, int nQuantiles) {
       var differences = Differences(qualities).ToList();
       InformationStability = differences.Select(d => Math.Abs(d)).Max();
       Regularity = new HashSet<double>(differences).Count;
-      var thresholds = UniqueThresholdCalculator.DetermineThresholds(differences, nQuantiles).ToList();
+      Diversity = new HashSet<double>(qualities).Count;
+      //var thresholds = UniqueThresholdCalculator.DetermineThresholds(differences, nQuantiles).ToList();
+      var thresholds = differences.Select(d => Math.Abs(d)).OrderBy(d => d);
       foreach (var eps in thresholds) {
         var shapes = Shapes(eps, differences).ToList();
-        int[] shape_counts = CountShapes(shapes);
+        int[] shapeCounts = CountShapes(shapes);
         QualityDelta.Add(eps);
-        InformationContent.Add(CalculateInformationContent(shape_counts, shapes.Count));
+        InformationContent.Add(CalculateInformationContent(shapeCounts, shapes.Count));
         PartialInformationContent.Add(CalculatePartialInformationContent(eps, differences));
-        DensityBasinInformation.Add(CalculateDensityBasinInformation(shape_counts, shapes.Count));
+        DensityBasinInformation.Add(CalculateDensityBasinInformation(shapeCounts, shapes.Count));
+        TotalEntropy.Add(CalculateTotalEntropy(shapeCounts, shapes.Count));
       }
-      PeakDensityBasinInformation = GetPeak(QualityDelta, InformationContent);
+      PeakInformationContent = GetPeak(QualityDelta, InformationContent);
+      PeakDensityBasinInformation = GetPeak(QualityDelta, DensityBasinInformation);
       PeakPartialInformationContent = GetPeak(QualityDelta, PartialInformationContent);
-      PeakDensityBasinInformation = GetPeak(QualityDelta, DensityBasinInformation);
+      PeakTotalEntropy = GetPeak(QualityDelta, TotalEntropy);
     }
 
@@ -72,33 +80,37 @@
       return Utils.Delta(differences, (x, y) =>
         (Shape)
-          ((x >= eps ? 1 : (x <= -eps ? -1 : 0)) +
-           (y >= eps ? 3 : (y <= -eps ? -3 : 0))));
+          ((x > eps ? 1 : (x < -eps ? -1 : 0)) +
+           (y > eps ? 3 : (y < -eps ? -3 : 0))));
     }
 
-    private static double CalculateInformationContent(int[] shape_counts, int total_n_shapes) {
+    private static double CalculateInformationContent(int[] shapeCounts, int totalNShapes) {
       return
-        -Entropy(shape_counts[(int)Shape.EquDec + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.IncDec + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.DecEqu + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.IncEqu + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.DecInc + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.EquInc + 4], total_n_shapes, 6);
+        -Entropy(shapeCounts[(int)Shape.EquDec + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.IncDec + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.DecEqu + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.IncEqu + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.DecInc + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.EquInc + 4], totalNShapes, 6);
     }
 
-    private static double CalculateDensityBasinInformation(int[] shape_counts, int total_n_shapes) {
+    private static double CalculateDensityBasinInformation(int[] shapeCounts, int totalNShapes) {
       return
-        -Entropy(shape_counts[(int)Shape.DecDec + 4], total_n_shapes, 3)
-        - Entropy(shape_counts[(int)Shape.EquEqu + 4], total_n_shapes, 3)
-        - Entropy(shape_counts[(int)Shape.IncInc + 4], total_n_shapes, 3);
+        -Entropy(shapeCounts[(int)Shape.DecDec + 4], totalNShapes, 3)
+        - Entropy(shapeCounts[(int)Shape.EquEqu + 4], totalNShapes, 3)
+        - Entropy(shapeCounts[(int)Shape.IncInc + 4], totalNShapes, 3);
     }
 
-    private static double CalculatePartialInformationContent(double eps, List<double> differences) {
+    private static double CalculateTotalEntropy(int[] shapeCounts, int totalNShapes) {
+      return shapeCounts.Aggregate(0.0, (current, t) => current - Entropy(t, totalNShapes, 9));
+    }
+
+    private static double CalculatePartialInformationContent(double eps, ICollection<double> differences) {
       int slope = 0;
       int nPeaks = 0;
       foreach (var d in differences) {
-        if (d >= eps) {
+        if (d > eps) {
           if (slope < 0) nPeaks++;
           slope = +1;
-        } else if (d <= -eps) {
+        } else if (d < -eps) {
           if (slope > 0) nPeaks++;
           slope = -1;
@@ -109,16 +121,16 @@
 
     private static int[] CountShapes(IEnumerable<Shape> shapes) {
-      int[] shape_counts = new int[9];
+      int[] shapeCounts = new int[9];
       foreach (var s in shapes) {
-        shape_counts[(int)s + 4]++;
+        shapeCounts[(int)s + 4]++;
       }
-      return shape_counts;
+      return shapeCounts;
     }
 
-    private static double Entropy(int count, int total, int n_cases) {
+    private static double Entropy(int count, int total, int nCases) {
       if (count == 0)
         return 0;
       double freq = 1.0 * count / total;
-      return freq * Math.Log(freq, n_cases);
+      return freq * Math.Log(freq, nCases);
     }
 
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysisCalculator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysisCalculator.cs	(revision 8627)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysisCalculator.cs	(revision 8725)
@@ -25,4 +25,7 @@
       get { return (LookupParameter<IntValue>)Parameters["Regularity"]; }
     }
+    public LookupParameter<IntValue> DiversityParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Diversity"]; }
+    }
     public LookupParameter<DoubleArray> InformationContentParameter {
       get { return (LookupParameter<DoubleArray>)Parameters["InformationContent"]; }
@@ -34,4 +37,7 @@
       get { return (LookupParameter<DoubleArray>)Parameters["DensityBasinInformation"]; }
     }
+    public LookupParameter<DoubleArray> TotalEntropyParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["TotalEntropy"]; }
+    }
     public LookupParameter<DoubleArray> EpsilonQuantilesParameter {
       get { return (LookupParameter<DoubleArray>)Parameters["EpsilonQuantiles"]; }
@@ -42,13 +48,14 @@
     [StorableConstructor]
     protected InformationAnalysisCalculator(bool deserializing) : base(deserializing) { }
-    public InformationAnalysisCalculator()
-      : base() {
+    public InformationAnalysisCalculator() {
       Parameters.Add(new LookupParameter<DataTable>("QualityTrail", "Historical quality trail of a walk over a fitness landscape."));
       Parameters.Add(new ValueLookupParameter<IntValue>("NQuantiles", "Number of epsilon quantiles to calculate information analysis."));
       Parameters.Add(new LookupParameter<DoubleValue>("InformationStability"));
       Parameters.Add(new LookupParameter<IntValue>("Regularity"));
+      Parameters.Add(new LookupParameter<IntValue>("Diversity"));
       Parameters.Add(new LookupParameter<DoubleArray>("InformationContent"));
       Parameters.Add(new LookupParameter<DoubleArray>("PartialInformationContent"));
       Parameters.Add(new LookupParameter<DoubleArray>("DensityBasinInformation"));
+      Parameters.Add(new LookupParameter<DoubleArray>("TotalEntropy"));
       Parameters.Add(new LookupParameter<DoubleArray>("EpsilonQuantiles", "Considered values of epsilon, selected as quantiles of actual quality differences"));
     }
@@ -66,8 +73,10 @@
         NQuantilesParameter.ActualValue.Value);
       RegularityParameter.ActualValue = new IntValue(analysis.Regularity);
+      DiversityParameter.ActualValue = new IntValue(analysis.Diversity);
       InformationStabilityParameter.ActualValue = new DoubleValue(analysis.InformationStability);
       InformationContentParameter.ActualValue = new DoubleArray(analysis.InformationContent.ToArray());
       PartialInformationContentParameter.ActualValue = new DoubleArray(analysis.PartialInformationContent.ToArray());
       DensityBasinInformationParameter.ActualValue = new DoubleArray(analysis.DensityBasinInformation.ToArray());
+      TotalEntropyParameter.ActualValue = new DoubleArray(analysis.TotalEntropy.ToArray());
       EpsilonQuantilesParameter.ActualValue = new DoubleArray(analysis.QualityDelta.ToArray());
       return base.Apply();
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalyzer.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalyzer.cs	(revision 8627)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalyzer.cs	(revision 8725)
@@ -62,4 +62,7 @@
       get { return (LookupParameter<DoubleValue>)Parameters["DensityBasinInformationValue"]; }
     }
+    public LookupParameter<DoubleValue> TotalEntropyValueParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["TotalEntropyValue"]; }
+    }
     public LookupParameter<DoubleValue> InformationStabilityValueParameter {
       get { return (LookupParameter<DoubleValue>)Parameters["InformationStabilityValue"]; }
@@ -68,4 +71,25 @@
       get { return (LookupParameter<IntValue>)Parameters["RegularityValue"]; }
     }
+    public LookupParameter<IntValue> DiversityValueParameter {
+      get { return (LookupParameter<IntValue>)Parameters["DiversityValue"]; }
+    }
+
+    #region Peaks
+    public LookupParameter<DoubleValue> PeakInformationContentParameter {
+      get { return (LookupParameter<DoubleValue>) Parameters["PeakInformationContent"]; }
+    }
+    public LookupParameter<DoubleValue> PeakInformationContentQualityDeltaParameter {
+      get { return (LookupParameter<DoubleValue>) Parameters["PeakInformationContentQualityDelta"]; }
+    }
+    public LookupParameter<DoubleValue> PeakDensityBasinInformationParameter {
+      get { return (LookupParameter<DoubleValue>) Parameters["PeakDensityBasinInformation"]; }
+    }
+    public LookupParameter<DoubleValue> PeakDensityBasinInformationQualityDeltaParameter {
+      get { return (LookupParameter<DoubleValue>) Parameters["PeakDensityBasinInformationQualityDelta"]; }
+    }
+
+
+    #endregion
+
     #endregion
 
@@ -82,8 +106,10 @@
       set { DensityBasinInformationValueParameter.ActualValue = new DoubleValue(value); }
     }
+    private double TotalEntropyValue {
+      set { TotalEntropyValueParameter.ActualValue = new DoubleValue(value); }
+    }
     private double InformationStabilityValue {
       set { InformationStabilityValueParameter.ActualValue = new DoubleValue(value); }
     }
-
 
     [StorableConstructor]
@@ -100,6 +126,12 @@
       Parameters.Add(new LookupParameter<DoubleValue>("PartialInformationContentValue", "Partial information content M(0) at eps = 0"));
       Parameters.Add(new LookupParameter<DoubleValue>("DensityBasinInformationValue", "Density Basin Information h(0) at eps = 0"));
+      Parameters.Add(new LookupParameter<DoubleValue>("TotalEntropyValue", "The overall disorder in the trajectory"));
       Parameters.Add(new LookupParameter<DoubleValue>("InformationStabilityValue", "Information Stability Value"));
       Parameters.Add(new LookupParameter<IntValue>("RegularityValue", "The number of different quality differences"));
+      Parameters.Add(new LookupParameter<IntValue>("DiversityValue", "The number of different quality values"));
+      Parameters.Add(new LookupParameter<DoubleValue>("PeakInformationContent", "Maximum information content at any quality delta."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PeakInformationContentQualityDelta", "Quality delta with maximum information content."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PeakDensityBasinInformation", "Maximum density basin information at any quality delta."));
+      Parameters.Add(new LookupParameter<DoubleValue>("PeakDensityBasinInformationQualityDelta", "Quality delta with maximum density basin information."));
 
       var resultsCollector = new ResultsCollector();
@@ -109,7 +141,12 @@
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(PartialInformationContentValueParameter.Name));
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(DensityBasinInformationValueParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(TotalEntropyValueParameter.Name));
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(InformationStabilityValueParameter.Name));
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(RegularityValueParameter.Name));
-
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(DiversityValueParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(PeakInformationContentParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(PeakInformationContentQualityDeltaParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(PeakDensityBasinInformationParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(PeakDensityBasinInformationQualityDeltaParameter.Name));
 
       OperatorGraph.InitialOperator = resultsCollector;
@@ -139,8 +176,11 @@
         var partialInformationContent = informationTable.Rows["Partial Information Content"].Values;
         var densityBasinInformation = informationTable.Rows["Density Basin Information"].Values;
+        var totalEntropy = informationTable.Rows["Total Entropy"].Values;
         var qualityDelta = informationTable.Rows["Quality Delta"].Values;
         var analysis = new InformationAnalysis(qualities, nQuantiles);
         InformationStability.Rows["Regularity"].Values.Add(analysis.Regularity);
+        InformationStability.Rows["Diversity"].Values.Add(analysis.Diversity);
         InformationStability.Rows["Relative Regularity"].Values.Add(1.0 * analysis.Regularity / qualities.Count);
+        InformationStability.Rows["Relative Diversity"].Values.Add(1.0 * analysis.Diversity / qualities.Count);
         InformationStability.Rows["Information Stability"].Values.Add(analysis.InformationStability);
         informationContent.Clear();
@@ -150,4 +190,6 @@
         densityBasinInformation.Clear();
         densityBasinInformation.AddRange(analysis.DensityBasinInformation);
+        totalEntropy.Clear();
+        totalEntropy.AddRange(analysis.TotalEntropy);
         qualityDelta.Clear();
         qualityDelta.AddRange(analysis.QualityDelta);
@@ -157,4 +199,9 @@
         InformationStabilityValue = analysis.InformationStability;
         RegularityValueParameter.ActualValue = new IntValue(analysis.Regularity);
+        DiversityValueParameter.ActualValue = new IntValue(analysis.Diversity);
+        PeakInformationContentParameter.ActualValue = new DoubleValue(analysis.PeakInformationContent.Value);
+        PeakDensityBasinInformationParameter.ActualValue = new DoubleValue(analysis.PeakDensityBasinInformation.Value);
+        PeakInformationContentQualityDeltaParameter.ActualValue = new DoubleValue(analysis.PeakInformationContent.QualityDelta);
+        PeakDensityBasinInformationQualityDeltaParameter.ActualValue = new DoubleValue(analysis.PeakDensityBasinInformation.QualityDelta);
       }
     }
@@ -167,7 +214,6 @@
         information.Rows.Add(new DataRow("Partial Information Content"));
         information.Rows.Add(new DataRow("Density Basin Information"));
-        var row = new DataRow("Quality Delta");
-        row.VisualProperties.SecondYAxis = true;
-        information.Rows.Add(row);
+        information.Rows.Add(new DataRow("Total Entropy"));
+        information.Rows.Add(new DataRow("Quality Delta") {VisualProperties = {SecondYAxis = true}});
         InformationParameter.ActualValue = information;
       }
@@ -180,7 +226,7 @@
         informationStability.Rows.Add(new DataRow("Information Stability"));
         informationStability.Rows.Add(new DataRow("Relative Regularity"));
-        var row = new DataRow("Regularity");
-        row.VisualProperties.SecondYAxis = true;
-        informationStability.Rows.Add(row);
+        informationStability.Rows.Add(new DataRow("Relative Diversity"));
+        informationStability.Rows.Add(new DataRow("Regularity") {VisualProperties = {SecondYAxis = true}});
+        informationStability.Rows.Add(new DataRow("Diversity") {VisualProperties = {SecondYAxis = true}});
         InformationStabilityParameter.ActualValue = informationStability;
       }
