Changeset 17460 for branches/3040_VectorBasedGP

Timestamp:

02/28/20 14:55:58 (5 years ago)

Author:

pfleck

Message:

#3040

• Added full functional grammar for vectors.
• Added sum and mean aggregation for vectors.

Location:

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Grammars/DataAnalysisGrammar.cs (modified) (1 diff)
• Grammars/FullFunctionalVectorExpressionGrammar.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs) (4 diffs)
• Grammars/TypeCoherentExpressionGrammar.cs (modified) (4 diffs)
• Grammars/TypeCoherentVectorExpressionGrammar.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (2 diffs)
• Interpreter/OpCodes.cs (modified) (3 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs (modified) (3 diffs)
• Symbols/Sum.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Average.cs) (2 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/DataAnalysisGrammar.cs

@@ -35 +35 @@
     protected DataAnalysisGrammar(string name, string description) : base(name, description) { }
 
-    public void ConfigureVariableSymbols(IDataAnalysisProblemData problemData) {
+    public virtual void ConfigureVariableSymbols(IDataAnalysisProblemData problemData) {
       var dataset = problemData.Dataset;
       foreach (var varSymbol in Symbols.OfType<VariableBase>()) {

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalVectorExpressionGrammar.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("44B0829C-1CB5-4BE9-9514-BBA54FAB2912")]
-  [Item("FullFunctionalExpressionGrammar", "Represents a grammar for functional expressions using all available functions.")]
-  public class FullFunctionalExpressionGrammar : DataAnalysisGrammar, ISymbolicDataAnalysisGrammar {
+  [StorableType("C913F5C6-AF16-4F2C-BA93-2D5AE1F8E68A")]
+  [Item("FullFunctionalVectorExpressionGrammar", "Represents a grammar for functional expressions using all available functions.")]
+  public class FullFunctionalVectorExpressionGrammar : DataAnalysisGrammar, ISymbolicDataAnalysisGrammar {
     [StorableConstructor]
-    protected FullFunctionalExpressionGrammar(StorableConstructorFlag _) : base(_) { }
-    protected FullFunctionalExpressionGrammar(FullFunctionalExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
-    public FullFunctionalExpressionGrammar()
-      : base(ItemAttribute.GetName(typeof(FullFunctionalExpressionGrammar)), ItemAttribute.GetDescription(typeof(FullFunctionalExpressionGrammar))) {
+    protected FullFunctionalVectorExpressionGrammar(StorableConstructorFlag _) : base(_) { }
+    protected FullFunctionalVectorExpressionGrammar(FullFunctionalVectorExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
+    public FullFunctionalVectorExpressionGrammar()
+      : base(ItemAttribute.GetName(typeof(FullFunctionalVectorExpressionGrammar)), ItemAttribute.GetDescription(typeof(FullFunctionalVectorExpressionGrammar))) {
       Initialize();
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new FullFunctionalExpressionGrammar(this, cloner);
+      return new FullFunctionalVectorExpressionGrammar(this, cloner);
     }
 
@@ -48 +49 @@
       var mul = new Multiplication();
       var div = new Division();
-      var aq = new AnalyticQuotient();
-      var mean = new Average();
+
       var sin = new Sine();
       var cos = new Cosine();
       var tan = new Tangent();
+
       var log = new Logarithm();
-      var abs = new Absolute();
-      var tanh = new HyperbolicTangent();
-      var pow = new Power();
-      pow.InitialFrequency = 0.0;
-      var square = new Square();
-      square.InitialFrequency = 0.0;
-      var cube = new Cube();
-      cube.InitialFrequency = 0.0;
-      var root = new Root();
-      root.InitialFrequency = 0.0;
-      var sqrt = new SquareRoot();
-      sqrt.InitialFrequency = 0.0;
-      var cubeRoot = new CubeRoot();
-      cubeRoot.InitialFrequency = 0.0;
-      var airyA = new AiryA();
-      airyA.InitialFrequency = 0.0;
-      var airyB = new AiryB();
-      airyB.InitialFrequency = 0.0;
-      var bessel = new Bessel();
-      bessel.InitialFrequency = 0.0;
-      var cosineIntegral = new CosineIntegral();
-      cosineIntegral.InitialFrequency = 0.0;
-      var dawson = new Dawson();
-      dawson.InitialFrequency = 0.0;
-      var erf = new Erf();
-      erf.InitialFrequency = 0.0;
-      var expIntegralEi = new ExponentialIntegralEi();
-      expIntegralEi.InitialFrequency = 0.0;
-      var fresnelCosineIntegral = new FresnelCosineIntegral();
-      fresnelCosineIntegral.InitialFrequency = 0.0;
-      var fresnelSineIntegral = new FresnelSineIntegral();
-      fresnelSineIntegral.InitialFrequency = 0.0;
-      var gamma = new Gamma();
-      gamma.InitialFrequency = 0.0;
-      var hypCosineIntegral = new HyperbolicCosineIntegral();
-      hypCosineIntegral.InitialFrequency = 0.0;
-      var hypSineIntegral = new HyperbolicSineIntegral();
-      hypSineIntegral.InitialFrequency = 0.0;
-      var norm = new Norm();
-      norm.InitialFrequency = 0.0;
-      var psi = new Psi();
-      psi.InitialFrequency = 0.0;
-      var sineIntegral = new SineIntegral();
-      sineIntegral.InitialFrequency = 0.0;
+      var exp = new Exponential();
 
-      var exp = new Exponential();
-      var @if = new IfThenElse();
-      var gt = new GreaterThan();
-      var lt = new LessThan();
-      var and = new And();
-      var or = new Or();
-      var not = new Not();
-      var xor = new Xor();
 
-      var timeLag = new TimeLag();
-      timeLag.InitialFrequency = 0.0;
-      var integral = new Integral();
-      integral.InitialFrequency = 0.0;
-      var derivative = new Derivative();
-      derivative.InitialFrequency = 0.0;
+      var pow = new Power { InitialFrequency = 0.0 };
+      var root = new Root { InitialFrequency = 0.0 };
+      var square = new Square { InitialFrequency = 0.0 };
+      var sqrt = new SquareRoot { InitialFrequency = 0.0 };
+      var cube = new Cube { InitialFrequency = 0.0 };
+      var cubeRoot = new CubeRoot { InitialFrequency = 0.0 };
 
-      var variableCondition = new VariableCondition();
-      variableCondition.InitialFrequency = 0.0;
-
-      var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
-      var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
+      var constant = new Constant { MinValue = -20, MaxValue = 20 };
+      var variable = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
       var factorVariable = new FactorVariable();
-      var laggedVariable = new LaggedVariable();
-      laggedVariable.InitialFrequency = 0.0;
-      var autoregressiveVariable = new AutoregressiveTargetVariable();
-      autoregressiveVariable.InitialFrequency = 0.0;
-      autoregressiveVariable.Enabled = false;
+      var vectorVariable = new Variable() { Name = "Vector Variable" };
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, aq, mean, abs, sin, cos, tan, log, square, cube, pow, sqrt, cubeRoot, root, exp, tanh,
-        airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral,
-        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, constant, variableSymbol, binFactorVariable, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
-      var unaryFunctionSymbols = new List<Symbol>() { abs, square, sqrt, cube, cubeRoot, sin, cos, tan, log, exp, tanh, not, timeLag, integral, derivative,
-        airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral
+      var sum = new Sum();
+      var mean = new Average() { Name = "Mean" };
+
+
+      var allSymbols = new List<Symbol>() {
+        add, sub, mul, div,
+        sin, cos, tan,
+        log, exp,
+        square, sqrt, cube, cubeRoot, pow, root,
+        constant, variable, binFactorVariable, factorVariable, vectorVariable,
+        sum, mean
+      };
+      var unaryFunctionSymbols = new List<Symbol>() {
+        sin, cos, tan,
+        log, exp
       };
 
-      var binaryFunctionSymbols = new List<Symbol>() { pow, root, gt, lt, aq, variableCondition };
-      var ternarySymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or, xor };
-      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, constant, laggedVariable, autoregressiveVariable };
+      var binaryFunctionSymbols = new List<Symbol>() { pow, root };
+      var ternarySymbols = new List<Symbol>() { add, sub, mul, div };
+      var terminalSymbols = new List<Symbol>() { variable, binFactorVariable, factorVariable, vectorVariable, constant };
+
+      var aggregationSymbols = new List<Symbol>() { sum, mean };
 
       foreach (var symb in allSymbols)
@@ -156 +109 @@
         SetSubtreeCount(terminalSymbol, 0, 0);
       }
-
-      SetSubtreeCount(@if, 3, 3);
+      foreach (var aggrSymb in aggregationSymbols) {
+        SetSubtreeCount(aggrSymb, 1, 1);
+      }
 
 
@@ -172 +126 @@
       }
     }
+
+    public override void ConfigureVariableSymbols(IDataAnalysisProblemData problemData) {
+      base.ConfigureVariableSymbols(problemData);
+
+      var dataset = problemData.Dataset;
+      foreach (var varSymbol in Symbols.OfType<VariableBase>().Where(sym => sym.Name == "Variable")) {
+        if (!varSymbol.Fixed) {
+          varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<double>(x));
+          varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<double>(x));
+        }
+      }
+      foreach (var varSymbol in Symbols.OfType<VariableBase>().Where(sym => sym.Name == "Vector Variable")) {
+        if (!varSymbol.Fixed) {
+          varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<DoubleVector>(x));
+          varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<DoubleVector>(x));
+        }
+      }
+    }
   }
 }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -42 +42 @@
     private const string SpecialFunctionsName = "Special Functions";
     private const string TimeSeriesSymbolsName = "Time Series Symbols";
-    private const string VectorSymbolsName = "Vector Symbols";
 
     [StorableConstructor]
@@ -250 +249 @@
       Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
       Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
     }
 
@@ -264 +262 @@
       Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
       Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
     }
 
@@ -275 +272 @@
       Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
       Symbols.First(s => s.Name == SpecialFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
 
       Symbols.Single(s => s.Name == "Variable").Enabled = false;

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentVectorExpressionGrammar.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("36A22322-0627-4E25-A468-F2A788AF6D46")]
-  [Item("TypeCoherentExpressionGrammar", "Represents a grammar for functional expressions in which special syntactic constraints are enforced so that boolean and real-valued expressions are not mixed.")]
-  public class TypeCoherentExpressionGrammar : DataAnalysisGrammar, ISymbolicDataAnalysisGrammar {
+  [StorableType("7EC7B4A7-0E27-4011-B983-B0E15A6944EC")]
+  [Item("TypeCoherentVectorExpressionGrammar", "Represents a grammar for functional expressions in which special syntactic constraints are enforced so that vector and scalar expressions are not mixed.")]
+  public class TypeCoherentVectorExpressionGrammar : DataAnalysisGrammar, ISymbolicDataAnalysisGrammar {
     private const string ArithmeticFunctionsName = "Arithmetic Functions";
     private const string TrigonometricFunctionsName = "Trigonometric Functions";
@@ -42 +44 @@
     private const string SpecialFunctionsName = "Special Functions";
     private const string TimeSeriesSymbolsName = "Time Series Symbols";
-    private const string VectorSymbolsName = "Vector Symbols";
 
     [StorableConstructor]
-    protected TypeCoherentExpressionGrammar(StorableConstructorFlag _) : base(_) { }
-    protected TypeCoherentExpressionGrammar(TypeCoherentExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
-    public TypeCoherentExpressionGrammar()
-      : base(ItemAttribute.GetName(typeof(TypeCoherentExpressionGrammar)), ItemAttribute.GetDescription(typeof(TypeCoherentExpressionGrammar))) {
+    protected TypeCoherentVectorExpressionGrammar(StorableConstructorFlag _) : base(_) { }
+    protected TypeCoherentVectorExpressionGrammar(TypeCoherentVectorExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
+    public TypeCoherentVectorExpressionGrammar()
+      : base(ItemAttribute.GetName(typeof(TypeCoherentVectorExpressionGrammar)), ItemAttribute.GetDescription(typeof(TypeCoherentVectorExpressionGrammar))) {
       Initialize();
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new TypeCoherentExpressionGrammar(this, cloner);
+      return new TypeCoherentVectorExpressionGrammar(this, cloner);
     }
 
@@ -241 +242 @@
     }
 
-    public void ConfigureAsDefaultRegressionGrammar() {
-      Symbols.First(s => s is Average).Enabled = false;
-      Symbols.First(s => s is Absolute).Enabled = false;
-      Symbols.First(s => s is HyperbolicTangent).Enabled = false;
-      Symbols.First(s => s.Name == TrigonometricFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == SpecialFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
-    }
-
-    public void ConfigureAsDefaultClassificationGrammar() {
-      Symbols.First(s => s is Average).Enabled = false;
-      Symbols.First(s => s is VariableCondition).Enabled = false;
-      Symbols.First(s => s is Xor).Enabled = false;
-      Symbols.First(s => s is Absolute).Enabled = false;
-      Symbols.First(s => s is HyperbolicTangent).Enabled = false;
-      Symbols.First(s => s.Name == TrigonometricFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == ExponentialFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == SpecialFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
-    }
-
-    public void ConfigureAsDefaultTimeSeriesPrognosisGrammar() {
-      Symbols.First(s => s is Average).Enabled = false;
-      Symbols.First(s => s is Absolute).Enabled = false;
-      Symbols.First(s => s is HyperbolicTangent).Enabled = false;
-      Symbols.First(s => s.Name == TrigonometricFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
-      Symbols.First(s => s.Name == SpecialFunctionsName).Enabled = false;
-      Symbols.First(s => s.Name == VectorSymbolsName).Enabled = false;
-
-      Symbols.Single(s => s.Name == "Variable").Enabled = false;
-      Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = true;
-      Symbols.First(s => s is Derivative).Enabled = false;
-      Symbols.First(s => s is Integral).Enabled = false;
-      Symbols.First(s => s is TimeLag).Enabled = false;
+    public override void ConfigureVariableSymbols(IDataAnalysisProblemData problemData) {
+      base.ConfigureVariableSymbols(problemData);
+
+      var dataset = problemData.Dataset;
+      foreach (var varSymbol in Symbols.OfType<VariableBase>().Where(sym => sym.Name == "Variable")) {
+        if (!varSymbol.Fixed) {
+          varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<double>(x));
+          varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<double>(x));
+        }
+      }
+      foreach (var varSymbol in Symbols.OfType<VariableBase>().Where(sym => sym.Name == "Vector Variable")) {
+        if (!varSymbol.Fixed) {
+          varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<DoubleVector>(x));
+          varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<DoubleVector>(x));
+        }
+      }
     }
   }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -161 +161 @@
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionCSharpFormatter.cs" />
     <Compile Include="Grammars\DataAnalysisGrammar.cs" />
+    <Compile Include="Grammars\FullFunctionalVectorExpressionGrammar.cs" />
+    <Compile Include="Grammars\TypeCoherentVectorExpressionGrammar.cs" />
     <Compile Include="Hashing\HashExtensions.cs" />
     <Compile Include="Hashing\HashUtil.cs" />
@@ -229 +231 @@
     <Compile Include="Symbols\And.cs" />
     <Compile Include="Symbols\AutoregressiveVariable.cs" />
+    <Compile Include="Symbols\Sum.cs" />
     <Compile Include="Symbols\Average.cs" />
     <Compile Include="Symbols\Constant.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -77 +77 @@
     Cube = 50,
     CubeRoot = 51,
-    Tanh = 52
+    Tanh = 52,
+    Sum = 53
   };
   public static class OpCodes {
@@ -133 +134 @@
     public const byte CubeRoot = (byte)OpCode.CubeRoot;
     public const byte Tanh = (byte)OpCode.Tanh;
+    public const byte Sum = (byte)OpCode.Sum;
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
@@ -187 +189 @@
       { typeof(AnalyticQuotient), OpCodes.AnalyticQuotient },
       { typeof(Cube), OpCodes.Cube },
-      { typeof(CubeRoot), OpCodes.CubeRoot }
+      { typeof(CubeRoot), OpCodes.CubeRoot },
+      { typeof(Sum), OpCodes.Sum }
     };
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs

@@ -118 +118 @@
         if (instr.opCode == OpCodes.Variable) {
           var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
-          instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
+          if (dataset.VariableHasType<double>(variableTreeNode.VariableName))
+            instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
+          else if (dataset.VariableHasType<DoubleVector>(variableTreeNode.VariableName))
+            instr.data = dataset.GetReadOnlyDoubleVectorValues(variableTreeNode.VariableName);
+          else throw new NotSupportedException($"Type of variable {variableTreeNode.VariableName} is not supported.");
         } else if (instr.opCode == OpCodes.FactorVariable) {
           var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
@@ -186 +190 @@
       throw new NotSupportedException($"Unsupported argument type ({val})");
     }
+    private static EvaluationResult AggregateApply(EvaluationResult val,
+      Func<double, double> sFunc = null,
+      Func<DoubleVector, double> vFunc = null) {
+      if (val.IsScalar && sFunc != null) return new EvaluationResult(sFunc(val.Scalar));
+      if (val.IsVector && vFunc != null) return new EvaluationResult(vFunc(val.Vector));
+      throw new NotSupportedException($"Unsupported argument type ({val})");
+    }
 
     public virtual EvaluationResult Evaluate(IDataset dataset, ref int row, InterpreterState state) {
@@ -312 +323 @@
               v => DoubleVector.Log(v));
           }
+        case OpCodes.Sum: {
+            var cur = Evaluate(dataset, ref row, state);
+            return AggregateApply(cur,
+              s => s,
+              v => v.Sum());
+          }
+        case OpCodes.Average: {
+            var cur = Evaluate(dataset, ref row, state);
+            return AggregateApply(cur,
+              s => s,
+              v => v.Mean());
+          }
         case OpCodes.Variable: {
             if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs

@@ -24 +24 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HEAL.Attic;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("459E521B-A921-4A0F-B63D-B298DA2CDD11")]
-  [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
-  public sealed class Average : Symbol {
+  [StorableType("C6C245BF-C44A-4207-A268-55641483F27F")]
+  [Item("Sum", "Symbol that represents the Sum function.")]
+  public sealed class Sum : Symbol {
     private const int minimumArity = 1;
     private const int maximumArity = byte.MaxValue;
@@ -39 +40 @@
 
     [StorableConstructor]
-    private Average(StorableConstructorFlag _) : base(_) { }
-    private Average(Average original, Cloner cloner) : base(original, cloner) { }
+    private Sum(StorableConstructorFlag _) : base(_) { }
+    private Sum(Sum original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new Average(this, cloner);
+      return new Sum(this, cloner);
     }
-    public Average() : base("Average", "Symbol that represents the average (arithmetic mean) function.") { }
+    public Sum() : base("Sum", "Symbol that represents the sum function.") { }
   }
 }