Пример #1
0
 protected HeatMap(HeatMap original, Cloner cloner)
     : base(original, cloner)
 {
     this.title   = original.title;
     this.minimum = original.minimum;
     this.maximum = original.maximum;
 }
        public override IOperation Apply()
        {
            int      updateInterval = UpdateIntervalParameter.Value.Value;
            IntValue updateCounter  = UpdateCounterParameter.ActualValue;

            // if counter does not yet exist then initialize it with update interval
            // to make sure the solutions are analyzed on the first application of this operator
            if (updateCounter == null)
            {
                updateCounter = new IntValue(updateInterval);
                UpdateCounterParameter.ActualValue = updateCounter;
            }
            //analyze solutions only every 'updateInterval' times
            if (updateCounter.Value != updateInterval)
            {
                updateCounter.Value++;
                return(base.Apply());
            }
            updateCounter.Value = 1;

            bool storeHistory = StoreHistoryParameter.Value.Value;
            int  count        = CurrentScopeParameter.ActualValue.SubScopes.Count;

            if (count > 1)
            {
                var similarityCalculator = SimilarityCalculatorParameter.Value;
                // calculate solution similarities
                var similarityMatrix = similarityCalculator.CalculateSolutionCrowdSimilarity(CurrentScopeParameter.ActualValue);
                double[,] similarities = new double[similarityMatrix.Length, similarityMatrix[0].Length];
                for (int i = 0; i < similarityMatrix.Length; i++)
                {
                    for (int j = 0; j < similarityMatrix[0].Length; j++)
                    {
                        similarities[i, j] = similarityMatrix[i][j];
                    }
                }

                // calculate minimum, average and maximum similarities
                double   similarity;
                double[] minSimilarities = new double[count];
                double[] avgSimilarities = new double[count];
                double[] maxSimilarities = new double[count];
                for (int i = 0; i < count; i++)
                {
                    minSimilarities[i] = 1;
                    avgSimilarities[i] = 0;
                    maxSimilarities[i] = 0;
                    for (int j = 0; j < count; j++)
                    {
                        if (i != j)
                        {
                            similarity = similarities[i, j];

                            if ((similarity < 0) || (similarity > 1))
                            {
                                throw new InvalidOperationException("Solution similarities have to be in the interval [0;1].");
                            }

                            if (minSimilarities[i] > similarity)
                            {
                                minSimilarities[i] = similarity;
                            }
                            avgSimilarities[i] += similarity;
                            if (maxSimilarities[i] < similarity)
                            {
                                maxSimilarities[i] = similarity;
                            }
                        }
                    }
                    avgSimilarities[i] = avgSimilarities[i] / (count - 1);
                }
                double avgMinSimilarity = minSimilarities.Average();
                double avgAvgSimilarity = avgSimilarities.Average();
                double avgMaxSimilarity = maxSimilarities.Average();

                // fetch results collection
                ResultCollection results;
                if (!ResultsParameter.ActualValue.ContainsKey(DiversityResultName))
                {
                    results = new ResultCollection();
                    ResultsParameter.ActualValue.Add(new Result(DiversityResultName, results));
                }
                else
                {
                    results = (ResultCollection)ResultsParameter.ActualValue[DiversityResultName].Value;
                }

                // store similarities
                HeatMap similaritiesHeatMap = new HeatMap(similarities, "Solution Similarities", 0.0, 1.0);
                if (!results.ContainsKey("Solution Similarities"))
                {
                    results.Add(new Result("Solution Similarities", similaritiesHeatMap));
                }
                else
                {
                    results["Solution Similarities"].Value = similaritiesHeatMap;
                }

                // store similarities history
                if (storeHistory)
                {
                    if (!results.ContainsKey("Solution Similarities History"))
                    {
                        HeatMapHistory history = new HeatMapHistory();
                        history.Add(similaritiesHeatMap);
                        results.Add(new Result("Solution Similarities History", history));
                    }
                    else
                    {
                        ((HeatMapHistory)results["Solution Similarities History"].Value).Add(similaritiesHeatMap);
                    }
                }

                // store average minimum, average and maximum similarity
                if (!results.ContainsKey("Average Minimum Solution Similarity"))
                {
                    results.Add(new Result("Average Minimum Solution Similarity", new DoubleValue(avgMinSimilarity)));
                }
                else
                {
                    ((DoubleValue)results["Average Minimum Solution Similarity"].Value).Value = avgMinSimilarity;
                }

                if (!results.ContainsKey("Average Average Solution Similarity"))
                {
                    results.Add(new Result("Average Average Solution Similarity", new DoubleValue(avgAvgSimilarity)));
                }
                else
                {
                    ((DoubleValue)results["Average Average Solution Similarity"].Value).Value = avgAvgSimilarity;
                }

                if (!results.ContainsKey("Average Maximum Solution Similarity"))
                {
                    results.Add(new Result("Average Maximum Solution Similarity", new DoubleValue(avgMaxSimilarity)));
                }
                else
                {
                    ((DoubleValue)results["Average Maximum Solution Similarity"].Value).Value = avgMaxSimilarity;
                }

                // store average minimum, average and maximum solution similarity data table
                DataTable minAvgMaxSimilarityDataTable;
                if (!results.ContainsKey("Average Minimum/Average/Maximum Solution Similarity"))
                {
                    minAvgMaxSimilarityDataTable = new DataTable("Average Minimum/Average/Maximum Solution Similarity");
                    minAvgMaxSimilarityDataTable.VisualProperties.XAxisTitle = "Iteration";
                    minAvgMaxSimilarityDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
                    minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Minimum Solution Similarity", null));
                    minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].VisualProperties.StartIndexZero = true;
                    minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Average Solution Similarity", null));
                    minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].VisualProperties.StartIndexZero = true;
                    minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Maximum Solution Similarity", null));
                    minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].VisualProperties.StartIndexZero = true;
                    results.Add(new Result("Average Minimum/Average/Maximum Solution Similarity", minAvgMaxSimilarityDataTable));
                }
                else
                {
                    minAvgMaxSimilarityDataTable = (DataTable)results["Average Minimum/Average/Maximum Solution Similarity"].Value;
                }
                minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].Values.Add(avgMinSimilarity);
                minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].Values.Add(avgAvgSimilarity);
                minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].Values.Add(avgMaxSimilarity);

                // store minimum, average, maximum similarities data table
                DataTable minAvgMaxSimilaritiesDataTable = new DataTable("Minimum/Average/Maximum Solution Similarities");
                minAvgMaxSimilaritiesDataTable.VisualProperties.XAxisTitle = "Solution Index";
                minAvgMaxSimilaritiesDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
                minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Minimum Solution Similarity", null, minSimilarities));
                minAvgMaxSimilaritiesDataTable.Rows["Minimum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Average Solution Similarity", null, avgSimilarities));
                minAvgMaxSimilaritiesDataTable.Rows["Average Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Maximum Solution Similarity", null, maxSimilarities));
                minAvgMaxSimilaritiesDataTable.Rows["Maximum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities"))
                {
                    results.Add(new Result("Minimum/Average/Maximum Solution Similarities", minAvgMaxSimilaritiesDataTable));
                }
                else
                {
                    results["Minimum/Average/Maximum Solution Similarities"].Value = minAvgMaxSimilaritiesDataTable;
                }

                // store minimum, average, maximum similarities history
                if (storeHistory)
                {
                    if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities History"))
                    {
                        DataTableHistory history = new DataTableHistory();
                        history.Add(minAvgMaxSimilaritiesDataTable);
                        results.Add(new Result("Minimum/Average/Maximum Solution Similarities History", history));
                    }
                    else
                    {
                        ((DataTableHistory)results["Minimum/Average/Maximum Solution Similarities History"].Value).Add(minAvgMaxSimilaritiesDataTable);
                    }
                }
            }
            return(base.Apply());
        }
        public override IOperation Apply()
        {
            int      updateInterval = UpdateIntervalParameter.Value.Value;
            IntValue updateCounter  = UpdateCounterParameter.ActualValue;

            // if counter does not yet exist then initialize it with update interval
            // to make sure the solutions are analyzed on the first application of this operator
            if (updateCounter == null)
            {
                updateCounter = new IntValue(updateInterval);
                UpdateCounterParameter.ActualValue = updateCounter;
            }
            else
            {
                updateCounter.Value++;
            }

            //analyze solutions only every 'updateInterval' times
            if (updateCounter.Value == updateInterval)
            {
                updateCounter.Value = 0;

                bool                    max          = MaximizationParameter.ActualValue.Value;
                ItemArray <T>           solutions    = SolutionParameter.ActualValue;
                ItemArray <DoubleValue> qualities    = QualityParameter.ActualValue;
                bool                    storeHistory = StoreHistoryParameter.Value.Value;
                int count = solutions.Length;

                if (count > 1)
                {
                    // sort solutions by quality
                    T[] sortedSolutions = null;
                    if (max)
                    {
                        sortedSolutions = solutions
                                          .Select((x, index) => new { Solution = x, Quality = qualities[index] })
                                          .OrderByDescending(x => x.Quality)
                                          .Select(x => x.Solution)
                                          .ToArray();
                    }
                    else
                    {
                        sortedSolutions = solutions
                                          .Select((x, index) => new { Solution = x, Quality = qualities[index] })
                                          .OrderBy(x => x.Quality)
                                          .Select(x => x.Solution)
                                          .ToArray();
                    }

                    // calculate solution similarities
                    double[,] similarities = CalculateSimilarities(sortedSolutions);

                    // calculate minimum, average and maximum similarities
                    double   similarity;
                    double[] minSimilarities = new double[count];
                    double[] avgSimilarities = new double[count];
                    double[] maxSimilarities = new double[count];
                    for (int i = 0; i < count; i++)
                    {
                        minSimilarities[i] = 1;
                        avgSimilarities[i] = 0;
                        maxSimilarities[i] = 0;
                        for (int j = 0; j < count; j++)
                        {
                            if (i != j)
                            {
                                similarity = similarities[i, j];

                                if ((similarity < 0) || (similarity > 1))
                                {
                                    throw new InvalidOperationException("Solution similarities have to be in the interval [0;1].");
                                }

                                if (minSimilarities[i] > similarity)
                                {
                                    minSimilarities[i] = similarity;
                                }
                                avgSimilarities[i] += similarity;
                                if (maxSimilarities[i] < similarity)
                                {
                                    maxSimilarities[i] = similarity;
                                }
                            }
                        }
                        avgSimilarities[i] = avgSimilarities[i] / (count - 1);
                    }
                    double avgMinSimilarity = minSimilarities.Average();
                    double avgAvgSimilarity = avgSimilarities.Average();
                    double avgMaxSimilarity = maxSimilarities.Average();

                    // fetch results collection
                    ResultCollection results;
                    if (!ResultsParameter.ActualValue.ContainsKey(Name + " Results"))
                    {
                        results = new ResultCollection();
                        ResultsParameter.ActualValue.Add(new Result(Name + " Results", results));
                    }
                    else
                    {
                        results = (ResultCollection)ResultsParameter.ActualValue[Name + " Results"].Value;
                    }

                    // store similarities
                    HeatMap similaritiesHeatMap = new HeatMap(similarities, "Solution Similarities", 0.0, 1.0);
                    if (!results.ContainsKey("Solution Similarities"))
                    {
                        results.Add(new Result("Solution Similarities", similaritiesHeatMap));
                    }
                    else
                    {
                        results["Solution Similarities"].Value = similaritiesHeatMap;
                    }

                    // store similarities history
                    if (storeHistory)
                    {
                        if (!results.ContainsKey("Solution Similarities History"))
                        {
                            HeatMapHistory history = new HeatMapHistory();
                            history.Add(similaritiesHeatMap);
                            results.Add(new Result("Solution Similarities History", history));
                        }
                        else
                        {
                            ((HeatMapHistory)results["Solution Similarities History"].Value).Add(similaritiesHeatMap);
                        }
                    }

                    // store average minimum, average and maximum similarity
                    if (!results.ContainsKey("Average Minimum Solution Similarity"))
                    {
                        results.Add(new Result("Average Minimum Solution Similarity", new DoubleValue(avgMinSimilarity)));
                    }
                    else
                    {
                        ((DoubleValue)results["Average Minimum Solution Similarity"].Value).Value = avgMinSimilarity;
                    }

                    if (!results.ContainsKey("Average Average Solution Similarity"))
                    {
                        results.Add(new Result("Average Average Solution Similarity", new DoubleValue(avgAvgSimilarity)));
                    }
                    else
                    {
                        ((DoubleValue)results["Average Average Solution Similarity"].Value).Value = avgAvgSimilarity;
                    }

                    if (!results.ContainsKey("Average Maximum Solution Similarity"))
                    {
                        results.Add(new Result("Average Maximum Solution Similarity", new DoubleValue(avgMaxSimilarity)));
                    }
                    else
                    {
                        ((DoubleValue)results["Average Maximum Solution Similarity"].Value).Value = avgMaxSimilarity;
                    }

                    // store average minimum, average and maximum solution similarity data table
                    DataTable minAvgMaxSimilarityDataTable;
                    if (!results.ContainsKey("Average Minimum/Average/Maximum Solution Similarity"))
                    {
                        minAvgMaxSimilarityDataTable = new DataTable("Average Minimum/Average/Maximum Solution Similarity");
                        minAvgMaxSimilarityDataTable.VisualProperties.XAxisTitle = "Iteration";
                        minAvgMaxSimilarityDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
                        minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Minimum Solution Similarity", null));
                        minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].VisualProperties.StartIndexZero = true;
                        minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Average Solution Similarity", null));
                        minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].VisualProperties.StartIndexZero = true;
                        minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Maximum Solution Similarity", null));
                        minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].VisualProperties.StartIndexZero = true;
                        results.Add(new Result("Average Minimum/Average/Maximum Solution Similarity", minAvgMaxSimilarityDataTable));
                    }
                    else
                    {
                        minAvgMaxSimilarityDataTable = (DataTable)results["Average Minimum/Average/Maximum Solution Similarity"].Value;
                    }
                    minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].Values.Add(avgMinSimilarity);
                    minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].Values.Add(avgAvgSimilarity);
                    minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].Values.Add(avgMaxSimilarity);

                    // store minimum, average, maximum similarities data table
                    DataTable minAvgMaxSimilaritiesDataTable = new DataTable("Minimum/Average/Maximum Solution Similarities");
                    minAvgMaxSimilaritiesDataTable.VisualProperties.XAxisTitle = "Solution Index";
                    minAvgMaxSimilaritiesDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
                    minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Minimum Solution Similarity", null, minSimilarities));
                    minAvgMaxSimilaritiesDataTable.Rows["Minimum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                    minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Average Solution Similarity", null, avgSimilarities));
                    minAvgMaxSimilaritiesDataTable.Rows["Average Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                    minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Maximum Solution Similarity", null, maxSimilarities));
                    minAvgMaxSimilaritiesDataTable.Rows["Maximum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
                    if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities"))
                    {
                        results.Add(new Result("Minimum/Average/Maximum Solution Similarities", minAvgMaxSimilaritiesDataTable));
                    }
                    else
                    {
                        results["Minimum/Average/Maximum Solution Similarities"].Value = minAvgMaxSimilaritiesDataTable;
                    }

                    // store minimum, average, maximum similarities history
                    if (storeHistory)
                    {
                        if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities History"))
                        {
                            DataTableHistory history = new DataTableHistory();
                            history.Add(minAvgMaxSimilaritiesDataTable);
                            results.Add(new Result("Minimum/Average/Maximum Solution Similarities History", history));
                        }
                        else
                        {
                            ((DataTableHistory)results["Minimum/Average/Maximum Solution Similarities History"].Value).Add(minAvgMaxSimilaritiesDataTable);
                        }
                    }
                }
            }
            return(base.Apply());
        }
    public override IOperation Apply() {
      int updateInterval = UpdateIntervalParameter.Value.Value;
      IntValue updateCounter = UpdateCounterParameter.ActualValue;
      // if counter does not yet exist then initialize it with update interval
      // to make sure the solutions are analyzed on the first application of this operator
      if (updateCounter == null) {
        updateCounter = new IntValue(updateInterval);
        UpdateCounterParameter.ActualValue = updateCounter;
      } else updateCounter.Value++;

      //analyze solutions only every 'updateInterval' times
      if (updateCounter.Value == updateInterval) {
        updateCounter.Value = 0;

        bool max = MaximizationParameter.ActualValue.Value;
        ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
        bool storeHistory = StoreHistoryParameter.Value.Value;
        int count = CurrentScopeParameter.ActualValue.SubScopes.Count;

        if (count > 1) {
          // calculate solution similarities
          var similarityMatrix = SimilarityCalculator.CalculateSolutionCrowdSimilarity(CurrentScopeParameter.ActualValue);

          // sort similarities by quality
          double[][] sortedSimilarityMatrix = null;
          if (max)
            sortedSimilarityMatrix = similarityMatrix
              .Select((x, index) => new { Solutions = x, Quality = qualities[index] })
              .OrderByDescending(x => x.Quality)
              .Select(x => x.Solutions)
              .ToArray();
          else
            sortedSimilarityMatrix = similarityMatrix
              .Select((x, index) => new { Solutions = x, Quality = qualities[index] })
              .OrderBy(x => x.Quality)
              .Select(x => x.Solutions)
              .ToArray();

          double[,] similarities = new double[similarityMatrix.Length, similarityMatrix[0].Length];
          for (int i = 0; i < similarityMatrix.Length; i++)
            for (int j = 0; j < similarityMatrix[0].Length; j++)
              similarities[i, j] = similarityMatrix[i][j];

          // calculate minimum, average and maximum similarities
          double similarity;
          double[] minSimilarities = new double[count];
          double[] avgSimilarities = new double[count];
          double[] maxSimilarities = new double[count];
          for (int i = 0; i < count; i++) {
            minSimilarities[i] = 1;
            avgSimilarities[i] = 0;
            maxSimilarities[i] = 0;
            for (int j = 0; j < count; j++) {
              if (i != j) {
                similarity = similarities[i, j];

                if ((similarity < 0) || (similarity > 1))
                  throw new InvalidOperationException("Solution similarities have to be in the interval [0;1].");

                if (minSimilarities[i] > similarity) minSimilarities[i] = similarity;
                avgSimilarities[i] += similarity;
                if (maxSimilarities[i] < similarity) maxSimilarities[i] = similarity;
              }
            }
            avgSimilarities[i] = avgSimilarities[i] / (count - 1);
          }
          double avgMinSimilarity = minSimilarities.Average();
          double avgAvgSimilarity = avgSimilarities.Average();
          double avgMaxSimilarity = maxSimilarities.Average();

          // fetch results collection
          ResultCollection results;
          if (!ResultsParameter.ActualValue.ContainsKey(Name + " Results")) {
            results = new ResultCollection();
            ResultsParameter.ActualValue.Add(new Result(Name + " Results", results));
          } else {
            results = (ResultCollection)ResultsParameter.ActualValue[Name + " Results"].Value;
          }

          // store similarities
          HeatMap similaritiesHeatMap = new HeatMap(similarities, "Solution Similarities", 0.0, 1.0);
          if (!results.ContainsKey("Solution Similarities"))
            results.Add(new Result("Solution Similarities", similaritiesHeatMap));
          else
            results["Solution Similarities"].Value = similaritiesHeatMap;

          // store similarities history
          if (storeHistory) {
            if (!results.ContainsKey("Solution Similarities History")) {
              HeatMapHistory history = new HeatMapHistory();
              history.Add(similaritiesHeatMap);
              results.Add(new Result("Solution Similarities History", history));
            } else {
              ((HeatMapHistory)results["Solution Similarities History"].Value).Add(similaritiesHeatMap);
            }
          }

          // store average minimum, average and maximum similarity
          if (!results.ContainsKey("Average Minimum Solution Similarity"))
            results.Add(new Result("Average Minimum Solution Similarity", new DoubleValue(avgMinSimilarity)));
          else
            ((DoubleValue)results["Average Minimum Solution Similarity"].Value).Value = avgMinSimilarity;

          if (!results.ContainsKey("Average Average Solution Similarity"))
            results.Add(new Result("Average Average Solution Similarity", new DoubleValue(avgAvgSimilarity)));
          else
            ((DoubleValue)results["Average Average Solution Similarity"].Value).Value = avgAvgSimilarity;

          if (!results.ContainsKey("Average Maximum Solution Similarity"))
            results.Add(new Result("Average Maximum Solution Similarity", new DoubleValue(avgMaxSimilarity)));
          else
            ((DoubleValue)results["Average Maximum Solution Similarity"].Value).Value = avgMaxSimilarity;

          // store average minimum, average and maximum solution similarity data table
          DataTable minAvgMaxSimilarityDataTable;
          if (!results.ContainsKey("Average Minimum/Average/Maximum Solution Similarity")) {
            minAvgMaxSimilarityDataTable = new DataTable("Average Minimum/Average/Maximum Solution Similarity");
            minAvgMaxSimilarityDataTable.VisualProperties.XAxisTitle = "Iteration";
            minAvgMaxSimilarityDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
            minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Minimum Solution Similarity", null));
            minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].VisualProperties.StartIndexZero = true;
            minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Average Solution Similarity", null));
            minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].VisualProperties.StartIndexZero = true;
            minAvgMaxSimilarityDataTable.Rows.Add(new DataRow("Average Maximum Solution Similarity", null));
            minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].VisualProperties.StartIndexZero = true;
            results.Add(new Result("Average Minimum/Average/Maximum Solution Similarity", minAvgMaxSimilarityDataTable));
          } else {
            minAvgMaxSimilarityDataTable = (DataTable)results["Average Minimum/Average/Maximum Solution Similarity"].Value;
          }
          minAvgMaxSimilarityDataTable.Rows["Average Minimum Solution Similarity"].Values.Add(avgMinSimilarity);
          minAvgMaxSimilarityDataTable.Rows["Average Average Solution Similarity"].Values.Add(avgAvgSimilarity);
          minAvgMaxSimilarityDataTable.Rows["Average Maximum Solution Similarity"].Values.Add(avgMaxSimilarity);

          // store minimum, average, maximum similarities data table
          DataTable minAvgMaxSimilaritiesDataTable = new DataTable("Minimum/Average/Maximum Solution Similarities");
          minAvgMaxSimilaritiesDataTable.VisualProperties.XAxisTitle = "Solution Index";
          minAvgMaxSimilaritiesDataTable.VisualProperties.YAxisTitle = "Solution Similarity";
          minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Minimum Solution Similarity", null, minSimilarities));
          minAvgMaxSimilaritiesDataTable.Rows["Minimum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
          minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Average Solution Similarity", null, avgSimilarities));
          minAvgMaxSimilaritiesDataTable.Rows["Average Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
          minAvgMaxSimilaritiesDataTable.Rows.Add(new DataRow("Maximum Solution Similarity", null, maxSimilarities));
          minAvgMaxSimilaritiesDataTable.Rows["Maximum Solution Similarity"].VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
          if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities")) {
            results.Add(new Result("Minimum/Average/Maximum Solution Similarities", minAvgMaxSimilaritiesDataTable));
          } else {
            results["Minimum/Average/Maximum Solution Similarities"].Value = minAvgMaxSimilaritiesDataTable;
          }

          // store minimum, average, maximum similarities history
          if (storeHistory) {
            if (!results.ContainsKey("Minimum/Average/Maximum Solution Similarities History")) {
              DataTableHistory history = new DataTableHistory();
              history.Add(minAvgMaxSimilaritiesDataTable);
              results.Add(new Result("Minimum/Average/Maximum Solution Similarities History", history));
            } else {
              ((DataTableHistory)results["Minimum/Average/Maximum Solution Similarities History"].Value).Add(minAvgMaxSimilaritiesDataTable);
            }
          }
        }
      }
      return base.Apply();
    }
Пример #5
0
 protected HeatMap(HeatMap original, Cloner cloner)
   : base(original, cloner) {
   this.title = original.title;
   this.minimum = original.minimum;
   this.maximum = original.maximum;
 }