Changeset 17463 for branches

Timestamp:

03/02/20 15:04:46 (5 years ago)

Author:

pfleck

Message:

#3040 Added type coherent vector grammar to enforce that the root symbol is a scalar.

Location:

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

Files:

• Grammars/TypeCoherentVectorExpressionGrammar.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• Interpreter/OpCodes.cs (modified) (3 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs (modified) (8 diffs)
• Symbols/StandardDeviation.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/TypeCoherentVectorExpressionGrammar.cs

@@ -35 +35 @@
     private const string TrigonometricFunctionsName = "Trigonometric Functions";
     private const string ExponentialFunctionsName = "Exponential and Logarithmic Functions";
+    private const string PowerFunctionsName = "Power Functions";
+    private const string TerminalsName = "Terminals";
+    private const string VectorAggregationName = "Aggregations";
+    private const string ScalarSymbolsName = "Scalar Symbols";
+
+    private const string VectorArithmeticFunctionsName = "Vector Arithmetic Functions";
+    private const string VectorTrigonometricFunctionsName = "Vector Trigonometric Functions";
+    private const string VectorExponentialFunctionsName = "Vector Exponential and Logarithmic Functions";
+    private const string VectorPowerFunctionsName = "Vector Power Functions";
+    private const string VectorTerminalsName = "Vector Terminals";
+    private const string VectorSymbolsName = "Vector Symbols";
+
     private const string RealValuedSymbolsName = "Real Valued Symbols";
-    private const string TerminalsName = "Terminals";
-    private const string PowerFunctionsName = "Power Functions";
-    private const string ConditionsName = "Conditions";
-    private const string ComparisonsName = "Comparisons";
-    private const string BooleanOperatorsName = "Boolean Operators";
-    private const string ConditionalSymbolsName = "ConditionalSymbols";
-    private const string SpecialFunctionsName = "Special Functions";
-    private const string TimeSeriesSymbolsName = "Time Series Symbols";
 
     [StorableConstructor]
@@ -57 +61 @@
 
     private void Initialize() {
-      #region symbol declaration
+      #region scalar symbol declaration
       var add = new Addition();
       var sub = new Subtraction();
       var mul = new Multiplication();
       var div = new Division();
-      var mean = new Average();
+
       var sin = new Sine();
       var cos = new Cosine();
       var tan = new Tangent();
+
+      var exp = new Exponential();
       var log = new Logarithm();
-      var pow = new Power();
+
       var square = new Square();
-      var root = new Root();
       var sqrt = new SquareRoot();
       var cube = new Cube();
       var cubeRoot = new CubeRoot();
-      var exp = new Exponential();
-      var abs = new Absolute();
-
-      var airyA = new AiryA();
-      var airyB = new AiryB();
-      var bessel = new Bessel();
-      var cosineIntegral = new CosineIntegral();
-      var dawson = new Dawson();
-      var erf = new Erf();
-      var expIntegralEi = new ExponentialIntegralEi();
-      var fresnelCosineIntegral = new FresnelCosineIntegral();
-      var fresnelSineIntegral = new FresnelSineIntegral();
-      var gamma = new Gamma();
-      var hypCosineIntegral = new HyperbolicCosineIntegral();
-      var tanh = new HyperbolicTangent();
-      var hypSineIntegral = new HyperbolicSineIntegral();
-      var norm = new Norm();
-      var psi = new Psi();
-      var sineIntegral = new SineIntegral();
-      var analyticalQuotient = new AnalyticQuotient();
-
-      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 variableCondition = new VariableCondition();
-
-      var timeLag = new TimeLag();
-      var integral = new Integral();
-      var derivative = new Derivative();
-
-      var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
-      var variableSymbol = new Variable();
+      var power = new Power();
+      var root = new Root();
+
+      var constant = new Constant { MinValue = -20, MaxValue = 20 };
+      var variable = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
       var factorVariable = new FactorVariable();
-      var laggedVariable = new LaggedVariable();
-      var autoregressiveVariable = new AutoregressiveTargetVariable();
+
+      var sum = new Sum();
+      var mean = new Average { Name = "Mean" };
+      var sd = new StandardDeviation();
+      #endregion
+
+      #region vector symbol declaration
+      var vectoradd = new Addition() { Name = "Vector Addition" };
+      var vectorsub = new Subtraction() { Name = "Vector Subtraction" };
+      var vectormul = new Multiplication() { Name = "Vector Multiplication" };
+      var vectordiv = new Division() { Name = "Vector Division" };
+
+      var vectorsin = new Sine() { Name = "Vector Sine" };
+      var vectorcos = new Cosine() { Name = "Vector Cosine" };
+      var vectortan = new Tangent() { Name = "Vector Tangent" };
+
+      var vectorexp = new Exponential() { Name = "Vector Exponential" };
+      var vectorlog = new Logarithm() { Name = "Vector Logarithm" };
+
+      var vectorsquare = new Square() { Name = "Vector Square" };
+      var vectorsqrt = new SquareRoot() { Name = "Vector SquareRoot" };
+      var vectorcube = new Cube() { Name = "Vector Cube" };
+      var vectorcubeRoot = new CubeRoot() { Name = "Vector CubeRoot" };
+      var vectorpower = new Power() { Name = "Vector Power" };
+      var vectorroot = new Root() { Name = "Vector Root" };
+
+      var vectorvariable = new Variable() { Name = "Vector Variable" };
       #endregion
 
       #region group symbol declaration
-      var arithmeticSymbols = new GroupSymbol(ArithmeticFunctionsName, new List<ISymbol>() { add, sub, mul, div, mean });
-      var trigonometricSymbols = new GroupSymbol(TrigonometricFunctionsName, new List<ISymbol>() { sin, cos, tan, tanh });
+      var arithmeticSymbols = new GroupSymbol(ArithmeticFunctionsName, new List<ISymbol>() { add, sub, mul, div });
+      var trigonometricSymbols = new GroupSymbol(TrigonometricFunctionsName, new List<ISymbol>() { sin, cos, tan });
       var exponentialAndLogarithmicSymbols = new GroupSymbol(ExponentialFunctionsName, new List<ISymbol> { exp, log });
-      var specialFunctions = new GroupSymbol(SpecialFunctionsName, new List<ISymbol> { abs, airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi,
-        fresnelCosineIntegral,fresnelSineIntegral,gamma,hypCosineIntegral,hypSineIntegral,norm, psi, sineIntegral, analyticalQuotient});
-      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variableSymbol, binFactorVariable, factorVariable });
-      var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, specialFunctions, terminalSymbols });
-
-      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, pow, sqrt, root, cube, cubeRoot });
-
-      var conditionSymbols = new GroupSymbol(ConditionsName, new List<ISymbol> { @if, variableCondition });
-      var comparisonSymbols = new GroupSymbol(ComparisonsName, new List<ISymbol> { gt, lt });
-      var booleanOperationSymbols = new GroupSymbol(BooleanOperatorsName, new List<ISymbol> { and, or, not, xor });
-      var conditionalSymbols = new GroupSymbol(ConditionalSymbolsName, new List<ISymbol> { conditionSymbols, comparisonSymbols, booleanOperationSymbols });
-
-      var timeSeriesSymbols = new GroupSymbol(TimeSeriesSymbolsName, new List<ISymbol> { timeLag, integral, derivative, laggedVariable, autoregressiveVariable });
-      #endregion
-
-      AddSymbol(realValuedSymbols);
-      AddSymbol(powerSymbols);
-      AddSymbol(conditionalSymbols);
-      AddSymbol(timeSeriesSymbols);
+      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, sqrt, cube, cubeRoot, power, root });
+      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variable, binFactorVariable, factorVariable });
+      var aggregationSymbols = new GroupSymbol(VectorAggregationName, new List<ISymbol> { sum, mean, sd });
+      var scalarSymbols = new GroupSymbol(ScalarSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, powerSymbols, terminalSymbols, aggregationSymbols });
+
+      var vectorarithmeticSymbols = new GroupSymbol(VectorArithmeticFunctionsName, new List<ISymbol>() { vectoradd, vectorsub, vectormul, vectordiv });
+      var vectortrigonometricSymbols = new GroupSymbol(VectorTrigonometricFunctionsName, new List<ISymbol>() { vectorsin, vectorcos, vectortan });
+      var vectorexponentialAndLogarithmicSymbols = new GroupSymbol(VectorExponentialFunctionsName, new List<ISymbol> { vectorexp, vectorlog });
+      var vectorpowerSymbols = new GroupSymbol(VectorPowerFunctionsName, new List<ISymbol> { vectorsquare, vectorsqrt, vectorcube, vectorcubeRoot, vectorpower, vectorroot });
+      var vectorterminalSymbols = new GroupSymbol(VectorTerminalsName, new List<ISymbol> { vectorvariable });
+      var vectorSymbols = new GroupSymbol(VectorSymbolsName, new List<ISymbol>() { vectorarithmeticSymbols, vectortrigonometricSymbols, vectorexponentialAndLogarithmicSymbols, vectorpowerSymbols, vectorterminalSymbols });
+
+      //var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol> { scalarSymbols, vectorSymbols });
+
+
+      #endregion
+
+      //AddSymbol(realValuedSymbols);
+      AddSymbol(scalarSymbols);
+      AddSymbol(vectorSymbols);
 
       #region subtree count configuration
       SetSubtreeCount(arithmeticSymbols, 2, 2);
       SetSubtreeCount(trigonometricSymbols, 1, 1);
-      SetSubtreeCount(pow, 2, 2);
+      SetSubtreeCount(exponentialAndLogarithmicSymbols, 1, 1);
+      SetSubtreeCount(square, 1, 1);
+      SetSubtreeCount(sqrt, 1, 1);
+      SetSubtreeCount(cube, 1, 1);
+      SetSubtreeCount(cubeRoot, 1, 1);
+      SetSubtreeCount(power, 2, 2);
       SetSubtreeCount(root, 2, 2);
-      SetSubtreeCount(square, 1, 1);
-      SetSubtreeCount(cube, 1, 1);
-      SetSubtreeCount(sqrt, 1, 1);
-      SetSubtreeCount(cubeRoot, 1, 1);
       SetSubtreeCount(exponentialAndLogarithmicSymbols, 1, 1);
-      foreach (var sy in specialFunctions.Symbols.Except(new[] { analyticalQuotient })) {
-        SetSubtreeCount(sy, 1, 1);
-      }
-      SetSubtreeCount(analyticalQuotient, 2, 2);
-
       SetSubtreeCount(terminalSymbols, 0, 0);
-
-      SetSubtreeCount(@if, 3, 3);
-      SetSubtreeCount(variableCondition, 2, 2);
-      SetSubtreeCount(comparisonSymbols, 2, 2);
-      SetSubtreeCount(and, 2, 2);
-      SetSubtreeCount(or, 2, 2);
-      SetSubtreeCount(not, 1, 1);
-      SetSubtreeCount(xor, 2, 2);
-
-      SetSubtreeCount(timeLag, 1, 1);
-      SetSubtreeCount(integral, 1, 1);
-      SetSubtreeCount(derivative, 1, 1);
-      SetSubtreeCount(laggedVariable, 0, 0);
-      SetSubtreeCount(autoregressiveVariable, 0, 0);
+      SetSubtreeCount(aggregationSymbols, 1, 1);
+
+      SetSubtreeCount(vectorarithmeticSymbols, 2, 2);
+      SetSubtreeCount(vectortrigonometricSymbols, 1, 1);
+      SetSubtreeCount(vectorexponentialAndLogarithmicSymbols, 1, 1);
+      SetSubtreeCount(vectorsquare, 1, 1);
+      SetSubtreeCount(vectorsqrt, 1, 1);
+      SetSubtreeCount(vectorcube, 1, 1);
+      SetSubtreeCount(vectorcubeRoot, 1, 1);
+      SetSubtreeCount(vectorpower, 2, 2);
+      SetSubtreeCount(vectorroot, 2, 2);
+      SetSubtreeCount(vectorexponentialAndLogarithmicSymbols, 1, 1);
+      SetSubtreeCount(vectorterminalSymbols, 0, 0);
       #endregion
 
       #region allowed child symbols configuration
-      AddAllowedChildSymbol(StartSymbol, realValuedSymbols);
-      AddAllowedChildSymbol(StartSymbol, powerSymbols);
-      AddAllowedChildSymbol(StartSymbol, conditionSymbols);
-      AddAllowedChildSymbol(StartSymbol, timeSeriesSymbols);
-      AddAllowedChildSymbol(StartSymbol, specialFunctions);
-
-      AddAllowedChildSymbol(DefunSymbol, realValuedSymbols);
-      AddAllowedChildSymbol(DefunSymbol, powerSymbols);
-      AddAllowedChildSymbol(DefunSymbol, conditionSymbols);
-      AddAllowedChildSymbol(DefunSymbol, timeSeriesSymbols);
-      AddAllowedChildSymbol(DefunSymbol, specialFunctions);
-
-      AddAllowedChildSymbol(realValuedSymbols, realValuedSymbols);
-      AddAllowedChildSymbol(realValuedSymbols, powerSymbols);
-      AddAllowedChildSymbol(realValuedSymbols, conditionSymbols);
-      AddAllowedChildSymbol(realValuedSymbols, timeSeriesSymbols);
-      AddAllowedChildSymbol(realValuedSymbols, specialFunctions);
-
-      AddAllowedChildSymbol(powerSymbols, variableSymbol, 0);
-      AddAllowedChildSymbol(powerSymbols, laggedVariable, 0);
-      AddAllowedChildSymbol(powerSymbols, autoregressiveVariable, 0);
-      AddAllowedChildSymbol(powerSymbols, constant, 1);
-
-      AddAllowedChildSymbol(square, realValuedSymbols, 0);
-      AddAllowedChildSymbol(square, conditionSymbols, 0);
-      AddAllowedChildSymbol(square, timeSeriesSymbols, 0);
-
-      AddAllowedChildSymbol(sqrt, realValuedSymbols, 0);
-      AddAllowedChildSymbol(sqrt, conditionSymbols, 0);
-      AddAllowedChildSymbol(sqrt, timeSeriesSymbols, 0);
-
-      AddAllowedChildSymbol(@if, comparisonSymbols, 0);
-      AddAllowedChildSymbol(@if, booleanOperationSymbols, 0);
-      AddAllowedChildSymbol(@if, conditionSymbols, 1);
-      AddAllowedChildSymbol(@if, realValuedSymbols, 1);
-      AddAllowedChildSymbol(@if, powerSymbols, 1);
-      AddAllowedChildSymbol(@if, timeSeriesSymbols, 1);
-      AddAllowedChildSymbol(@if, conditionSymbols, 2);
-      AddAllowedChildSymbol(@if, realValuedSymbols, 2);
-      AddAllowedChildSymbol(@if, powerSymbols, 2);
-      AddAllowedChildSymbol(@if, timeSeriesSymbols, 2);
-
-      AddAllowedChildSymbol(booleanOperationSymbols, comparisonSymbols);
-      AddAllowedChildSymbol(comparisonSymbols, realValuedSymbols);
-      AddAllowedChildSymbol(comparisonSymbols, powerSymbols);
-      AddAllowedChildSymbol(comparisonSymbols, conditionSymbols);
-      AddAllowedChildSymbol(comparisonSymbols, timeSeriesSymbols);
-
-      AddAllowedChildSymbol(variableCondition, realValuedSymbols);
-      AddAllowedChildSymbol(variableCondition, powerSymbols);
-      AddAllowedChildSymbol(variableCondition, conditionSymbols);
-      AddAllowedChildSymbol(variableCondition, timeSeriesSymbols);
-
-
-      AddAllowedChildSymbol(timeLag, realValuedSymbols);
-      AddAllowedChildSymbol(timeLag, powerSymbols);
-      AddAllowedChildSymbol(timeLag, conditionSymbols);
-
-      AddAllowedChildSymbol(integral, realValuedSymbols);
-      AddAllowedChildSymbol(integral, powerSymbols);
-      AddAllowedChildSymbol(integral, conditionSymbols);
-
-      AddAllowedChildSymbol(derivative, realValuedSymbols);
-      AddAllowedChildSymbol(derivative, powerSymbols);
-      AddAllowedChildSymbol(derivative, conditionSymbols);
+      AddAllowedChildSymbol(StartSymbol, scalarSymbols);
+
+      AddAllowedChildSymbol(arithmeticSymbols, scalarSymbols);
+      AddAllowedChildSymbol(trigonometricSymbols, scalarSymbols);
+      AddAllowedChildSymbol(exponentialAndLogarithmicSymbols, scalarSymbols);
+      AddAllowedChildSymbol(powerSymbols, scalarSymbols, 0);
+      AddAllowedChildSymbol(power, constant, 1);
+      AddAllowedChildSymbol(root, constant, 1);
+      AddAllowedChildSymbol(aggregationSymbols, vectorSymbols);
+
+      AddAllowedChildSymbol(vectorarithmeticSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorarithmeticSymbols, scalarSymbols);
+      AddAllowedChildSymbol(vectortrigonometricSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorexponentialAndLogarithmicSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorpowerSymbols, vectorSymbols, 0);
+      AddAllowedChildSymbol(vectorpower, constant, 1);
+      AddAllowedChildSymbol(vectorroot, constant, 1);
       #endregion
     }

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

@@ -231 +231 @@
     <Compile Include="Symbols\And.cs" />
     <Compile Include="Symbols\AutoregressiveVariable.cs" />
+    <Compile Include="Symbols\StandardDeviation.cs" />
     <Compile Include="Symbols\Sum.cs" />
     <Compile Include="Symbols\Average.cs" />

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

@@ -78 +78 @@
     CubeRoot = 51,
     Tanh = 52,
-    Sum = 53
+    Sum = 53,
+    Sd = 54
   };
   public static class OpCodes {
@@ -135 +136 @@
     public const byte Tanh = (byte)OpCode.Tanh;
     public const byte Sum = (byte)OpCode.Sum;
+    public const byte StandardDeviation = (byte)OpCode.Sd;
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
@@ -190 +192 @@
       { typeof(Cube), OpCodes.Cube },
       { typeof(CubeRoot), OpCodes.CubeRoot },
-      { typeof(Sum), OpCodes.Sum }
+      { typeof(Sum), OpCodes.Sum },
+      { typeof(StandardDeviation), OpCodes.StandardDeviation }
     };
 

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

@@ -105 +105 @@
         int row = rowEnum;
         var result = Evaluate(dataset, ref row, state);
-        if (!result.IsScalar)
-          throw new InvalidOperationException("Result of the tree is not a scalar.");
-        yield return result.Scalar;
+        if (result.IsScalar)
+          yield return result.Scalar;
+        else
+          yield return double.NaN;
+        //if (!result.IsScalar)
+        //  throw new InvalidOperationException("Result of the tree is not a scalar.");
+        //yield return result.Scalar;
         state.Reset();
       }
@@ -148 +152 @@
 
       public DoubleVector Vector { get; }
-      public bool IsVector => !(Vector.Count == 1 && double.IsNaN(Vector[0]));
+      public bool IsVector => Vector != null;
+      //public bool IsVector => !(Vector.Count == 1 && double.IsNaN(Vector[0]));
 
       public bool IsNaN => !IsScalar && !IsVector;
@@ -154 +159 @@
       public EvaluationResult(double scalar) {
         Scalar = scalar;
-        Vector = NaNVector;
+        //Vector = NaNVector;
+        Vector = null;
       }
       public EvaluationResult(DoubleVector vector) {
+        if (vector == null) throw new ArgumentNullException(nameof(vector));
         Vector = vector;
         Scalar = double.NaN;
@@ -168 +175 @@
 
       public static readonly EvaluationResult NaN = new EvaluationResult(double.NaN);
-      private static readonly DoubleVector NaNVector = DoubleVector.Build.Dense(1, double.NaN);
+      //private static readonly DoubleVector NaNVector = DoubleVector.Build.Dense(1, double.NaN);
     }
 
@@ -180 +187 @@
       if (lhs.IsVector && rhs.IsScalar && vsFunc != null) return new EvaluationResult(vsFunc(lhs.Vector, rhs.Scalar));
       if (lhs.IsVector && rhs.IsVector && vvFunc != null) return new EvaluationResult(vvFunc(lhs.Vector, rhs.Vector));
-      throw new NotSupportedException($"Unsupported combination of argument types: ({lhs}) / ({rhs})");
+      return EvaluationResult.NaN;
+      //throw new NotSupportedException($"Unsupported combination of argument types: ({lhs}) / ({rhs})");
     }
 
@@ -188 +196 @@
       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})");
+      return EvaluationResult.NaN;
+      //throw new NotSupportedException($"Unsupported argument type ({val})");
     }
     private static EvaluationResult AggregateApply(EvaluationResult val,
@@ -195 +204 @@
       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})");
+      return EvaluationResult.NaN;
+      //throw new NotSupportedException($"Unsupported argument type ({val})");
     }
 
@@ -335 +345 @@
               v => v.Mean());
           }
+        case OpCodes.StandardDeviation: {
+            var cur = Evaluate(dataset, ref row, state);
+            return AggregateApply(cur,
+              s => 0,
+              v => v.Count > 1 ? Statistics.StandardDeviation(v) : 0);
+          }
         case OpCodes.Variable: {
             if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;

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

@@ -25 +25 @@
 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("615033EC-6A76-4DE7-B55F-BB228D6A8166")]
+  [Item("StandardDeviation", "Symbol that represents the standard deviation function.")]
+  public sealed class StandardDeviation : Symbol {
     private const int minimumArity = 1;
     private const int maximumArity = byte.MaxValue;
@@ -39 +39 @@
 
     [StorableConstructor]
-    private Average(StorableConstructorFlag _) : base(_) { }
-    private Average(Average original, Cloner cloner) : base(original, cloner) { }
+    private StandardDeviation(StorableConstructorFlag _) : base(_) { }
+    private StandardDeviation(StandardDeviation original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new Average(this, cloner);
+      return new StandardDeviation(this, cloner);
     }
-    public Average() : base("Average", "Symbol that represents the average (arithmetic mean) function.") { }
+    public StandardDeviation() : base("StandardDeviation", "Symbol that represents the standard deviation function.") { }
   }
 }