source: branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/ExpressionTemplate.cs @ 15921

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 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;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.ExpressionGenerator.Interfaces;
using HeuristicLab.Random;

namespace HeuristicLab.ExpressionGenerator {
  public interface IExpressionTemplate {
    string Label { get; set; }
  }
  public abstract class ExpressionTemplate : IExpressionTemplate {
    protected List<Tuple<Expression, double>> arguments;
    protected readonly Func<IEnumerable<double>, double> transform;
    public string Label { get; set; }

    protected Expression Instantiate(string name, IRandom random, int n, bool sampleWithRepetition = false) {
      var func = Expression.Function(name, transform, SampleArguments(random, n, sampleWithRepetition));
      func.Label = Label;
      return func;
    }

    protected IEnumerable<Expression> SampleArguments(IRandom random, int n, bool sampleWithRepetition = false) {
      var weights = arguments.Select(x => x.Item2);
      var args = sampleWithRepetition
       ? arguments.SampleProportional(random, n, weights, windowing: false).Select(x => x.Item1)
       : arguments.SampleProportionalWithoutRepetition(random, n, weights, windowing: false).Select(x => x.Item1);
      return args;
    }

    public abstract Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false);

    protected ExpressionTemplate(Func<IEnumerable<double>, double> transform) {
      this.transform = transform;
    }

    public void AddArgument(Expression expression, double weight = 1d) {
      arguments = arguments ?? new List<Tuple<Expression, double>>();
      arguments.Add(Tuple.Create(expression, weight));
    }

    public void AddArguments(IEnumerable<Expression> expressions) {
      arguments = arguments ?? new List<Tuple<Expression, double>>();
      arguments.AddRange(expressions.Select(x => Tuple.Create(x, 1d)));
    }

    public void AddArguments(IEnumerable<Expression> expressions, IEnumerable<double> weights) {
      arguments = arguments ?? new List<Tuple<Expression, double>>();
      arguments.AddRange(expressions.Zip(weights, Tuple.Create));
    }
  }

  public class RandomArityTemplate : ExpressionTemplate {
    private readonly IDistribution<int> arityDistribution;

    public RandomArityTemplate(Func<IEnumerable<double>, double> transform, IDistribution<int> arityDistribution) : base(transform) {
      this.arityDistribution = arityDistribution;
    }

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      var arity = arityDistribution.Sample();
      return Instantiate(name, random, arity, sampleWithRepetition);
    }
  }

  public class FixedArityTemplate : ExpressionTemplate {
    private readonly int arity;
    public FixedArityTemplate(Func<IEnumerable<double>, double> transform, int arity) : base(transform) {
      this.arity = arity;
    }

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      return Instantiate(name, random, arity, sampleWithRepetition);
    }
  }


  public class BinaryOperatorTemplate : IExpressionTemplate {
    public string Label { get; set; }
    private readonly Func<IEnumerable<double>, double> transform;
    private List<Tuple<Expression, double>> leftArguments;
    private List<Tuple<Expression, double>> rightArguments;

    public BinaryOperatorTemplate(Func<IEnumerable<double>, double> transform) {
      this.transform = transform;
    }

    public void AddLeftArgument(Expression expression, double weight = 1d) {
      leftArguments = leftArguments ?? new List<Tuple<Expression, double>>();
      leftArguments.Add(Tuple.Create(expression, weight));
    }

    public void AddLeftArguments(IEnumerable<Expression> expressions) {
      leftArguments = leftArguments ?? new List<Tuple<Expression, double>>();
      leftArguments.AddRange(expressions.Select(x => Tuple.Create(x, 1d)));
    }

    public void AddLeftArguments(IEnumerable<Expression> expressions, IEnumerable<double> weights) {
      leftArguments = leftArguments ?? new List<Tuple<Expression, double>>();
      leftArguments.AddRange(expressions.Zip(weights, Tuple.Create));
    }


    public void AddRightArgument(Expression expression, double weight = 1d) {
      rightArguments = rightArguments ?? new List<Tuple<Expression, double>>();
      rightArguments.Add(Tuple.Create(expression, weight));
    }

    public void AddRightArguments(IEnumerable<Expression> expressions) {
      rightArguments = rightArguments ?? new List<Tuple<Expression, double>>();
      rightArguments.AddRange(expressions.Select(x => Tuple.Create(x, 1d)));
    }

    public void AddRightArguments(IEnumerable<Expression> expressions, IEnumerable<double> weights) {
      rightArguments = rightArguments ?? new List<Tuple<Expression, double>>();
      rightArguments.AddRange(expressions.Zip(weights, Tuple.Create));
    }

    public Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      Expression leftArgument = null;
      Expression rightArgument = null;
      {
        var weights = leftArguments.Select(x => x.Item2);
        leftArgument = sampleWithRepetition
          ? leftArguments.SampleProportional(random, 1, weights, windowing: false).Select(x => x.Item1).First() :
          leftArguments.SampleProportionalWithoutRepetition(random, 1, weights, windowing: false).Select(x => x.Item1).First();
      }
      {
        var weights = rightArguments.Select(x => x.Item2);
        rightArgument = sampleWithRepetition
          ? rightArguments.SampleProportional(random, 1, weights).Select(x => x.Item1).First() :
          rightArguments.SampleProportionalWithoutRepetition(random, 1, weights).Select(x => x.Item1).First();
      }

      var func = Expression.Function(name, transform, new Expression[] { leftArgument, rightArgument });
      func.Label = Label;
      return func;
    }
  }

  public class ScalingTemplate : ExpressionTemplate {
    private readonly IDistribution<double> scaledVariance;
    // w * expr
    public ScalingTemplate(IDistribution<double> scaledVariance = null) : base(ExpressionGenerator.Product) {
      this.scaledVariance = scaledVariance;
    }

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      var expr = SampleArguments(random, 1, sampleWithRepetition).First();

      // use the evaluator to determine variance of the sampled expression and initialize the constant accordingly to reach the target variance
      var @const = 1.0;
      if (scaledVariance != null) {
        var evaluator = new ExpressionEvaluator();
        var data = evaluator.GenerateData(expr, 10000);
        var variance = data[expr].VariancePop();
        @const = scaledVariance.Sample() / variance;
      }

      var func = Expression.Function(name, transform, new Expression[] { Expression.Constant(name, @const), expr });
      func.Label = "*";
      return func;
    }
  }

  public class OffsetTemplate : ExpressionTemplate {
    private readonly IDistribution<double> offset;
    // expr + offset
    public OffsetTemplate(IDistribution<double> offset = null) : base(ExpressionGenerator.Sum) {
      this.offset = offset;
    }

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      var expr = SampleArguments(random, 1, sampleWithRepetition).First();

      // use the evaluator to determine variance of the sampled expression and initialize the constant accordingly to reach the target offset
      var @const = 0.0;
      if (offset != null) {
        var evaluator = new ExpressionEvaluator();
        var data = evaluator.GenerateData(expr, 10000);
        var average = data[expr].Average();
        @const = offset.Sample() - average;
      }

      var func = Expression.Function(name, transform, new Expression[] { Expression.Constant(name, @const), expr });
      func.Label = "+";
      return func;
    }
  }

  public class RangeTemplate : ExpressionTemplate {
    private readonly IDistribution<double> minValue;
    private readonly IDistribution<double> valueRange;
    // expr + offset
    public RangeTemplate(IDistribution<double> minValue = null, IDistribution<double> valueRange = null) : base(null) {
      this.minValue = minValue;
      this.valueRange = valueRange;
    }

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      var expr = SampleArguments(random, 1, sampleWithRepetition).First();

      // use the evaluator to determine variance of the sampled expression and initialize the constant accordingly to reach the target offset
      var mult = 1.0;
      var add = 0.0;

      if (minValue != null || valueRange != null) {
        var evaluator = new ExpressionEvaluator();
        var data = evaluator.GenerateData(expr, 10000);
        if (valueRange != null) {
          var targetRange = valueRange.Sample();
          var min = data[expr].Min();
          var max = data[expr].Max();
          var range = max - min;
          mult = targetRange / range;
          add = -min + min / mult;
        }
        if (minValue != null) {
          var targetMin = minValue.Sample();
          var min = data[expr].Min();
          add += (targetMin - min) / mult;
        }

        expr = Expression.Function(name + "-toZero", ExpressionGenerator.Sum, new Expression[] { Expression.Constant("name-add0", add), expr });
        expr.Label = "+";
        expr = Expression.Function(name + "-mult", ExpressionGenerator.Product, new Expression[] { Expression.Constant("name-mult", mult), expr });
        expr.Label = "*";
      }

      return expr;
    }
  }
}