1  #region License Information


2  /* HeuristicLab


3  * Copyright (C) 20022019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)


4  *


5  * This file is part of HeuristicLab.


6  *


7  * HeuristicLab is free software: you can redistribute it and/or modify


8  * it under the terms of the GNU General Public License as published by


9  * the Free Software Foundation, either version 3 of the License, or


10  * (at your option) any later version.


11  *


12  * HeuristicLab is distributed in the hope that it will be useful,


13  * but WITHOUT ANY WARRANTY; without even the implied warranty of


14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the


15  * GNU General Public License for more details.


16  *


17  * You should have received a copy of the GNU General Public License


18  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.


19  */


20  #endregion


21 


22  using HEAL.Attic;


23  using HeuristicLab.Common;


24  using HeuristicLab.Core;


25  using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;


26  using HeuristicLab.Problems.DataAnalysis.Symbolic;


27  using System;


28  using System.Collections.Generic;


29  using System.Linq;


30 


31  namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {


32  [Item("RankMap", "A map of models of models of models")]


33  [StorableType("1D4DD90E553A46DBB0CD6A899AA0B6D0")]


34  public class EMMRankMap : EMMMapBase<ISymbolicExpressionTree> { // it do not work absolutely


35  [Storable]


36  public List<List<double>> Probabilities { get; set; }


37  #region constructors


38  [StorableConstructor]


39  protected EMMRankMap(StorableConstructorFlag _) : base(_) { }


40  public override IDeepCloneable Clone(Cloner cloner) {


41  return new EMMRankMap(this, cloner);


42  }


43  public EMMRankMap() : base() {


44  ModelSet = new List<ISymbolicExpressionTree>();


45  Probabilities = new List<List<double>>();


46  }


47  public EMMRankMap(EMMRankMap original, Cloner cloner) : base(original, cloner) {


48  if (original.Probabilities != null) {


49  Probabilities = original.Probabilities.Select(x => x.ToList()).ToList();


50  }


51  }


52  #endregion


53  #region MapCreation


54  override public void CreateMap(IRandom random) {


55  MapSizeCheck(ModelSet.Count);


56  ApplyRankMapCreationAlgorithm(ModelSetPreparation.CalculateDistances(ModelSet), Map, Probabilities);


57  }


58  override public void CreateMap(IRandom random, ISymbolicDataAnalysisSingleObjectiveProblem problem) {


59  MapSizeCheck(ModelSet.Count);


60  ApplyRankMapCreationAlgorithm(ModelSetPreparation.DistanceMatrixCalculation(ModelSet, DistanceParametr, problem), Map, Probabilities);


61  }


62  override public void MapRead(IEnumerable<ISymbolicExpressionTree> trees) {


63  base.MapRead(trees);


64  MapFullment(trees.Count());


65  string fileName = ("Map" + DistanceParametr + ".txt");


66  Probabilities = FileComuncations.DoubleMatrixFromFileRead(fileName);


67  }


68  protected void MapFullment(int mapSize) {


69  if (Map != null) {


70  Map.Clear();


71  }


72  for (int t = 0; t < mapSize; t++) {


73  for (int i = 0; i < mapSize; i++) {


74  if (i == t)


75  continue;


76  Map[t].Add(i);


77  }


78  }


79  }


80  override public string[] MapToStoreInFile() { // Function that prepare Map to printing in .txt File: create a set of strings for future reading by computer


81  string[] s;


82  s = new string[Map.Count];


83  for (int i = 0; i < Map.Count; i++) {


84  s[i] = "";


85  for (int j = 0; j < (Map.Count  1); j++) {


86  s[i] += Probabilities[i][j].ToString();


87  if (j != (Map.Count  2)) { s[i] += " "; }


88  }


89  }


90  return s;


91  }


92  public static void ApplyRankMapCreationAlgorithm(double[,] distances, List<List<int>> map, List<List<double>> probabilities) {


93  int mapSize = distances.GetLength(0);


94  double tempSum = 0;


95  for (int i = 0; i < mapSize; i++) {


96  tempSum += i;


97  }


98  List<List<double>> currentList = new List<List<double>>();


99  for (int t = 0; t < mapSize; t++) {


100  for (int i = 0; i < mapSize; i++) {


101  if (distances[i, t].IsAlmost(0))


102  continue;


103  currentList.Add(new List<double>());


104  currentList[i].Add(i);


105  currentList[i].Add(distances[i, t]);


106  }


107  currentList.Sort((a, b) => a[1].CompareTo(b[1])); ///workable sorting


108  for (int i = 0; i < currentList.Count; i++) {


109  currentList[i].Add(currentList.Count  i);


110  }


111  probabilities.Add(new List<double>());


112  for (int i = 0; i < mapSize; i++) {


113  if (distances[i, t].IsAlmost(0))


114  continue;


115  map[t].Add(Convert.ToInt32(currentList[i][0]));


116  probabilities[t].Add(currentList[i][2] / tempSum);


117  }


118  currentList.Clear();


119  }


120  }


121  #endregion


122  #region Map Apply Functions


123  public override ISymbolicExpressionTree NewModelForMutation(IRandom random, out int treeNumber, int parentTreeNumber) {


124  treeNumber = Map[parentTreeNumber][HelpFunctions.OneElementFromListProportionalSelection(random, Probabilities[parentTreeNumber])];


125  return (ISymbolicExpressionTree)ModelSet[treeNumber].Clone();


126  }


127  override public ISymbolicExpressionTree NewModelForInizializtionNotTree(IRandom random, out int treeNumber) {


128  return NewModelForInizializtion(random, out treeNumber);


129  }


130  #endregion


131  }


132  }

