Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentVectorTimeSeriesExpressionGrammar.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentVectorTimeSeriesExpressionGrammar.cs	(revision 17830)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentVectorTimeSeriesExpressionGrammar.cs	(revision 17830)
@@ -0,0 +1,328 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("88895D71-3D3F-44A7-A531-D5D59963AABE")]
+  [Item("TypeCoherentVectorTimeSeriesExpressionGrammar", "Represents a grammar for functional expressions in which special syntactic constraints are enforced so that vector and scalar expressions are not mixed.")]
+  public class TypeCoherentVectorTimeSeriesExpressionGrammar : DataAnalysisGrammar, ISymbolicDataAnalysisGrammar {
+    private const string ArithmeticFunctionsName = "Arithmetic Functions";
+    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 VectorStatisticsName = "Vector Statistics";
+    private const string VectorDistancesName = "Vector Distances";
+    private const string VectorDistributionCharacteristicsName = "Distribution Characteristics";
+    private const string VectorTimeSeriesDynamicsName = "Time Series Dynamics";
+    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 VectorManipulationSymbolsName = "Vector Manipulation Symbols";
+
+    private const string RealValuedSymbolsName = "Real Valued Symbols";
+
+    [StorableConstructor]
+    protected TypeCoherentVectorTimeSeriesExpressionGrammar(StorableConstructorFlag _) : base(_) { }
+    protected TypeCoherentVectorTimeSeriesExpressionGrammar(TypeCoherentVectorTimeSeriesExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
+    public TypeCoherentVectorTimeSeriesExpressionGrammar()
+      : base(ItemAttribute.GetName(typeof(TypeCoherentVectorTimeSeriesExpressionGrammar)), ItemAttribute.GetDescription(typeof(TypeCoherentVectorTimeSeriesExpressionGrammar))) {
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TypeCoherentVectorTimeSeriesExpressionGrammar(this, cloner);
+    }
+
+    private void Initialize() {
+      #region scalar symbol declaration
+      var add = new Addition();
+      var sub = new Subtraction();
+      var mul = new Multiplication();
+      var div = new Division();
+
+      var sin = new Sine();
+      var cos = new Cosine();
+      var tan = new Tangent();
+
+      var exp = new Exponential();
+      var log = new Logarithm();
+
+      var square = new Square();
+      var sqrt = new SquareRoot();
+      var cube = new Cube();
+      var cubeRoot = new CubeRoot();
+      var power = new Power();
+      var root = new Root();
+
+      var constant = new Constant { MinValue = -20, MaxValue = 20 };
+      var constantZeroToOne = new Constant { Name = "Constant [0-1]", MinValue = 0, MaxValue = 1 };
+      var variable = new Variable();
+      var binFactorVariable = new BinaryFactorVariable();
+      var factorVariable = new FactorVariable();
+
+      var mean = new Mean();
+      var median = new Median() { Enabled = false };
+      var sd = new StandardDeviation();
+      var sum = new Sum();
+      var length = new Length() { Enabled = false };
+      var min = new Min() { Enabled = false };
+      var max = new Max() { Enabled = false };
+      var quantile = new Quantile() { Enabled = false };
+      var variance = new Variance() { Enabled = false };
+      var skewness = new Skewness() { Enabled = false };
+      var kurtosis = new Kurtosis() { Enabled = false };
+      var euclideanDistance = new EuclideanDistance() { Enabled = false };
+      var covariance = new Covariance() { Enabled = false };
+      #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" };
+
+      #region TimeSeries Symbols
+      var absoluteEnergy = new AbsoluteEnergy() { Enabled = false };
+      var binnedEntropy = new BinnedEntropy() { Enabled = false };
+      var hasLargeStandardDeviation = new HasLargeStandardDeviation() { Enabled = false };
+      var hasVarianceLargerThanStd = new HasVarianceLargerThanStd() { Enabled = false };
+      var isSymmetricLooking = new IsSymmetricLooking() { Enabled = false };
+      var numberDataPointsAboveMean = new NumberDataPointsAboveMean() { Enabled = false };
+      var numberDataPointsAboveMedian = new NumberDataPointsAboveMedian() { Enabled = false };
+      var numberDataPointsBelowMean = new NumberDataPointsBelowMean() { Enabled = false };
+      var numberDataPointsBelowMedian = new NumberDataPointsBelowMedian() { Enabled = false };
+
+      var arimaModelCoefficients = new ArimaModelCoefficients() { Enabled = false };
+      var continuousWaveletTransformationCoefficients = new ContinuousWaveletTransformationCoefficients() { Enabled = false };
+      var fastFourierTransformationCoefficient = new FastFourierTransformationCoefficient() { Enabled = false };
+      var firstIndexMax = new FirstIndexMax() { Enabled = false };
+      var firstIndexMin = new FirstIndexMin() { Enabled = false };
+      var lastIndexMax = new LastIndexMax() { Enabled = false };
+      var lastIndexMin = new LastIndexMin() { Enabled = false };
+      var longestStrikeAboveMean = new LongestStrikeAboveMean() { Enabled = false };
+      var longestStrikeAboveMedian = new LongestStrikeAboveMedian() { Enabled = false };
+      var longestStrikeBelowMean = new LongestStrikeBelowMean() { Enabled = false };
+      var longestStrikeBelowMedian = new LongestStrikeBelowMedian() { Enabled = false };
+      var longestStrikePositive = new LongestStrikePositive() { Enabled = false };
+      var longestStrikeNegative = new LongestStrikeNegative() { Enabled = false };
+      var longestStrikeZero = new LongestStrikeZero() { Enabled = false };
+      var meanAbsoluteChange = new MeanAbsoluteChange() { Enabled = false };
+      var meanAbsoluteChangeQuantiles = new MeanAbsoluteChangeQuantiles() { Enabled = false };
+      var meanAutocorrelation = new MeanAutocorrelation() { Enabled = false };
+      var laggedAutocorrelation = new LaggedAutocorrelation() { Enabled = false };
+      var meanSecondDerivateCentral = new MeanSecondDerivateCentral() { Enabled = false };
+      var numberPeaksOfSize = new NumberPeaksOfSize() { Enabled = false };
+      var largeNumberOfPeaks = new LargeNumberOfPeaks() { Enabled = false };
+      var timeReversalAsymmetryStatistic = new TimeReversalAsymmetryStatistic() { Enabled = false };
+      #endregion
+      #endregion
+
+      #region vector manipulation symbol declaration
+      var subvector = new SubVector() { EnableWindowing = true };
+      #endregion
+
+      #region group symbol declaration
+      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 powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, sqrt, cube, cubeRoot, power, root });
+      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, constantZeroToOne, variable, binFactorVariable, factorVariable });
+      var statisticsSymbols = new GroupSymbol(VectorStatisticsName, new List<ISymbol> { mean, median, sd, sum, length, min, max, quantile, variance, skewness, kurtosis });
+      var distancesSymbols = new GroupSymbol(VectorDistancesName, new List<ISymbol> { euclideanDistance, covariance });
+      var distributionCharacteristicsSymbols = new GroupSymbol(VectorDistributionCharacteristicsName, new List<ISymbol> {
+        absoluteEnergy, binnedEntropy, hasLargeStandardDeviation, hasVarianceLargerThanStd, isSymmetricLooking,
+        numberDataPointsAboveMean, numberDataPointsAboveMedian, numberDataPointsBelowMean, numberDataPointsBelowMedian
+      });
+      var timeSeriesDynamicsSymbols = new GroupSymbol(VectorTimeSeriesDynamicsName, new List<ISymbol> {
+        arimaModelCoefficients, continuousWaveletTransformationCoefficients, fastFourierTransformationCoefficient,
+        firstIndexMax, firstIndexMin, lastIndexMax, lastIndexMin,
+        longestStrikeAboveMean, longestStrikeAboveMedian, longestStrikeBelowMean, longestStrikeBelowMedian, longestStrikePositive, longestStrikePositive, longestStrikeNegative, longestStrikeZero,
+        meanAbsoluteChange, meanAbsoluteChangeQuantiles, meanAutocorrelation, laggedAutocorrelation, meanSecondDerivateCentral, meanSecondDerivateCentral,
+        numberPeaksOfSize, largeNumberOfPeaks, timeReversalAsymmetryStatistic
+      });
+      var aggregationSymbols = new GroupSymbol(VectorAggregationName, new List<ISymbol> { statisticsSymbols, distancesSymbols, distributionCharacteristicsSymbols, timeSeriesDynamicsSymbols });
+      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 vectorManipulationSymbols = new GroupSymbol(VectorManipulationSymbolsName, new List<ISymbol>() { subvector });
+
+      //var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol> { scalarSymbols, vectorSymbols });
+      #endregion
+
+      //AddSymbol(realValuedSymbols);
+      AddSymbol(scalarSymbols);
+      AddSymbol(vectorSymbols);
+      AddSymbol(vectorManipulationSymbols);
+
+      #region subtree count configuration
+      SetSubtreeCount(arithmeticSymbols, 2, 2);
+      SetSubtreeCount(trigonometricSymbols, 1, 1);
+      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(exponentialAndLogarithmicSymbols, 1, 1);
+      SetSubtreeCount(terminalSymbols, 0, 0);
+      foreach (var sy in new Symbol[] { mean, median, sd, sum, length, min, max, variance, skewness, kurtosis })
+        SetSubtreeCount(sy, 1, 1);
+      SetSubtreeCount(quantile, 2, 2);
+      SetSubtreeCount(distancesSymbols, 2, 2);
+      #region TimeSeries symbols
+      foreach (var sy in new Symbol[] {
+        absoluteEnergy, hasLargeStandardDeviation, hasVarianceLargerThanStd, isSymmetricLooking,
+         numberDataPointsAboveMean, numberDataPointsAboveMedian, numberDataPointsBelowMean, numberDataPointsBelowMedian
+      }) SetSubtreeCount(sy, 1, 1);
+      foreach (var sy in new Symbol[] { binnedEntropy })
+        SetSubtreeCount(sy, 2, 2);
+
+      foreach (var sy in new Symbol[] {
+        firstIndexMax, firstIndexMin, lastIndexMax, lastIndexMin,
+        longestStrikeAboveMean, longestStrikeAboveMedian, longestStrikeBelowMean, longestStrikeBelowMedian,
+        longestStrikePositive, longestStrikeNegative, longestStrikeZero,
+        meanAbsoluteChange, meanAutocorrelation, meanSecondDerivateCentral
+      }) SetSubtreeCount(sy, 1, 1);
+      foreach (var sy in new Symbol[] {
+        fastFourierTransformationCoefficient, laggedAutocorrelation, numberPeaksOfSize, timeReversalAsymmetryStatistic
+      }) SetSubtreeCount(sy, 2, 2);
+      foreach (var sy in new Symbol[] {
+        arimaModelCoefficients, continuousWaveletTransformationCoefficients,
+        meanAbsoluteChangeQuantiles, largeNumberOfPeaks
+      }) SetSubtreeCount(sy, 3, 3);
+      #endregion
+
+      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);
+
+      SetSubtreeCount(subvector, 1, 1);
+      #endregion
+
+      #region allowed child symbols configuration
+      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, 0);
+      AddAllowedChildSymbol(statisticsSymbols, subvector, 0);
+      AddAllowedChildSymbol(quantile, constantZeroToOne, 1);
+      AddAllowedChildSymbol(distancesSymbols, vectorSymbols, 1);
+      AddAllowedChildSymbol(distributionCharacteristicsSymbols, vectorSymbols, 0);
+      AddAllowedChildSymbol(distributionCharacteristicsSymbols, subvector, 0);
+      AddAllowedChildSymbol(distributionCharacteristicsSymbols, constantZeroToOne, 1);
+      AddAllowedChildSymbol(timeSeriesDynamicsSymbols, vectorSymbols, 0);
+      AddAllowedChildSymbol(timeSeriesDynamicsSymbols, subvector, 0);
+      AddAllowedChildSymbol(timeSeriesDynamicsSymbols, constantZeroToOne, 1);
+      AddAllowedChildSymbol(timeSeriesDynamicsSymbols, constantZeroToOne, 2);
+
+      AddAllowedChildSymbol(vectorarithmeticSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorarithmeticSymbols, scalarSymbols);
+      AddAllowedChildSymbol(vectortrigonometricSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorexponentialAndLogarithmicSymbols, vectorSymbols);
+      AddAllowedChildSymbol(vectorpowerSymbols, vectorSymbols, 0);
+      AddAllowedChildSymbol(vectorpower, constantZeroToOne, 1);
+      AddAllowedChildSymbol(vectorroot, constantZeroToOne, 1);
+
+      AddAllowedChildSymbol(subvector, vectorSymbols);
+      #endregion
+
+      #region default enabled/disabled
+      var disabledByDefault = new[] {
+        TrigonometricFunctionsName, ExponentialFunctionsName, PowerFunctionsName,
+        VectorTrigonometricFunctionsName, VectorExponentialFunctionsName, VectorPowerFunctionsName,
+        VectorManipulationSymbolsName
+      };
+      foreach (var grp in Symbols.Where(sym => disabledByDefault.Contains(sym.Name)))
+        grp.Enabled = false;
+      #endregion
+    }
+
+    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));
+          varSymbol.VariableDataType = typeof(double);
+        }
+      }
+      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));
+          varSymbol.VariableDataType = typeof(DoubleVector);
+        }
+      }
+    }
+  }
+}
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 17829)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 17830)
@@ -181,4 +181,5 @@
     <Compile Include="Grammars\FullFunctionalVectorExpressionGrammar.cs" />
     <Compile Include="Grammars\TypeCoherentVectorExpressionGrammar.cs" />
+    <Compile Include="Grammars\TypeCoherentVectorTimeSeriesExpressionGrammar.cs" />
     <Compile Include="Hashing\HashExtensions.cs" />
     <Compile Include="Hashing\HashUtil.cs" />
@@ -260,4 +261,5 @@
     <Compile Include="Symbols\Skewness.cs" />
     <Compile Include="Symbols\SubVector.cs" />
+    <Compile Include="Symbols\TimeSeriesSymbols.cs" />
     <Compile Include="Symbols\WindowedSymbolTreeNode.cs" />
     <Compile Include="Symbols\WindowedSymbol.cs" />
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 17829)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 17830)
@@ -91,4 +91,41 @@
     SubVector = 64,
 
+    #region Time Series Symbols
+    Median = 100,
+    Quantile = 101,
+
+    AbsoluteEnergy = 102,
+    BinnedEntropy = 103,
+    HasLargeStandardDeviation = 104,
+    HasVarianceLargerThanStd = 105,
+    IsSymmetricLooking = 106,
+    NumberDataPointsAboveMean = 107,
+    NumberDataPointsAboveMedian = 108,
+    NumberDataPointsBelowMean = 109,
+    NumberDataPointsBelowMedian = 110,
+
+    ArimaModelCoefficients = 111,
+    ContinuousWaveletTransformationCoefficients = 112,
+    FastFourierTransformationCoefficient = 113,
+    FirstIndexMax = 124,
+    FirstIndexMin = 125,
+    LastIndexMax = 126,
+    LastIndexMin = 127,
+    LongestStrikeAboveMean = 128,
+    LongestStrikeAboveMedian = 129,
+    LongestStrikeBelowMean = 130,
+    LongestStrikeBelowMedian = 131,
+    LongestStrikePositive = 132,
+    LongestStrikeNegative = 133,
+    LongestStrikeZero = 134,
+    MeanAbsoluteChange = 135,
+    MeanAbsoluteChangeQuantiles = 136,
+    MeanAutocorrelation = 137,
+    LaggedAutocorrelation = 138,
+    MeanSecondDerivateCentral = 139,
+    NumberPeaksOfSize = 140,
+    LargeNumberOfPeaks = 141,
+    TimeReversalAsymmetryStatistic = 142
+    #endregion
   }
   public static class OpCodes {
@@ -158,4 +195,41 @@
     public const byte Covariance = (byte)OpCode.Covariance;
     public const byte SubVector = (byte)OpCode.SubVector;
+    #region Time Series Symbols
+    public const byte Median = (byte)OpCode.Median;
+    public const byte Quantile = (byte)OpCode.Quantile;
+
+    public const byte AbsoluteEnergy = (byte)OpCode.AbsoluteEnergy;
+    public const byte BinnedEntropy = (byte)OpCode.BinnedEntropy;
+    public const byte HasLargeStandardDeviation = (byte)OpCode.HasLargeStandardDeviation;
+    public const byte HasVarianceLargerThanStd = (byte)OpCode.HasVarianceLargerThanStd;
+    public const byte IsSymmetricLooking = (byte)OpCode.IsSymmetricLooking;
+    public const byte NumberDataPointsAboveMean = (byte)OpCode.NumberDataPointsAboveMean;
+    public const byte NumberDataPointsAboveMedian = (byte)OpCode.NumberDataPointsAboveMedian;
+    public const byte NumberDataPointsBelowMean = (byte)OpCode.NumberDataPointsBelowMean;
+    public const byte NumberDataPointsBelowMedian = (byte)OpCode.NumberDataPointsBelowMedian;
+
+    public const byte ArimaModelCoefficients = (byte)OpCode.ArimaModelCoefficients;
+    public const byte ContinuousWaveletTransformationCoefficients = (byte)OpCode.ContinuousWaveletTransformationCoefficients;
+    public const byte FastFourierTransformationCoefficient = (byte)OpCode.FastFourierTransformationCoefficient;
+    public const byte FirstIndexMax = (byte)OpCode.FirstIndexMax;
+    public const byte FirstIndexMin = (byte)OpCode.FirstIndexMin;
+    public const byte LastIndexMax = (byte)OpCode.LastIndexMax;
+    public const byte LastIndexMin = (byte)OpCode.LastIndexMin;
+    public const byte LongestStrikeAboveMean = (byte)OpCode.LongestStrikeAboveMean;
+    public const byte LongestStrikeAboveMedian = (byte)OpCode.LongestStrikeAboveMedian;
+    public const byte LongestStrikeBelowMean = (byte)OpCode.LongestStrikeBelowMean;
+    public const byte LongestStrikeBelowMedian = (byte)OpCode.LongestStrikeBelowMedian;
+    public const byte LongestStrikePositive = (byte)OpCode.LongestStrikePositive;
+    public const byte LongestStrikeNegative = (byte)OpCode.LongestStrikeNegative;
+    public const byte LongestStrikeZero = (byte)OpCode.LongestStrikeZero;
+    public const byte MeanAbsoluteChange = (byte)OpCode.MeanAbsoluteChange;
+    public const byte MeanAbsoluteChangeQuantiles = (byte)OpCode.MeanAbsoluteChangeQuantiles;
+    public const byte MeanAutocorrelation = (byte)OpCode.MeanAutocorrelation;
+    public const byte LaggedAutocorrelation = (byte)OpCode.LaggedAutocorrelation;
+    public const byte MeanSecondDerivateCentral = (byte)OpCode.MeanSecondDerivateCentral;
+    public const byte NumberPeaksOfSize = (byte)OpCode.NumberPeaksOfSize;
+    public const byte LargeNumberOfPeaks = (byte)OpCode.LargeNumberOfPeaks;
+    public const byte TimeReversalAsymmetryStatistic = (byte)OpCode.TimeReversalAsymmetryStatistic;
+    #endregion
 
 
@@ -226,4 +300,42 @@
       { typeof(Covariance), OpCodes.Covariance },
       { typeof(SubVector), OpCodes.SubVector },
+
+      #region Time Series Symbols
+      { typeof(Median), OpCodes.Median },
+      { typeof(Quantile), OpCodes.Quantile },
+
+      { typeof(AbsoluteEnergy), OpCodes.AbsoluteEnergy },
+      { typeof(BinnedEntropy), OpCodes.BinnedEntropy },
+      { typeof(HasLargeStandardDeviation), OpCodes.HasLargeStandardDeviation },
+      { typeof(HasVarianceLargerThanStd), OpCodes.HasVarianceLargerThanStd },
+      { typeof(IsSymmetricLooking), OpCodes.IsSymmetricLooking },
+      { typeof(NumberDataPointsAboveMean), OpCodes.NumberDataPointsAboveMean },
+      { typeof(NumberDataPointsAboveMedian), OpCodes.NumberDataPointsAboveMedian },
+      { typeof(NumberDataPointsBelowMean), OpCodes.NumberDataPointsBelowMean },
+      { typeof(NumberDataPointsBelowMedian), OpCodes.NumberDataPointsBelowMedian },
+
+      { typeof(ArimaModelCoefficients), OpCodes.ArimaModelCoefficients },
+      { typeof(ContinuousWaveletTransformationCoefficients), OpCodes.ContinuousWaveletTransformationCoefficients },
+      { typeof(FastFourierTransformationCoefficient), OpCodes.FastFourierTransformationCoefficient },
+      { typeof(FirstIndexMax), OpCodes.FirstIndexMax },
+      { typeof(FirstIndexMin), OpCodes.FirstIndexMin },
+      { typeof(LastIndexMax), OpCodes.LastIndexMax },
+      { typeof(LastIndexMin), OpCodes.LastIndexMin },
+      { typeof(LongestStrikeAboveMean), OpCodes.LongestStrikeAboveMean },
+      { typeof(LongestStrikeAboveMedian), OpCodes.LongestStrikeAboveMedian },
+      { typeof(LongestStrikeBelowMean), OpCodes.LongestStrikeBelowMean },
+      { typeof(LongestStrikeBelowMedian), OpCodes.LongestStrikeBelowMedian },
+      { typeof(LongestStrikePositive), OpCodes.LongestStrikePositive },
+      { typeof(LongestStrikeNegative), OpCodes.LongestStrikeNegative },
+      { typeof(LongestStrikeZero), OpCodes.LongestStrikeZero },
+      { typeof(MeanAbsoluteChange), OpCodes.MeanAbsoluteChange },
+      { typeof(MeanAbsoluteChangeQuantiles), OpCodes.MeanAbsoluteChangeQuantiles },
+      { typeof(MeanAutocorrelation), OpCodes.MeanAutocorrelation },
+      { typeof(LaggedAutocorrelation), OpCodes.LaggedAutocorrelation },
+      { typeof(MeanSecondDerivateCentral), OpCodes.MeanSecondDerivateCentral },
+      { typeof(NumberPeaksOfSize), OpCodes.NumberPeaksOfSize },
+      { typeof(LargeNumberOfPeaks), OpCodes.LargeNumberOfPeaks },
+      { typeof(TimeReversalAsymmetryStatistic), OpCodes.TimeReversalAsymmetryStatistic },              
+      #endregion
     };
 
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs	(revision 17829)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs	(revision 17830)
@@ -209,6 +209,5 @@
 
     public SymbolicDataAnalysisExpressionTreeVectorInterpreter()
-      : this("SymbolicDataAnalysisExpressionTreeVectorInterpreter", "Interpreter for symbolic expression trees including vector arithmetic.") {
-    }
+      : this("SymbolicDataAnalysisExpressionTreeVectorInterpreter", "Interpreter for symbolic expression trees including vector arithmetic.") { }
 
     protected SymbolicDataAnalysisExpressionTreeVectorInterpreter(string name, string description)
@@ -752,8 +751,421 @@
           }
 
+        #region Time Series Symbols
+        case OpCodes.Median: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => s,
+              v => Statistics.Median(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.Quantile: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var q = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => s,
+              v => Statistics.Quantile(v, q.Scalar));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+
+        case OpCodes.AbsoluteEnergy: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => s * s,
+              v => v.PointwisePower(2.0).Sum());
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+
+        case OpCodes.BinnedEntropy: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var m = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                int bins = (int)Math.Round(m.Scalar);
+                double minValue = v.Minimum();
+                double maxValue = v.Maximum();
+                double intervalWidth = (maxValue - minValue) / bins;
+                int totalValues = v.Count;
+                double sum = 0;
+                for (int i = 0; i < Math.Max(bins, v.Count); i++) {
+                  double binMin = minValue * i;
+                  double binMax = binMin + intervalWidth;
+                  double countBin = v.Map(e => (e > binMin && e < binMax) ? 1 : 0).Sum();
+                  double percBin = countBin / totalValues;
+                  sum += percBin * Math.Log(percBin);
+                }
+
+                return sum;
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.HasLargeStandardDeviation: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => Statistics.PopulationStandardDeviation(v) > (Statistics.Maximum(v) - Statistics.Minimum(v)) / 2 ? 1 : 0);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.HasVarianceLargerThanStd: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => Statistics.PopulationVariance(v) > Statistics.StandardDeviation(v) ? 1 : 0);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.IsSymmetricLooking: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => Math.Abs(Statistics.Mean(v) - Statistics.Median(v)) < (Statistics.Maximum(v) - Statistics.Minimum(v)) / 2 ? 1 : 0);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.NumberDataPointsAboveMean: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double mean = Statistics.Mean(v);
+                return v.Map(e => e > mean ? 1 : 0).Sum();
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.NumberDataPointsAboveMedian: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double median = Statistics.Median(v);
+                return v.Map(e => e > median ? 1 : 0).Sum();
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.NumberDataPointsBelowMean: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double mean = Statistics.Mean(v);
+                return v.Map(e => e < mean ? 1 : 0).Sum();
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.NumberDataPointsBelowMedian: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double median = Statistics.Median(v);
+                return v.Map(e => e < median ? 1 : 0).Sum();
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+
+        case OpCodes.ArimaModelCoefficients: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var i = Evaluate(dataset, ref row, state, traceDict);
+            var k = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => throw new NotImplementedException(""));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.ContinuousWaveletTransformationCoefficients: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var a = Evaluate(dataset, ref row, state, traceDict);
+            var b = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => throw new NotImplementedException(""));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.FastFourierTransformationCoefficient: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var k = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => throw new NotImplementedException(""));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.FirstIndexMax: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => (double)v.MaximumIndex() / v.Count);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.FirstIndexMin: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => (double)v.MinimumIndex() / v.Count);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LastIndexMax: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => (double)(v.Count - DoubleVector.Build.DenseOfEnumerable(v.Reverse()).MaximumIndex()) / v.Count);
+
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LastIndexMin: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => (double)(v.Count - DoubleVector.Build.DenseOfEnumerable(v.Reverse()).MinimumIndex()) / v.Count);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeAboveMean: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeAbove(v, Statistics.Mean(v)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeAboveMedian: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeAbove(v, Statistics.Median(v)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeBelowMean: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeBelow(v, Statistics.Mean(v)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeBelowMedian: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeBelow(v, Statistics.Median(v)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikePositive: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeAbove(v, 0));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeNegative: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeAbove(v, 0));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LongestStrikeZero: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => LongestStrikeEqual(v, 0));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.MeanAbsoluteChange: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double sum = 0.0;
+                for (int i = 0; i < v.Count - 1; i++) {
+                  sum += Math.Abs(v[i + 1] - v[i]);
+                }
+
+                return sum / v.Count;
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.MeanAbsoluteChangeQuantiles: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var ql = Evaluate(dataset, ref row, state, traceDict);
+            var qu = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                var lowerBound = Statistics.Quantile(v, ql.Scalar);
+                var upperBound = Statistics.Quantile(v, qu.Scalar);
+                var inBounds = v.Select(e => e > lowerBound && e < upperBound).ToList();
+                double sum = 0.0;
+                int count = 0;
+                for (int i = 0; i < v.Count - 1; i++) {
+                  if (inBounds[i] && inBounds[i + 1]) {
+                    sum += Math.Abs(v[i + 1] - v[i]);
+                    count++;
+                  }
+                }
+
+                return sum / count;
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.MeanAutocorrelation: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double sum = 0.0;
+                double mean = Statistics.Mean(v);
+                for (int l = 0; l < v.Count; l++) {
+                  for (int i = 0; i < v.Count - l; i++) {
+                    sum += (v[i] - mean) * (v[i + l] - mean);
+                  }
+                }
+
+                return sum / (v.Count - 1) / Statistics.PopulationVariance(v);
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LaggedAutocorrelation: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var lVal = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double sum = 0.0;
+                int l = (int)Math.Round(lVal.Scalar);
+                double mean = Statistics.Mean(v);
+                for (int i = 0; i < v.Count - l; i++) {
+                  sum += (v[i] - mean) * (v[i + l] - mean);
+                }
+
+                return sum / Statistics.PopulationVariance(v);
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.MeanSecondDerivateCentral: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                double sum = 0.0;
+                for (int i = 1; i < v.Count - 1; i++) {
+                  sum += (v[i - 1] - 2 * v[i] + v[i + 1]) / 2;
+                }
+
+                return sum / (v.Count - 2);
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.NumberPeaksOfSize: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var l = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => CountNumberOfPeaks(v, l.Scalar));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.LargeNumberOfPeaks: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var l = Evaluate(dataset, ref row, state, traceDict);
+            var m = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => CountNumberOfPeaks(v, l.Scalar) > m.Scalar ? 1.0 : 0.0);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.TimeReversalAsymmetryStatistic: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            var l = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
+              s => 0,
+              v => {
+                int lag = (int)Math.Round(l.Scalar);
+                double sum = 0.0;
+                for (int i = 0; i < v.Count - 2 * lag; i++) {
+                  sum += Math.Pow(v[i + 2 * lag], 2) * v[i + lag] - v[i + lag] * Math.Pow(v[i], 2);
+                }
+
+                return sum / (v.Count - 2 * lag);
+              });
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        #endregion
+
         default:
           throw new NotSupportedException($"Unsupported OpCode: {currentInstr.opCode}");
       }
     }
+
+    private static int LongestStrikeAbove(DoubleVector v, double threshold) {
+      int longestStrike = 0, currentStrike = 0;
+      for (int i = 0; i < v.Count; i++) {
+        if (v[i] > threshold) {
+          currentStrike++;
+          longestStrike = Math.Max(longestStrike, currentStrike);
+        } else
+          currentStrike = 0;
+      }
+      return longestStrike;
+    }
+    private static int LongestStrikeBelow(DoubleVector v, double threshold) {
+      int longestStrike = 0, currentStrike = 0;
+      for (int i = 0; i < v.Count; i++) {
+        if (v[i] < threshold) {
+          currentStrike++;
+          longestStrike = Math.Max(longestStrike, currentStrike);
+        } else
+          currentStrike = 0;
+      }
+      return longestStrike;
+    }
+
+    private static int LongestStrikeEqual(DoubleVector v, double value, double epsilon = double.Epsilon) {
+      int longestStrike = 0, currentStrike = 0;
+      for (int i = 0; i < v.Count; i++) {
+        if (v[i].IsAlmost(epsilon)) {
+          currentStrike++;
+          longestStrike = Math.Max(longestStrike, currentStrike);
+        } else
+          currentStrike = 0;
+      }
+      return longestStrike;
+    }
+    private static int CountNumberOfPeaks(DoubleVector v, double heightDifference) {
+      int count = 0;
+      for (int i = 0; i < v.Count; i++) {
+        bool largerThanPrev = i == 0 || v[i] > v[i - 1] + heightDifference;
+        bool largerThanNext = i == v.Count - 1 || v[i] > v[i + 1] + heightDifference;
+        if (largerThanPrev && largerThanNext)
+          count++;
+      }
+      return count;
+    }
   }
 }
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeSeriesSymbols.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeSeriesSymbols.cs	(revision 17830)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeSeriesSymbols.cs	(revision 17830)
@@ -0,0 +1,377 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+
+  // This file contains selected symbols from 
+  // M. Christ et al. "Distributed and parallel time series feature extraction for industrial big data applications"
+
+  #region Appendix A.1: Features from summary statistics
+  // maximum
+  // minimum
+  // mean
+  // var
+  // std
+  // skewness
+  // kurtosis
+  // length
+  // median
+
+  [Item("Median", "Symbol that represents the median function."), StorableType("62460F36-459D-4B78-AB91-DCF9B8D6A414")]
+  public sealed class Median : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private Median(StorableConstructorFlag _) : base(_) { }
+    private Median(Median original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new Median(this, cloner); }
+    public Median() : base("Median", "Symbol that represents the median function.") { }
+  }
+
+  [Item("Quantile", "Symbol that represents the quantile of an empiric distribution."), StorableType("3BEA06D1-7603-473C-9E7D-4DB56AEFEF17")]
+  public sealed class Quantile : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private Quantile(StorableConstructorFlag _) : base(_) { }
+    private Quantile(Quantile original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new Quantile(this, cloner); }
+    public Quantile() : base("Quantile", "Symbol that represents the quantile of an empiric distribution.") { }
+  }
+  #endregion
+
+  #region Appendix A.2: Additional Characteristics of sample distribution
+  [Item("AbsoluteEnergy", ""), StorableType("4871F884-D23A-4F21-9458-5DB0D7DE2FBD")]
+  public sealed class AbsoluteEnergy : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private AbsoluteEnergy(StorableConstructorFlag _) : base(_) { }
+    private AbsoluteEnergy(AbsoluteEnergy original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new AbsoluteEnergy(this, cloner); }
+    public AbsoluteEnergy() : base("AbsoluteEnergy", "") { }
+  }
+
+  [Item("BinnedEntropy", ""), StorableType("9AB9F4C3-F9AD-4FE6-A1FA-53C578549F34")]
+  public sealed class BinnedEntropy : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private BinnedEntropy(StorableConstructorFlag _) : base(_) { }
+    private BinnedEntropy(BinnedEntropy original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new BinnedEntropy(this, cloner); }
+    public BinnedEntropy() : base("BinnedEntropy", "") { }
+  }
+
+  [Item("HasLargeStandardDeviation", ""), StorableType("F17B2C41-2B5F-439F-B7DE-C5EF7C815048")]
+  public sealed class HasLargeStandardDeviation : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private HasLargeStandardDeviation(StorableConstructorFlag _) : base(_) { }
+    private HasLargeStandardDeviation(HasLargeStandardDeviation original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new HasLargeStandardDeviation(this, cloner); }
+    public HasLargeStandardDeviation() : base("HasLargeStandardDeviation", "") { }
+  }
+
+  [Item("HasVarianceLargerThanStd", ""), StorableType("F2C40872-F7F5-45B8-9DDA-072C6479DF2F")]
+  public sealed class HasVarianceLargerThanStd : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private HasVarianceLargerThanStd(StorableConstructorFlag _) : base(_) { }
+    private HasVarianceLargerThanStd(HasVarianceLargerThanStd original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new HasVarianceLargerThanStd(this, cloner); }
+    public HasVarianceLargerThanStd() : base("HasVarianceLargerThanStd", "") { }
+  }
+
+  [Item("IsSymmetricLooking", ""), StorableType("1C8AE0D5-5454-42A4-BACB-033D1A1669BA")]
+  public sealed class IsSymmetricLooking : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private IsSymmetricLooking(StorableConstructorFlag _) : base(_) { }
+    private IsSymmetricLooking(IsSymmetricLooking original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new IsSymmetricLooking(this, cloner); }
+    public IsSymmetricLooking() : base("IsSymmetricLooking", "") { }
+  }
+
+  [Item("NumberDataPointsAboveMean", ""), StorableType("FD9FF3DB-78A6-43D0-89A4-B9FE83D73FFA")]
+  public sealed class NumberDataPointsAboveMean : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private NumberDataPointsAboveMean(StorableConstructorFlag _) : base(_) { }
+    private NumberDataPointsAboveMean(NumberDataPointsAboveMean original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NumberDataPointsAboveMean(this, cloner); }
+    public NumberDataPointsAboveMean() : base("NumberDataPointsAboveMean", "") { }
+  }
+
+  [Item("NumberDataPointsAboveMedian", ""), StorableType("D0F78A96-D3DD-488F-838B-E7B8A4BF05F1")]
+  public sealed class NumberDataPointsAboveMedian : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private NumberDataPointsAboveMedian(StorableConstructorFlag _) : base(_) { }
+    private NumberDataPointsAboveMedian(NumberDataPointsAboveMedian original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NumberDataPointsAboveMedian(this, cloner); }
+    public NumberDataPointsAboveMedian() : base("NumberDataPointsAboveMedian", "") { }
+  }
+
+  [Item("NumberDataPointsBelowMean", ""), StorableType("EA914163-44AF-42CE-B59E-C4F65DF4D991")]
+  public sealed class NumberDataPointsBelowMean : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private NumberDataPointsBelowMean(StorableConstructorFlag _) : base(_) { }
+    private NumberDataPointsBelowMean(NumberDataPointsBelowMean original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NumberDataPointsBelowMean(this, cloner); }
+    public NumberDataPointsBelowMean() : base("NumberDataPointsBelowMean", "") { }
+  }
+
+  [Item("NumberDataPointsBelowMedian", ""), StorableType("93BCF4B5-5716-4A89-BEEC-A69EF59C871F")]
+  public sealed class NumberDataPointsBelowMedian : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private NumberDataPointsBelowMedian(StorableConstructorFlag _) : base(_) { }
+    private NumberDataPointsBelowMedian(NumberDataPointsBelowMedian original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NumberDataPointsBelowMedian(this, cloner); }
+    public NumberDataPointsBelowMedian() : base("NumberDataPointsBelowMedian", "") { }
+  }
+  #endregion
+
+  #region Appending A.3: Features derived from observed dynamics
+  [Item("ArimaModelCoefficients", ""), StorableType("BCA361B2-EFE8-481F-8363-40BFE4AA5092")]
+  public sealed class ArimaModelCoefficients : Symbol {
+    public override int MinimumArity => 3;
+    public override int MaximumArity => 3;
+    [StorableConstructor] private ArimaModelCoefficients(StorableConstructorFlag _) : base(_) { }
+    private ArimaModelCoefficients(ArimaModelCoefficients original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new ArimaModelCoefficients(this, cloner); }
+    public ArimaModelCoefficients() : base("ArimaModelCoefficients", "") { }
+  }
+
+  [Item("ContinuousWaveletTransformationCoefficients", ""), StorableType("F8770E95-4165-49AC-A52A-250C60434BC4")]
+  public sealed class ContinuousWaveletTransformationCoefficients : Symbol {
+    public override int MinimumArity => 3;
+    public override int MaximumArity => 3;
+    [StorableConstructor] private ContinuousWaveletTransformationCoefficients(StorableConstructorFlag _) : base(_) { }
+    private ContinuousWaveletTransformationCoefficients(ContinuousWaveletTransformationCoefficients original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new ContinuousWaveletTransformationCoefficients(this, cloner); }
+    public ContinuousWaveletTransformationCoefficients() : base("ContinuousWaveletTransformationCoefficients", "") { }
+  }
+
+  [Item("FastFourierTransformationCoefficient", ""), StorableType("417E3923-1318-44B0-A4E2-D324F42ED249")]
+  public sealed class FastFourierTransformationCoefficient : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private FastFourierTransformationCoefficient(StorableConstructorFlag _) : base(_) { }
+    private FastFourierTransformationCoefficient(FastFourierTransformationCoefficient original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new FastFourierTransformationCoefficient(this, cloner); }
+    public FastFourierTransformationCoefficient() : base("FastFourierTransformationCoefficient", "") { }
+  }
+
+  [Item("FirstIndexMax", ""), StorableType("DF7DE795-61C1-434E-B7AC-123871BB81D9")]
+  public sealed class FirstIndexMax : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private FirstIndexMax(StorableConstructorFlag _) : base(_) { }
+    private FirstIndexMax(FirstIndexMax original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new FirstIndexMax(this, cloner); }
+    public FirstIndexMax() : base("FirstIndexMax", "") { }
+  }
+
+  [Item("FirstIndexMin", ""), StorableType("AF8DF281-E68B-48AF-B13C-D8AFA212B52C")]
+  public sealed class FirstIndexMin : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private FirstIndexMin(StorableConstructorFlag _) : base(_) { }
+    private FirstIndexMin(FirstIndexMin original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new FirstIndexMin(this, cloner); }
+    public FirstIndexMin() : base("FirstIndexMin", "") { }
+  }
+
+  [Item("LastIndexMax", ""), StorableType("318EE355-E86B-432C-A72A-44AEEE149032")]
+  public sealed class LastIndexMax : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LastIndexMax(StorableConstructorFlag _) : base(_) { }
+    private LastIndexMax(LastIndexMax original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LastIndexMax(this, cloner); }
+    public LastIndexMax() : base("LastIndexMax", "") { }
+  }
+
+  [Item("LastIndexMin", ""), StorableType("D00C8065-3AC4-40E4-97C3-22C578F51A73")]
+  public sealed class LastIndexMin : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LastIndexMin(StorableConstructorFlag _) : base(_) { }
+    private LastIndexMin(LastIndexMin original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LastIndexMin(this, cloner); }
+    public LastIndexMin() : base("LastIndexMin", "") { }
+  }
+
+  [Item("LongestStrikeAboveMean", ""), StorableType("4720C78C-A2F3-40A6-8675-421B09A78BA5")]
+  public sealed class LongestStrikeAboveMean : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeAboveMean(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeAboveMean(LongestStrikeAboveMean original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeAboveMean(this, cloner); }
+    public LongestStrikeAboveMean() : base("LongestStrikeAboveMean", "") { }
+  }
+
+  [Item("LongestStrikeAboveMedian", ""), StorableType("2E1232CB-7BDD-4500-AC75-C6FA9DD300A9")]
+  public sealed class LongestStrikeAboveMedian : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeAboveMedian(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeAboveMedian(LongestStrikeAboveMedian original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeAboveMedian(this, cloner); }
+    public LongestStrikeAboveMedian() : base("LongestStrikeAboveMedian", "") { }
+  }
+
+  [Item("LongestStrikeBelowMean", ""), StorableType("C27B6F0C-37AF-48F7-8619-1B3F836F4740")]
+  public sealed class LongestStrikeBelowMean : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeBelowMean(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeBelowMean(LongestStrikeBelowMean original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeBelowMean(this, cloner); }
+    public LongestStrikeBelowMean() : base("LongestStrikeBelowMean", "") { }
+  }
+
+  [Item("LongestStrikeBelowMedian", ""), StorableType("E489362B-46E3-4AB3-ABBA-9C3DEC584F80")]
+  public sealed class LongestStrikeBelowMedian : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeBelowMedian(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeBelowMedian(LongestStrikeBelowMedian original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeBelowMedian(this, cloner); }
+    public LongestStrikeBelowMedian() : base("LongestStrikeBelowMedian", "") { }
+  }
+
+  [Item("LongestStrikePositive", ""), StorableType("F384A095-8DF9-4457-9AC0-A40AACEBE50A")]
+  public sealed class LongestStrikePositive : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikePositive(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikePositive(LongestStrikePositive original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikePositive(this, cloner); }
+    public LongestStrikePositive() : base("LongestStrikePositive", "") { }
+  }
+
+  [Item("LongestStrikeNegative", ""), StorableType("282AA4BD-88F9-4C87-BA6B-9FCF7D9A983C")]
+  public sealed class LongestStrikeNegative : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeNegative(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeNegative(LongestStrikeNegative original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeNegative(this, cloner); }
+    public LongestStrikeNegative() : base("LongestStrikeNegative", "") { }
+  }
+
+  [Item("LongestStrikeZero", ""), StorableType("DB3A1172-E975-4F71-AE9D-D2375F777CD4")]
+  public sealed class LongestStrikeZero : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private LongestStrikeZero(StorableConstructorFlag _) : base(_) { }
+    private LongestStrikeZero(LongestStrikeZero original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LongestStrikeZero(this, cloner); }
+    public LongestStrikeZero() : base("LongestStrikeZero", "") { }
+  }
+
+  [Item("MeanAbsoluteChange", ""), StorableType("43E6AB4F-BDF4-42B5-84DF-D384C3FFA728")]
+  public sealed class MeanAbsoluteChange : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private MeanAbsoluteChange(StorableConstructorFlag _) : base(_) { }
+    private MeanAbsoluteChange(MeanAbsoluteChange original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MeanAbsoluteChange(this, cloner); }
+    public MeanAbsoluteChange() : base("MeanAbsoluteChange", "") { }
+  }
+
+  [Item("MeanAbsoluteChangeQuantiles", ""), StorableType("77BD8C07-9EC0-42B2-8FE4-1AA35A952B28")]
+  public sealed class MeanAbsoluteChangeQuantiles : Symbol {
+    public override int MinimumArity => 3;
+    public override int MaximumArity => 3;
+    [StorableConstructor] private MeanAbsoluteChangeQuantiles(StorableConstructorFlag _) : base(_) { }
+    private MeanAbsoluteChangeQuantiles(MeanAbsoluteChangeQuantiles original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MeanAbsoluteChangeQuantiles(this, cloner); }
+    public MeanAbsoluteChangeQuantiles() : base("MeanAbsoluteChangeQuantiles", "") { }
+  }
+
+  [Item("MeanAutocorrelation", ""), StorableType("589F8A85-1332-4B9D-B85E-F81CF2E46C58")]
+  public sealed class MeanAutocorrelation : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private MeanAutocorrelation(StorableConstructorFlag _) : base(_) { }
+    private MeanAutocorrelation(MeanAutocorrelation original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MeanAutocorrelation(this, cloner); }
+    public MeanAutocorrelation() : base("MeanAutocorrelation", "") { }
+  }
+
+  [Item("LaggedAutocorrelation", ""), StorableType("E93A8BF9-69EF-4FCA-99B0-FF9157C63814")]
+  public sealed class LaggedAutocorrelation : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private LaggedAutocorrelation(StorableConstructorFlag _) : base(_) { }
+    private LaggedAutocorrelation(LaggedAutocorrelation original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LaggedAutocorrelation(this, cloner); }
+    public LaggedAutocorrelation() : base("LaggedAutocorrelation", "") { }
+  }
+
+  [Item("MeanSecondDerivateCentral", ""), StorableType("8C31A24F-83E2-4027-85F1-185AAF7C421D")]
+  public sealed class MeanSecondDerivateCentral : Symbol {
+    public override int MinimumArity => 1;
+    public override int MaximumArity => 1;
+    [StorableConstructor] private MeanSecondDerivateCentral(StorableConstructorFlag _) : base(_) { }
+    private MeanSecondDerivateCentral(MeanSecondDerivateCentral original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MeanSecondDerivateCentral(this, cloner); }
+    public MeanSecondDerivateCentral() : base("MeanSecondDerivateCentral", "") { }
+  }
+
+  [Item("NumberPeaksOfSize", ""), StorableType("F57A6E86-F2A2-4884-BD29-9C74A694B3B0")]
+  public sealed class NumberPeaksOfSize : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private NumberPeaksOfSize(StorableConstructorFlag _) : base(_) { }
+    private NumberPeaksOfSize(NumberPeaksOfSize original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NumberPeaksOfSize(this, cloner); }
+    public NumberPeaksOfSize() : base("NumberPeaksOfSize", "") { }
+  }
+
+  [Item("LargeNumberOfPeaks", ""), StorableType("0E0EF4C6-0FA7-45C0-92C1-245392B33040")]
+  public sealed class LargeNumberOfPeaks : Symbol {
+    public override int MinimumArity => 3;
+    public override int MaximumArity => 3;
+    [StorableConstructor] private LargeNumberOfPeaks(StorableConstructorFlag _) : base(_) { }
+    private LargeNumberOfPeaks(LargeNumberOfPeaks original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LargeNumberOfPeaks(this, cloner); }
+    public LargeNumberOfPeaks() : base("LargeNumberOfPeaks", "") { }
+  }
+
+  [Item("TimeReversalAsymmetryStatistic", ""), StorableType("F4CDC994-0931-46B5-ACE3-765010FF41C4")]
+  public sealed class TimeReversalAsymmetryStatistic : Symbol {
+    public override int MinimumArity => 2;
+    public override int MaximumArity => 2;
+    [StorableConstructor] private TimeReversalAsymmetryStatistic(StorableConstructorFlag _) : base(_) { }
+    private TimeReversalAsymmetryStatistic(TimeReversalAsymmetryStatistic original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new TimeReversalAsymmetryStatistic(this, cloner); }
+    public TimeReversalAsymmetryStatistic() : base("TimeReversalAsymmetryStatistic", "") { }
+  }
+  #endregion
+}
