Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
10/11/12 17:48:27 (12 years ago)
Author:
mkommend
Message:

#1081: Reintegrated time series modeling branch into trunk.

Location:
trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic
Files:
2 deleted
12 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingBestSolutionAnalyzer.cs

    r7259 r8798  
    8585
    8686      var results = ResultCollection;
    87       if (TrainingBestSolutionQuality == null ||
    88         IsBetter(bestQuality, TrainingBestSolutionQuality.Value, Maximization.Value)) {
     87      if (bestTree != null && (TrainingBestSolutionQuality == null ||
     88        IsBetter(bestQuality, TrainingBestSolutionQuality.Value, Maximization.Value))) {
    8989        TrainingBestSolution = CreateSolution(bestTree, bestQuality);
    9090        TrainingBestSolutionQuality = new DoubleValue(bestQuality);

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs

    r8664 r8798  
    4545    private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
    4646    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     47    private const string ValidRowIndicatorParameterName = "ValidRowIndicator";
    4748
    4849    public override bool CanChangeName { get { return false; } }
    … …  
    7475      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
    7576    }
     77    public IValueLookupParameter<StringValue> ValidRowIndicatorParameter {
     78      get { return (IValueLookupParameter<StringValue>)Parameters[ValidRowIndicatorParameterName]; }
     79    }
    7680    #endregion
    7781
    … …  
    9296      Parameters.Add(new ValueLookupParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation between the start and end index."));
    9397      Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Flag that indicates if the individual should be linearly scaled before evaluating."));
     98      Parameters.Add(new ValueLookupParameter<StringValue>(ValidRowIndicatorParameterName, "An indicator variable in the data set that specifies which rows should be evaluated (those for which the indicator <> 0) (optional)."));
    9499    }
    95100
    … …  
    100105      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName))
    101106        Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Flag that indicates if the individual should be linearly scaled before evaluating."));
     107      if (!Parameters.ContainsKey(ValidRowIndicatorParameterName))
     108        Parameters.Add(new ValueLookupParameter<StringValue>(ValidRowIndicatorParameterName, "An indicator variable in the data set that specifies which rows should be evaluated (those for which the indicator <> 0) (optional)."));
    102109    }
    103110
    … …  
    112119      int testPartitionStart = ProblemDataParameter.ActualValue.TestPartition.Start;
    113120      int testPartitionEnd = ProblemDataParameter.ActualValue.TestPartition.End;
    114 
    115121      if (samplesEnd < samplesStart) throw new ArgumentException("Start value is larger than end value.");
    116122
    … …  
    124130      }
    125131
    126       return rows.Where(i => i < testPartitionStart || testPartitionEnd <= i);
     132      rows = rows.Where(i => i < testPartitionStart || testPartitionEnd <= i);
     133      if (ValidRowIndicatorParameter.ActualValue != null) {
     134        string indicatorVar = ValidRowIndicatorParameter.ActualValue.Value;
     135        var problemData = ProblemDataParameter.ActualValue;
     136        var indicatorRow = problemData.Dataset.GetReadOnlyDoubleValues(indicatorVar);
     137        rows = rows.Where(r => !indicatorRow[r].IsAlmost(0.0));
     138      }
     139      return rows;
    127140    }
    128141

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r7708 r8798  
    3333  [StorableClass]
    3434  public sealed class SymbolicDataAnalysisExpressionLatexFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
    35     private List<double> constants;
     35    private readonly List<double> constants;
     36    private int targetCount;
    3637    private int currentLag;
    3738
    … …  
    9899      } else if (node.Symbol is Division) {
    99100        if (node.SubtreeCount == 1) {
    100           strBuilder.Append(@" \cfrac{1}{");
     101          strBuilder.Append(@" \cfrac{1");
    101102        } else {
    102103          strBuilder.Append(@" \cfrac{ ");
    … …  
    196197        strBuilder.Append(invokeNode.Symbol.FunctionName + @" \left( ");
    197198      } else if (node.Symbol is StartSymbol) {
    198         strBuilder.Append("Result & = ");
     199        strBuilder.Append("target_" + (targetCount++) + "(t) & = ");
    199200      } else if (node.Symbol is Argument) {
    200201        var argSym = node.Symbol as Argument;
    … …  
    301302        strBuilder.Append(" , ");
    302303      } else if (node.Symbol is StartSymbol) {
    303         strBuilder.Append(@"\\" + Environment.NewLine + " & ");
     304        strBuilder.Append(@"\\" + Environment.NewLine);
     305        strBuilder.Append("target_" + (targetCount++) + "(t) & = ");
    304306      } else if (node.Symbol is Power) {
    305307        strBuilder.Append(@"\right) ^ { \operatorname{round} \left(");

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs

    r7707 r8798  
    116116      var laggedVariable = new LaggedVariable();
    117117      laggedVariable.InitialFrequency = 0.0;
     118      var autoregressiveVariable = new AutoregressiveTargetVariable();
     119      autoregressiveVariable.InitialFrequency = 0.0;
     120      autoregressiveVariable.Enabled = false;
    118121
    119122      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, square, pow, sqrt, root, exp,
    120123        airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral,
    121         @if, gt, lt, and, or, not, timeLag, integral, derivative, constant, variableSymbol, laggedVariable, variableCondition };
     124        @if, gt, lt, and, or, not, timeLag, integral, derivative, constant, variableSymbol, laggedVariable,autoregressiveVariable, variableCondition };
    122125      var unaryFunctionSymbols = new List<Symbol>() { square, sqrt, sin, cos, tan, log, exp, not, timeLag, integral, derivative,
    123126        airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral
    … …  
    126129      var binaryFunctionSymbols = new List<Symbol>() { pow, root, gt, lt, variableCondition };
    127130      var ternarySymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or };
    128       var terminalSymbols = new List<Symbol>() { variableSymbol, constant, laggedVariable };
     131      var terminalSymbols = new List<Symbol>() { variableSymbol, constant, laggedVariable, autoregressiveVariable };
    129132
    130133      foreach (var symb in allSymbols)

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

    r7696 r8798  
    104104      var variableSymbol = new Variable();
    105105      var laggedVariable = new LaggedVariable();
     106      var autoregressiveVariable = new AutoregressiveTargetVariable();
    106107      #endregion
    107108
    … …  
    122123      var conditionalSymbols = new GroupSymbol(ConditionalSymbolsName, new List<ISymbol> { conditionSymbols, comparisonSymbols, booleanOperationSymbols });
    123124
    124       var timeSeriesSymbols = new GroupSymbol(TimeSeriesSymbolsName, new List<ISymbol> { timeLag, integral, derivative, laggedVariable });
     125      var timeSeriesSymbols = new GroupSymbol(TimeSeriesSymbolsName, new List<ISymbol> { timeLag, integral, derivative, laggedVariable, autoregressiveVariable });
    125126      #endregion
    126127
    … …  
    152153      SetSubtreeCount(derivative, 1, 1);
    153154      SetSubtreeCount(laggedVariable, 0, 0);
     155      SetSubtreeCount(autoregressiveVariable, 0, 0);
    154156      #endregion
    155157
    … …  
    225227      Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
    226228    }
     229
     230    public void ConfigureAsDefaultTimeSeriesPrognosisGrammar() {
     231      Symbols.First(s => s is Average).Enabled = false;
     232      Symbols.First(s => s.Name == TrigonometricFunctionsName).Enabled = false;
     233      Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
     234      Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
     235      Symbols.First(s => s.Name == SpecialFunctionsName).Enabled = false;
     236
     237      Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = true;
     238      Symbols.First(s => s is Derivative).Enabled = false;
     239      Symbols.First(s => s is Integral).Enabled = false;
     240      Symbols.First(s => s is TimeLag).Enabled = false;
     241    }
    227242  }
    228243}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r8793 r8798  
    141141    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs" />
    142142    <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionCrossover.cs" />
     143    <Compile Include="Interpreter\InterpreterState.cs" />
     144    <Compile Include="Interpreter\OpCodes.cs" />
     145    <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs" />
     146    <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeInterpreter.cs" />
    143147    <Compile Include="Plugin.cs" />
    144     <Compile Include="SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs" />
    145148    <Compile Include="Formatters\SymbolicDataAnalysisExpressionLatexFormatter.cs" />
    146149    <Compile Include="Formatters\SymbolicDataAnalysisExpressionMATLABFormatter.cs" />
    … …  
    160163    <Compile Include="Interfaces\ISymbolicDataAnalysisAnalyzer.cs" />
    161164    <Compile Include="SymbolicDataAnalysisSingleObjectiveProblem.cs" />
    162     <Compile Include="SymbolicDataAnalysisExpressionTreeInterpreter.cs" />
    163165    <Compile Include="SymbolicDataAnalysisExpressionTreeSimplifier.cs" />
    164166    <Compile Include="SymbolicDataAnalysisProblem.cs" />
    165167    <Compile Include="Symbols\Addition.cs" />
    166168    <Compile Include="Symbols\And.cs" />
     169    <Compile Include="Symbols\AutoregressiveVariable.cs" />
    167170    <Compile Include="Symbols\Average.cs" />
    168171    <Compile Include="Symbols\Constant.cs" />

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r8436 r8798  
    565565        case OpCodes.Variable: {
    566566            VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
     567            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
     568            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
     569            // load correct column of the current variable
     570            il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
     571            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    567572            if (!state.InLaggedContext) {
    568               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
    569               il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
    570               // load correct column of the current variable
    571               il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    572               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    573573              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
    574574              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
    … …  
    577577              var nanResult = il.DefineLabel();
    578578              var normalResult = il.DefineLabel();
    579               var cachedValue = il.DefineLabel();
    580               var multiplyValue = il.DefineLabel();
    581               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    582579              il.Emit(System.Reflection.Emit.OpCodes.Dup);
    583580              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
    … …  
    586583              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
    587584              il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
    588               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3);
    589               il.Emit(System.Reflection.Emit.OpCodes.Bge, cachedValue);
    590               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
    591               il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
    592               il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    593               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    594585              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
    595               il.Emit(System.Reflection.Emit.OpCodes.Br, multiplyValue);
    596               il.MarkLabel(cachedValue);
    597               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2); // load cached values array
    598               il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
    599               il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    600               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    601               il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startRow
    602               il.Emit(System.Reflection.Emit.OpCodes.Sub); // startRow
    603               il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
    604               il.MarkLabel(multiplyValue);
    605586              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
    606587              il.Emit(System.Reflection.Emit.OpCodes.Mul);
    … …  
    608589              il.MarkLabel(nanResult);
    609590              il.Emit(System.Reflection.Emit.OpCodes.Pop); // rowIndex
     591              il.Emit(System.Reflection.Emit.OpCodes.Pop); // column reference
    610592              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
    611593              il.MarkLabel(normalResult);
    … …  
    616598            var nanResult = il.DefineLabel();
    617599            var normalResult = il.DefineLabel();
    618             var cachedValue = il.DefineLabel();
    619             var multiplyValue = il.DefineLabel();
    620600            LaggedVariableTreeNode varNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
     601            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
     602            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
     603            // load correct column of the current variable
     604            il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    621605            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
    622606            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    … …  
    628612            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
    629613            il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
    630             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startindex
    631             il.Emit(System.Reflection.Emit.OpCodes.Bge, cachedValue);
    632             // normal value
    633             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
    634             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0); // load correct column of the current variable
    635             il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    636             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
    637             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    638             il.Emit(System.Reflection.Emit.OpCodes.Add); // actualRowIndex = rowIndex + sampleOffset
    639614            il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
    640             il.Emit(System.Reflection.Emit.OpCodes.Br, multiplyValue);
    641             il.MarkLabel(cachedValue);
    642             // cached value
    643             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2); // load cached values
    644             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0); // load correct column of the current variable
    645             il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
    646             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
    647             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
    648             il.Emit(System.Reflection.Emit.OpCodes.Add); // actualRowIndex = rowIndex + sampleOffset
    649             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startRow
    650             il.Emit(System.Reflection.Emit.OpCodes.Sub); // startRow           
    651             il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
    652 
    653             il.MarkLabel(multiplyValue);
    654615            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
    655616            il.Emit(System.Reflection.Emit.OpCodes.Mul);
    656617            il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
    657618            il.MarkLabel(nanResult);
    658             il.Emit(System.Reflection.Emit.OpCodes.Pop); // pop the row index
     619            il.Emit(System.Reflection.Emit.OpCodes.Pop); // sample index
     620            il.Emit(System.Reflection.Emit.OpCodes.Pop); // column reference
    659621            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
    660622            il.MarkLabel(normalResult);
    … …  
    769731      return alglib.besseli0(x);
    770732    }
    771 
    772733  }
    773734}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

    r7696 r8798  
    5252    private GreaterThan gtSymbol = new GreaterThan();
    5353    private LessThan ltSymbol = new LessThan();
     54    private Integral integralSymbol = new Integral();
     55    private LaggedVariable laggedVariableSymbol = new LaggedVariable();
     56    private TimeLag timeLagSymbol = new TimeLag();
    5457
    5558    public ISymbolicExpressionTree Simplify(ISymbolicExpressionTree originalTree) {
    … …  
    182185    private bool IsConstant(ISymbolicExpressionTreeNode node) {
    183186      return node.Symbol is Constant;
     187    }
     188
     189    // dynamic
     190    private bool IsTimeLag(ISymbolicExpressionTreeNode node) {
     191      return node.Symbol is TimeLag;
     192    }
     193    private bool IsIntegral(ISymbolicExpressionTreeNode node) {
     194      return node.Symbol is Integral;
    184195    }
    185196
    … …  
    234245      } else if (IsNot(original)) {
    235246        return SimplifyNot(original);
     247      } else if (IsTimeLag(original)) {
     248        return SimplifyTimeLag(original);
     249      } else if (IsIntegral(original)) {
     250        return SimplifyIntegral(original);
    236251      } else {
    237252        return SimplifyAny(original);
    … …  
    376391      return MakePower(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
    377392    }
     393    private ISymbolicExpressionTreeNode SimplifyTimeLag(ISymbolicExpressionTreeNode original) {
     394      var laggedTreeNode = original as ILaggedTreeNode;
     395      var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
     396      if (!ContainsVariableCondition(simplifiedSubtree)) {
     397        return AddLagToDynamicNodes(simplifiedSubtree, laggedTreeNode.Lag);
     398      } else {
     399        return MakeTimeLag(simplifiedSubtree, laggedTreeNode.Lag);
     400      }
     401    }
     402    private ISymbolicExpressionTreeNode SimplifyIntegral(ISymbolicExpressionTreeNode original) {
     403      var laggedTreeNode = original as ILaggedTreeNode;
     404      var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
     405      if (IsConstant(simplifiedSubtree)) {
     406        return GetSimplifiedTree(MakeProduct(simplifiedSubtree, MakeConstant(-laggedTreeNode.Lag)));
     407      } else {
     408        return MakeIntegral(simplifiedSubtree, laggedTreeNode.Lag);
     409      }
     410    }
     411
    378412    #endregion
    379413
    380414    #region low level tree restructuring
     415    private ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
     416      if (lag == 0) return subtree;
     417      if (IsConstant(subtree)) return subtree;
     418      var lagNode = (LaggedTreeNode)timeLagSymbol.CreateTreeNode();
     419      lagNode.Lag = lag;
     420      lagNode.AddSubtree(subtree);
     421      return lagNode;
     422    }
     423
     424    private ISymbolicExpressionTreeNode MakeIntegral(ISymbolicExpressionTreeNode subtree, int lag) {
     425      if (lag == 0) return subtree;
     426      else if (lag == -1 || lag == 1) {
     427        return MakeSum(subtree, AddLagToDynamicNodes((ISymbolicExpressionTreeNode)subtree.Clone(), lag));
     428      } else {
     429        var node = (LaggedTreeNode)integralSymbol.CreateTreeNode();
     430        node.Lag = lag;
     431        node.AddSubtree(subtree);
     432        return node;
     433      }
     434    }
     435
    381436    private ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
    382437      if (IsConstant(t)) {
    … …  
    847902
    848903    #region helper functions
     904    private bool ContainsVariableCondition(ISymbolicExpressionTreeNode node) {
     905      if (node.Symbol is VariableCondition) return true;
     906      foreach (var subtree in node.Subtrees)
     907        if (ContainsVariableCondition(subtree)) return true;
     908      return false;
     909    }
     910
     911    private ISymbolicExpressionTreeNode AddLagToDynamicNodes(ISymbolicExpressionTreeNode node, int lag) {
     912      var laggedTreeNode = node as ILaggedTreeNode;
     913      var variableNode = node as VariableTreeNode;
     914      var variableConditionNode = node as VariableConditionTreeNode;
     915      if (laggedTreeNode != null)
     916        laggedTreeNode.Lag += lag;
     917      else if (variableNode != null) {
     918        var laggedVariableNode = (LaggedVariableTreeNode)laggedVariableSymbol.CreateTreeNode();
     919        laggedVariableNode.Lag = lag;
     920        laggedVariableNode.VariableName = variableNode.VariableName;
     921        return laggedVariableNode;
     922      } else if (variableConditionNode != null) {
     923        throw new NotSupportedException("Removal of time lags around variable condition symbols is not allowed.");
     924      }
     925      var subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
     926      while (node.SubtreeCount > 0) node.RemoveSubtree(0);
     927      foreach (var subtree in subtrees) {
     928        node.AddSubtree(AddLagToDynamicNodes(subtree, lag));
     929      }
     930      return node;
     931    }
    849932
    850933    private bool AreSameVariable(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/AutoregressiveVariable.cs

    r8789 r8798  
    2525namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    2626  [StorableClass]
    27   [Item("LaggedVariable", "Represents a variable value with a time offset.")]
     27  [Item("AutoregressiveTargetVariable", "Represents a variable value with a time offset.")]
    2828  public sealed class AutoregressiveTargetVariable : LaggedVariable {
    2929    [StorableConstructor]

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LaggedVariable.cs

    r7259 r8798  
    2727  [StorableClass]
    2828  [Item("LaggedVariable", "Represents a variable value with a time offset.")]
    29   public sealed class LaggedVariable : Variable {
     29  public class LaggedVariable : Variable {
    3030    [Storable]
    3131    private int minLag;
    … …  
    4141    }
    4242    [StorableConstructor]
    43     private LaggedVariable(bool deserializing) : base(deserializing) { }
    44     private LaggedVariable(LaggedVariable original, Cloner cloner)
     43    protected LaggedVariable(bool deserializing) : base(deserializing) { }
     44    protected LaggedVariable(LaggedVariable original, Cloner cloner)
    4545      : base(original, cloner) {
    4646      minLag = original.minLag;
    4747      maxLag = original.maxLag;
    4848    }
    49     public LaggedVariable()
    50       : base("LaggedVariable", "Represents a variable value with a time offset.") {
    51       minLag = -1; maxLag = -1;
     49    public LaggedVariable() : this("LaggedVariable", "Represents a variable value with a time offset.") { }
     50    protected LaggedVariable(string name, string description)
     51      : base(name, description) {
     52      MinLag = -1;
     53      MaxLag = -1;
    5254    }
    5355

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LaggedVariableTreeNode.cs

    r7259 r8798  
    3737    }
    3838
     39    public override bool HasLocalParameters {
     40      get { return true; }
     41    }
     42
    3943    [StorableConstructor]
    4044    private LaggedVariableTreeNode(bool deserializing) : base(deserializing) { }
    … …  
    4347      lag = original.lag;
    4448    }
    45     private LaggedVariableTreeNode() { }
    4649
    4750    public LaggedVariableTreeNode(LaggedVariable variableSymbol) : base(variableSymbol) { }
    4851
    49     public override bool HasLocalParameters {
    50       get {
    51         return true;
    52       }
    53     }
    5452
    5553    public override void ResetLocalParameters(IRandom random) {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Variable.cs

    r7259 r8798  
    101101    }
    102102
     103    public override bool Enabled {
     104      get {
     105        if (variableNames.Count == 0) return false;
     106        return base.Enabled;
     107      }
     108      set {
     109        if (variableNames.Count == 0) base.Enabled = false;
     110        else base.Enabled = value;
     111      }
     112    }
     113
    103114    private const int minimumArity = 0;
    104115    private const int maximumArity = 0;
Note: See TracChangeset for help on using the changeset viewer.