source: branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Problems.DynamicalSystemsModelling/3.3/Solution.cs @ 16653

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Random;

namespace HeuristicLab.Problems.DynamicalSystemsModelling {
  [StorableClass]
  public class Solution : Item {
    [Storable]
    private ISymbolicExpressionTree[] trees;
    public ISymbolicExpressionTree[] Trees {
      get { return trees; }
    }
    // [Storable]
    // private double[] theta;

    [Storable]
    private IRegressionProblemData problemData;
    public IRegressionProblemData ProblemData {
      get { return problemData; }
    }
    [Storable]
    private string[] targetVars;
    public string[] TargetVariables {
      get { return targetVars; }
    }
    [Storable]
    private string[] latentVariables;
    public string[] LatentVariables {
      get { return latentVariables; }
    }
    [Storable]
    private IEnumerable<IntRange> trainingEpisodes;
    public IEnumerable<IntRange> TrainingEpisodes {
      get { return trainingEpisodes; }
    }
    [Storable]
    private string odeSolver;
    [Storable]
    private int numericIntegrationSteps;

    [StorableConstructor]
    private Solution(bool deserializing) : base(deserializing) { }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    // cloning 
    private Solution(Solution original, Cloner cloner)
      : base(original, cloner) {
      this.trees = new ISymbolicExpressionTree[original.trees.Length];
      for (int i = 0; i < trees.Length; i++) this.trees[i] = cloner.Clone(original.trees[i]);
      // this.theta = new double[original.theta.Length];
      // Array.Copy(original.theta, this.theta, this.theta.Length);
      this.problemData = cloner.Clone(original.problemData);
      this.targetVars = original.TargetVariables.ToArray();
      this.latentVariables = original.LatentVariables.ToArray();
      this.trainingEpisodes = original.TrainingEpisodes.Select(te => cloner.Clone(te)).ToArray();
      this.odeSolver = original.odeSolver;
      this.numericIntegrationSteps = original.numericIntegrationSteps;
    }

    public Solution(ISymbolicExpressionTree[] trees,
      IRegressionProblemData problemData,
      string[] targetVars, string[] latentVariables, IEnumerable<IntRange> trainingEpisodes,
      string odeSolver, int numericIntegrationSteps) : base() {
      this.trees = trees;

      this.problemData = problemData;
      this.targetVars = targetVars;
      this.latentVariables = latentVariables;
      this.trainingEpisodes = trainingEpisodes;
      this.odeSolver = odeSolver;
      this.numericIntegrationSteps = numericIntegrationSteps;
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new Solution(this, cloner);
    }

    public IEnumerable<double[]> Predict(IntRange episode, int forecastHorizon, out double snmse) {
      var forecastEpisode = new IntRange(episode.Start, episode.End + forecastHorizon);
      // 
      // var random = new FastRandom(12345);
      // snmse = Problem.OptimizeForEpisodes(trees, problemData, targetVars, latentVariables, random, new[] { forecastEpisode }, 100, numericIntegrationSteps, odeSolver);

      var inputVariables = trees.SelectMany(t => t.IterateNodesPrefix().OfType<VariableTreeNode>().Select(n => n.VariableName)).Except(targetVars);

      var optimizationData = new Problem.OptimizationData(trees, targetVars, inputVariables.ToArray(), problemData, null, new[] { forecastEpisode }, numericIntegrationSteps, latentVariables, odeSolver);
      // 
      // 
      // var theta = Problem.ExtractParametersFromTrees(trees);

      snmse = 0.0; // TODO
      return Problem.Integrate(optimizationData).Select(p => p.Select(pi => pi.Item1).ToArray()).ToArray();
    }
  }
}