Free cookie consent management tool by TermsFeed Policy Generator

Changeset 17554


Ignore:
Timestamp:
05/25/20 14:52:32 (4 years ago)
Author:
pfleck
Message:

#3040 Added some symbols for statistical aggregation.

Location:
branches/3040_VectorBasedGP
Files:
6 edited
8 copied

Legend:

Unmodified
Added
Removed

  • branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToTensorConverter.cs

    r17502 r17554  
    158158      if (node.Symbol is Exponential) {
    159159        return math_ops.pow(
    160           Math.E,
     160          (float)Math.E,
    161161          ConvertNode(node.GetSubtree(0)));
    162162      }

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

    r17466 r17554  
    3838    private const string TerminalsName = "Terminals";
    3939    private const string VectorAggregationName = "Aggregations";
     40    private const string VectorStatisticsName = "Vector Statistics";
     41    private const string VectorDistancesName = "Vector Distances";
    4042    private const string ScalarSymbolsName = "Scalar Symbols";
    4143
    … …  
    8991      var sd = new StandardDeviation();
    9092      var sum = new Sum();
     93      var length = new Length() { Enabled = false };
     94      var min = new Min() { Enabled = false };
     95      var max = new Max() { Enabled = false };
     96      var variance = new Variance() { Enabled = false };
     97      var skewness = new Skewness() { Enabled = false };
     98      var kurtosis = new Kurtosis() { Enabled = false };
     99      var euclideanDistance = new EuclideanDistance() { Enabled = false };
     100      var covariance = new Covariance() { Enabled = false };
    91101      #endregion
    92102
    … …  
    120130      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, sqrt, cube, cubeRoot, power, root });
    121131      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variable, binFactorVariable, factorVariable });
    122       var aggregationSymbols = new GroupSymbol(VectorAggregationName, new List<ISymbol> { mean, sd, sum });
     132      var statisticsSymbols = new GroupSymbol(VectorStatisticsName, new List<ISymbol> {mean, sd, sum, length, min, max, variance, skewness, kurtosis});
     133      var distancesSymbols = new GroupSymbol(VectorDistancesName, new List<ISymbol> { euclideanDistance, covariance });
     134      var aggregationSymbols = new GroupSymbol(VectorAggregationName, new List<ISymbol> { statisticsSymbols, distancesSymbols });
    123135      var scalarSymbols = new GroupSymbol(ScalarSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, powerSymbols, terminalSymbols, aggregationSymbols });
    124136
    … …  
    151163      SetSubtreeCount(exponentialAndLogarithmicSymbols, 1, 1);
    152164      SetSubtreeCount(terminalSymbols, 0, 0);
    153       SetSubtreeCount(aggregationSymbols, 1, 1);
     165      SetSubtreeCount(statisticsSymbols, 1, 1);
     166      SetSubtreeCount(distancesSymbols, 2, 2);
    154167
    155168      SetSubtreeCount(vectorarithmeticSymbols, 2, 2);

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

    r17475 r17554  
    4747    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    4848    <Prefer32Bit>false</Prefer32Bit>
     49    <LangVersion>latest</LangVersion>
    4950  </PropertyGroup>
    5051  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    … …  
    5758    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    5859    <Prefer32Bit>false</Prefer32Bit>
     60    <LangVersion>latest</LangVersion>
    5961  </PropertyGroup>
    6062  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
    … …  
    6769    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    6870    <Prefer32Bit>false</Prefer32Bit>
     71    <LangVersion>latest</LangVersion>
    6972  </PropertyGroup>
    7073  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
    … …  
    7780    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    7881    <Prefer32Bit>false</Prefer32Bit>
     82    <LangVersion>latest</LangVersion>
    7983  </PropertyGroup>
    8084  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    … …  
    8791    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    8892    <Prefer32Bit>false</Prefer32Bit>
     93    <LangVersion>latest</LangVersion>
    8994  </PropertyGroup>
    9095  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    … …  
    97102    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    98103    <Prefer32Bit>false</Prefer32Bit>
     104    <LangVersion>latest</LangVersion>
    99105  </PropertyGroup>
    100106  <ItemGroup>
    … …  
    233239    <Compile Include="SymbolicDataAnalysisSolutionImpactValuesCalculator.cs" />
    234240    <Compile Include="Symbols\Addition.cs" />
     241    <Compile Include="Symbols\Covariance.cs" />
     242    <Compile Include="Symbols\EuclideanDistance.cs" />
    235243    <Compile Include="Symbols\AnalyticQuotient.cs" />
    236244    <Compile Include="Symbols\And.cs" />
    237245    <Compile Include="Symbols\AutoregressiveVariable.cs" />
     246    <Compile Include="Symbols\Length.cs" />
     247    <Compile Include="Symbols\Max.cs" />
     248    <Compile Include="Symbols\Min.cs" />
    238249    <Compile Include="Symbols\Mean.cs" />
     250    <Compile Include="Symbols\Kurtosis.cs" />
     251    <Compile Include="Symbols\Skewness.cs" />
     252    <Compile Include="Symbols\Variance.cs" />
    239253    <Compile Include="Symbols\StandardDeviation.cs" />
    240254    <Compile Include="Symbols\Sum.cs" />

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

    r17466 r17554  
    8080    Mean = 53,
    8181    StandardDeviation = 54,
    82     Sum = 55
     82    Sum = 55,
     83    Length = 56,
     84    Min = 57,
     85    Max = 58,
     86    Variance = 59,
     87    Skewness = 60,
     88    Kurtosis = 61,
     89    EuclideanDistance = 62 ,
     90    Covariance = 63,
     91
    8392  }
    8493  public static class OpCodes {
    … …  
    139148    public const byte StandardDeviation = (byte)OpCode.StandardDeviation;
    140149    public const byte Sum = (byte)OpCode.Sum;
     150    public const byte Length = (byte)OpCode.Length;
     151    public const byte Min = (byte)OpCode.Min;
     152    public const byte Max = (byte)OpCode.Max;
     153    public const byte Variance = (byte)OpCode.Variance;
     154    public const byte Skewness = (byte)OpCode.Skewness;
     155    public const byte Kurtosis = (byte)OpCode.Kurtosis;
     156    public const byte EuclideanDistance = (byte)OpCode.EuclideanDistance;
     157    public const byte Covariance = (byte)OpCode.Covariance;
    141158
    142159
    … …  
    197214      { typeof(Mean), OpCodes.Mean },
    198215      { typeof(StandardDeviation), OpCodes.StandardDeviation },
    199       { typeof(Sum), OpCodes.Sum }
    200 
     216      { typeof(Sum), OpCodes.Sum },
     217      { typeof(Length), OpCodes.Length },
     218      { typeof(Min), OpCodes.Min },
     219      { typeof(Max), OpCodes.Max },
     220      { typeof(Variance), OpCodes.Variance },
     221      { typeof(Skewness), OpCodes.Skewness },
     222      { typeof(Kurtosis), OpCodes.Kurtosis },
     223      { typeof(EuclideanDistance), OpCodes.EuclideanDistance },
     224      { typeof(Covariance), OpCodes.Covariance },
    201225    };
    202226

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

    r17467 r17554  
    221221      return EvaluationResult.NaN;
    222222    }
     223    private static EvaluationResult AggregateMultipleApply(EvaluationResult lhs, EvaluationResult rhs,
     224      Func<double, double, double> ssFunc = null,
     225      Func<double, DoubleVector, double> svFunc = null,
     226      Func<DoubleVector, double, double> vsFunc = null,
     227      Func<DoubleVector, DoubleVector, double> vvFunc = null) {
     228      if (lhs.IsScalar && rhs.IsScalar && ssFunc != null) return new EvaluationResult(ssFunc(lhs.Scalar, rhs.Scalar));
     229      if (lhs.IsScalar && rhs.IsVector && svFunc != null) return new EvaluationResult(svFunc(lhs.Scalar, rhs.Vector));
     230      if (lhs.IsVector && rhs.IsScalar && vsFunc != null) return new EvaluationResult(vsFunc(lhs.Vector, rhs.Scalar));
     231      if (lhs.IsVector && rhs.IsVector && vvFunc != null) return new EvaluationResult(vvFunc(lhs.Vector, rhs.Vector));
     232      return EvaluationResult.NaN;
     233    }
    223234
    224235    public virtual EvaluationResult Evaluate(IDataset dataset, ref int row, InterpreterState state) {
    … …  
    365376              v => v.Count > 1 ? Statistics.StandardDeviation(v) : 0);
    366377          }
     378        case OpCodes.Length: {
     379          var cur = Evaluate(dataset, ref row, state);
     380          return AggregateApply(cur,
     381            s => 0,
     382            v => v.Count > 1 ? v.Count : 0);
     383        }
     384        case OpCodes.Min: {
     385          var cur = Evaluate(dataset, ref row, state);
     386          return AggregateApply(cur,
     387            s => 0,
     388            v => v.Count > 1 ? Statistics.Minimum(v) : 0);
     389        }
     390        case OpCodes.Max: {
     391          var cur = Evaluate(dataset, ref row, state);
     392          return AggregateApply(cur,
     393            s => 0,
     394            v => v.Count > 1 ? Statistics.Maximum(v) : 0);
     395        }
     396        case OpCodes.Variance: {
     397          var cur = Evaluate(dataset, ref row, state);
     398          return AggregateApply(cur,
     399            s => 0,
     400            v => v.Count > 1 ? Statistics.Variance(v) : 0);
     401        }
     402        case OpCodes.Skewness: {
     403          var cur = Evaluate(dataset, ref row, state);
     404          return AggregateApply(cur,
     405            s => 0,
     406            v => v.Count > 1 ? Statistics.Skewness(v) : 0);
     407        }
     408        case OpCodes.Kurtosis: {
     409          var cur = Evaluate(dataset, ref row, state);
     410          return AggregateApply(cur,
     411            s => 0,
     412            v => v.Count > 1 ? Statistics.Kurtosis(v) : 0);
     413        }
     414        case OpCodes.EuclideanDistance: {
     415          var x1 = Evaluate(dataset, ref row, state);
     416          var x2 = Evaluate(dataset, ref row, state);
     417          return AggregateMultipleApply(x1, x2,
     418            //(s1, s2) => s1 - s2,
     419            //(s1, v2) => Math.Sqrt((s1 - v2).PointwisePower(2).Sum()),
     420            //(v1, s2) => Math.Sqrt((v1 - s2).PointwisePower(2).Sum()),
     421            vvFunc: (v1, v2) => Math.Sqrt((v1 - v2).PointwisePower(2).Sum())
     422          );
     423        }
     424        case OpCodes.Covariance: {
     425          var x1 = Evaluate(dataset, ref row, state);
     426          var x2 = Evaluate(dataset, ref row, state);
     427          return AggregateMultipleApply(x1, x2,
     428            //(s1, s2) => 0,
     429            //(s1, v2) => 0,
     430            //(v1, s2) => 0,
     431            vvFunc: (v1, v2) => v1.Count > 1 && v2.Count > 1 ? Statistics.Covariance(v1, v2) : double.NaN
     432          );
     433        }
    367434        case OpCodes.Variable: {
    368435            if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("1BFD8CB7-7377-4130-9903-1E9A76349285")]
    28   [Item("Analytic Quotient", "The analytic quotient function aq(a,b) = a / sqrt(b²+1) can be used as an " +
    29     "alternative to protected division. See H. Drieberg and P. Rocket, The Use of an Analytic Quotient Operator" +
    30     " in Genetic Programming. IEEE Transactions on Evolutionary Computation, Vol. 17, No. 1, February 2013, pp. 146 -- 152")]
    31   public sealed class AnalyticQuotient : Symbol {
     27  [StorableType("8B554834-78C9-4F2D-BD9F-902A77B598AB")]
     28  [Item("Covariance", "Symbol that represents the covariance function.")]
     29  public sealed class Covariance : Symbol {
    3230    private const int minimumArity = 2;
    3331    private const int maximumArity = 2;
    … …  
    4139
    4240    [StorableConstructor]
    43     private AnalyticQuotient(StorableConstructorFlag _) : base(_) { }
    44     private AnalyticQuotient(AnalyticQuotient original, Cloner cloner) : base(original, cloner) { }
     41    private Covariance(StorableConstructorFlag _) : base(_) { }
     42    private Covariance(Covariance original, Cloner cloner) : base(original, cloner) { }
    4543    public override IDeepCloneable Clone(Cloner cloner) {
    46       return new AnalyticQuotient(this, cloner);
     44      return new Covariance(this, cloner);
    4745    }
    48     public AnalyticQuotient() : base("AnalyticQuotient", "The analytic quotient function aq(a,b) = a / sqrt(b²+1) can be used as an " +
    49     "alternative to protected division. See H. Drieberg and P. Rocket, The Use of an Analytic Quotient Operator" +
    50     " in Genetic Programming. IEEE Transactions on Evolutionary Computation, Vol. 17, No. 1, February 2013, pp. 146 -- 152") { }
     46    public Covariance() : base("Covariance", "Symbol that represents the covariance function.") { }
    5147  }
    5248}

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("1BFD8CB7-7377-4130-9903-1E9A76349285")]
    28   [Item("Analytic Quotient", "The analytic quotient function aq(a,b) = a / sqrt(b²+1) can be used as an " +
    29     "alternative to protected division. See H. Drieberg and P. Rocket, The Use of an Analytic Quotient Operator" +
    30     " in Genetic Programming. IEEE Transactions on Evolutionary Computation, Vol. 17, No. 1, February 2013, pp. 146 -- 152")]
    31   public sealed class AnalyticQuotient : Symbol {
     27  [StorableType("5477A8C6-E557-4E2E-9326-16DF26F5D6A8")]
     28  [Item("Euclidean Distance", "Symbol that represents the Euclidean distance function.")]
     29  public sealed class EuclideanDistance : Symbol {
    3230    private const int minimumArity = 2;
    3331    private const int maximumArity = 2;
    … …  
    4139
    4240    [StorableConstructor]
    43     private AnalyticQuotient(StorableConstructorFlag _) : base(_) { }
    44     private AnalyticQuotient(AnalyticQuotient original, Cloner cloner) : base(original, cloner) { }
     41    private EuclideanDistance(StorableConstructorFlag _) : base(_) { }
     42    private EuclideanDistance(EuclideanDistance original, Cloner cloner) : base(original, cloner) { }
    4543    public override IDeepCloneable Clone(Cloner cloner) {
    46       return new AnalyticQuotient(this, cloner);
     44      return new EuclideanDistance(this, cloner);
    4745    }
    48     public AnalyticQuotient() : base("AnalyticQuotient", "The analytic quotient function aq(a,b) = a / sqrt(b²+1) can be used as an " +
    49     "alternative to protected division. See H. Drieberg and P. Rocket, The Use of an Analytic Quotient Operator" +
    50     " in Genetic Programming. IEEE Transactions on Evolutionary Computation, Vol. 17, No. 1, February 2013, pp. 146 -- 152") { }
     46    public EuclideanDistance() : base("Euclidean Distance", "Symbol that represents the Euclidean distance function.") { }
    5147  }
    5248}

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("615033EC-6A76-4DE7-B55F-BB228D6A8166")]
    28   [Item("StandardDeviation", "Symbol that represents the standard deviation function.")]
    29   public sealed class StandardDeviation : Symbol {
     27  [StorableType("FDE431E4-C20F-4203-9054-6175A8B734A7")]
     28  [Item("Kurtosis", "Symbol that represents the kurtosis function.")]
     29  public sealed class Kurtosis : Symbol {
    3030    private const int minimumArity = 1;
    3131    private const int maximumArity = 1;
    … …  
    3939
    4040    [StorableConstructor]
    41     private StandardDeviation(StorableConstructorFlag _) : base(_) { }
    42     private StandardDeviation(StandardDeviation original, Cloner cloner) : base(original, cloner) { }
     41    private Kurtosis(StorableConstructorFlag _) : base(_) { }
     42    private Kurtosis(Kurtosis original, Cloner cloner) : base(original, cloner) { }
    4343    public override IDeepCloneable Clone(Cloner cloner) {
    44       return new StandardDeviation(this, cloner);
     44      return new Kurtosis(this, cloner);
    4545    }
    46     public StandardDeviation() : base("StandardDeviation", "Symbol that represents the standard deviation function.") { }
     46    public Kurtosis() : base("Kurtosis", "Symbol that represents the kurtosis function.") { }
    4747  }
    4848}

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("615033EC-6A76-4DE7-B55F-BB228D6A8166")]
    28   [Item("StandardDeviation", "Symbol that represents the standard deviation function.")]
    29   public sealed class StandardDeviation : Symbol {
     27  [StorableType("E3634514-DAC3-48FF-93D2-F3AD0E559C07")]
     28  [Item("Length", "Symbol that represents the length function.")]
     29  public sealed class Length : Symbol {
    3030    private const int minimumArity = 1;
    3131    private const int maximumArity = 1;
    … …  
    3939
    4040    [StorableConstructor]
    41     private StandardDeviation(StorableConstructorFlag _) : base(_) { }
    42     private StandardDeviation(StandardDeviation original, Cloner cloner) : base(original, cloner) { }
     41    private Length(StorableConstructorFlag _) : base(_) { }
     42    private Length(Length original, Cloner cloner) : base(original, cloner) { }
    4343    public override IDeepCloneable Clone(Cloner cloner) {
    44       return new StandardDeviation(this, cloner);
     44      return new Length(this, cloner);
    4545    }
    46     public StandardDeviation() : base("StandardDeviation", "Symbol that represents the standard deviation function.") { }
     46    public Length() : base("Length", "Symbol that represents the length function.") { }
    4747  }
    4848}

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

    r17551 r17554  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    28   [StorableType("2AE24E16-849E-4D54-A35B-7FE64BEF8ECB")]
    29   [Item("Mean", "Symbol that represents the mean function.")]
    30   public sealed class Mean : Symbol {
     28  [StorableType("1FFBD7DA-C474-4E99-B24F-AAD6B8B3EB35")]
     29  [Item("Min", "Symbol that represents the max function.")]
     30  public sealed class Max : Symbol {
    3131    private const int minimumArity = 1;
    3232    private const int maximumArity = 1;
    … …  
    4040
    4141    [StorableConstructor]
    42     private Mean(StorableConstructorFlag _) : base(_) { }
    43     private Mean(Mean original, Cloner cloner) : base(original, cloner) { }
     42    private Max(StorableConstructorFlag _) : base(_) { }
     43    private Max(Max original, Cloner cloner) : base(original, cloner) { }
    4444    public override IDeepCloneable Clone(Cloner cloner) {
    45       return new Mean(this, cloner);
     45      return new Max(this, cloner);
    4646    }
    47     public Mean() : base("Mean", "Symbol that represents the mean function.") { }
     47    public Max() : base("Max", "Symbol that represents the max function.") { }
    4848  }
    4949}

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

    r17551 r17554  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    28   [StorableType("2AE24E16-849E-4D54-A35B-7FE64BEF8ECB")]
    29   [Item("Mean", "Symbol that represents the mean function.")]
    30   public sealed class Mean : Symbol {
     28  [StorableType("AB40A794-51A7-45ED-AF83-90D61BE4158D")]
     29  [Item("Min", "Symbol that represents the min function.")]
     30  public sealed class Min : Symbol {
    3131    private const int minimumArity = 1;
    3232    private const int maximumArity = 1;
    … …  
    4040
    4141    [StorableConstructor]
    42     private Mean(StorableConstructorFlag _) : base(_) { }
    43     private Mean(Mean original, Cloner cloner) : base(original, cloner) { }
     42    private Min(StorableConstructorFlag _) : base(_) { }
     43    private Min(Min original, Cloner cloner) : base(original, cloner) { }
    4444    public override IDeepCloneable Clone(Cloner cloner) {
    45       return new Mean(this, cloner);
     45      return new Min(this, cloner);
    4646    }
    47     public Mean() : base("Mean", "Symbol that represents the mean function.") { }
     47    public Min() : base("Min", "Symbol that represents the min function.") { }
    4848  }
    4949}

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("615033EC-6A76-4DE7-B55F-BB228D6A8166")]
    28   [Item("StandardDeviation", "Symbol that represents the standard deviation function.")]
    29   public sealed class StandardDeviation : Symbol {
     27  [StorableType("7C645DC6-6904-4E9C-A9DE-474F66AD6563")]
     28  [Item("Skewness", "Symbol that represents the skewness function.")]
     29  public sealed class Skewness : Symbol {
    3030    private const int minimumArity = 1;
    3131    private const int maximumArity = 1;
    … …  
    3939
    4040    [StorableConstructor]
    41     private StandardDeviation(StorableConstructorFlag _) : base(_) { }
    42     private StandardDeviation(StandardDeviation original, Cloner cloner) : base(original, cloner) { }
     41    private Skewness(StorableConstructorFlag _) : base(_) { }
     42    private Skewness(Skewness original, Cloner cloner) : base(original, cloner) { }
    4343    public override IDeepCloneable Clone(Cloner cloner) {
    44       return new StandardDeviation(this, cloner);
     44      return new Skewness(this, cloner);
    4545    }
    46     public StandardDeviation() : base("StandardDeviation", "Symbol that represents the standard deviation function.") { }
     46    public Skewness() : base("Skewness", "Symbol that represents the skewness function.") { }
    4747  }
    4848}

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

    r17551 r17554  
    2525using HEAL.Attic;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   [StorableType("615033EC-6A76-4DE7-B55F-BB228D6A8166")]
    28   [Item("StandardDeviation", "Symbol that represents the standard deviation function.")]
    29   public sealed class StandardDeviation : Symbol {
     27  [StorableType("E9371D4B-104A-43CF-82F9-4F3B41B2FC3D")]
     28  [Item("Variance", "Symbol that represents the variance function.")]
     29  public sealed class Variance : Symbol {
    3030    private const int minimumArity = 1;
    3131    private const int maximumArity = 1;
    … …  
    3939
    4040    [StorableConstructor]
    41     private StandardDeviation(StorableConstructorFlag _) : base(_) { }
    42     private StandardDeviation(StandardDeviation original, Cloner cloner) : base(original, cloner) { }
     41    private Variance(StorableConstructorFlag _) : base(_) { }
     42    private Variance(Variance original, Cloner cloner) : base(original, cloner) { }
    4343    public override IDeepCloneable Clone(Cloner cloner) {
    44       return new StandardDeviation(this, cloner);
     44      return new Variance(this, cloner);
    4545    }
    46     public StandardDeviation() : base("StandardDeviation", "Symbol that represents the standard deviation function.") { }
     46    public Variance() : base("Variance", "Symbol that represents the variance function.") { }
    4747  }
    4848}

  • branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestTwo.cs

    r17541 r17554  
    3333  public abstract class VectorDataTestTwo : ArtificialRegressionDataDescriptor {
    3434
    35     protected const int Rows = 100;
     35    protected const int Rows = 1000;
    3636
    3737    public override string Description { get { return ""; } }
Note: See TracChangeset for help on using the changeset viewer.