Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/04/19 16:03:48 (5 years ago)
Author:
mkommend
Message:

#2958: Merged 16266, 16269, 16274, 16276, 16277, 16285, 16286, 16287, 16289, 16293, 16296, 16297, 16298, 16333, 16334 into stable.

Location:
stable
Files:
2 edited
4 copied

Legend:

Unmodified
Added
Removed
  • stable

  • stable/HeuristicLab.Problems.DataAnalysis.Symbolic

  • stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs

    r16287 r17071  
    6464        a[i] = Math.Cos(b[i]);
    6565    }
     66
     67    public static void Tan(double[] a, double[] b) {
     68      for (int i = 0; i < BATCHSIZE; ++i)
     69        a[i] = Math.Tan(b[i]);
     70    }
     71
     72    public static void Pow(double[] a, double[] b) {
     73      for (int i = 0; i < BATCHSIZE; ++i)
     74        a[i] = Math.Pow(a[i], Math.Round(b[i]));
     75    }
     76
     77    public static void Root(double[] a, double[] b) {
     78      for (int i = 0; i < BATCHSIZE; ++i)
     79        a[i] = Math.Pow(a[i], 1 / Math.Round(b[i]));
     80    }
     81
     82    public static void Square(double[] a, double[] b) {
     83      for (int i = 0; i < BATCHSIZE; ++i)
     84        a[i] = Math.Pow(b[i], 2d);
     85    }
     86
     87    public static void Sqrt(double[] a, double[] b) {
     88      for (int i = 0; i < BATCHSIZE; ++i)
     89        a[i] = Math.Sqrt(b[i]);
     90    }
    6691  }
    6792}
  • stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

    r16287 r17071  
    1111
    1212using static HeuristicLab.Problems.DataAnalysis.Symbolic.BatchOperations;
    13 //using static HeuristicLab.Problems.DataAnalysis.Symbolic.BatchOperationsVector;
    1413
    1514namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
     
    6564              break;
    6665            }
     66
    6767          case OpCodes.Add: {
    6868              Load(instr.buf, code[c].buf);
     
    7676              if (n == 1) {
    7777                Neg(instr.buf, code[c].buf);
    78                 break;
    7978              } else {
    8079                Load(instr.buf, code[c].buf);
     
    8281                  Sub(instr.buf, code[c + j].buf);
    8382                }
    84                 break;
    85               }
     83              }
     84              break;
    8685            }
    8786
     
    9796              if (n == 1) {
    9897                Inv(instr.buf, code[c].buf);
    99                 break;
    10098              } else {
    10199                Load(instr.buf, code[c].buf);
     
    103101                  Div(instr.buf, code[c + j].buf);
    104102                }
    105                 break;
    106               }
     103              }
     104              break;
     105            }
     106
     107          case OpCodes.Square: {
     108              Square(instr.buf, code[c].buf);
     109              break;
     110            }
     111
     112          case OpCodes.Root: {
     113              Root(instr.buf, code[c].buf);
     114              break;
     115            }
     116
     117          case OpCodes.SquareRoot: {
     118              Sqrt(instr.buf, code[c].buf);
     119              break;
     120            }
     121
     122          case OpCodes.Power: {
     123              Pow(instr.buf, code[c].buf);
     124              break;
    107125            }
    108126
     
    116134              break;
    117135            }
     136
     137          case OpCodes.Sin: {
     138              Sin(instr.buf, code[c].buf);
     139              break;
     140            }
     141
     142          case OpCodes.Cos: {
     143              Cos(instr.buf, code[c].buf);
     144              break;
     145            }
     146
     147          case OpCodes.Tan: {
     148              Tan(instr.buf, code[c].buf);
     149              break;
     150            }
    118151        }
    119152      }
     153    }
     154
     155    [ThreadStatic]
     156    private Dictionary<string, double[]> cachedData;
     157
     158    private void InitCache(IDataset dataset) {
     159      cachedData = new Dictionary<string, double[]>();
     160      foreach (var v in dataset.DoubleVariables) {
     161        var values = dataset.GetDoubleValues(v).ToArray();
     162      }
     163    }
     164
     165    public void InitializeState() {
     166      cachedData = null;
     167      EvaluatedSolutions = 0;
    120168    }
    121169
    122170    private double[] GetValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
    123171      var code = Compile(tree, dataset, OpCodes.MapSymbolToOpCode);
    124 
    125172      var remainingRows = rows.Length % BATCHSIZE;
    126173      var roundedTotal = rows.Length - remainingRows;
     
    141188    }
    142189
     190    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
     191      if (cachedData == null) {
     192        InitCache(dataset);
     193      }
     194      return GetValues(tree, dataset, rows);
     195    }
     196
    143197    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
    144       return GetValues(tree, dataset, rows.ToArray());
    145     }
    146 
    147     public void InitializeState() {
     198      return GetSymbolicExpressionTreeValues(tree, dataset, rows.ToArray());
    148199    }
    149200
     
    152203      var code = new BatchInstruction[root.GetLength()];
    153204      if (root.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
    154       code[0] = new BatchInstruction { narg = (ushort)root.SubtreeCount, opcode = opCodeMapper(root) };
    155205      int c = 1, i = 0;
    156206      foreach (var node in root.IterateNodesBreadth()) {
    157         for (int j = 0; j < node.SubtreeCount; ++j) {
    158           var s = node.GetSubtree(j);
    159           if (s.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
    160           code[c + j] = new BatchInstruction { narg = (ushort)s.SubtreeCount, opcode = opCodeMapper(s) };
    161         }
    162 
    163         code[i].buf = new double[BATCHSIZE];
    164 
     207        if (node.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
     208        code[i] = new BatchInstruction {
     209          opcode = opCodeMapper(node),
     210          narg = (ushort)node.SubtreeCount,
     211          buf = new double[BATCHSIZE],
     212          childIndex = c
     213        };
    165214        if (node is VariableTreeNode variable) {
    166215          code[i].weight = variable.Weight;
    167           code[i].data = dataset.GetReadOnlyDoubleValues(variable.VariableName).ToArray();
     216          if (cachedData.ContainsKey(variable.VariableName)) {
     217            code[i].data = cachedData[variable.VariableName];
     218          } else {
     219            code[i].data = dataset.GetReadOnlyDoubleValues(variable.VariableName).ToArray();
     220            cachedData[variable.VariableName] = code[i].data;
     221          }
    168222        } else if (node is ConstantTreeNode constant) {
    169223          code[i].value = constant.Value;
     
    171225            code[i].buf[j] = code[i].value;
    172226        }
    173 
    174         code[i].childIndex = c;
    175227        c += node.SubtreeCount;
    176228        ++i;
Note: See TracChangeset for help on using the changeset viewer.