source: branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/ExpressionGenerator.cs @ 14880

#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.Core;
using HeuristicLab.ExpressionGenerator.Interfaces;
using HeuristicLab.Random;

namespace HeuristicLab.ExpressionGenerator {
  public static class ExpressionGenerator {
    public static IEnumerable<Expression> GenerateRandomDistributedVariables(int numberOfVariables, string variablePrefix, IRandom randomDistribution) {
      return Enumerable.Range(1, numberOfVariables).Select(x => Expression.RandomVariable(string.Format("{0}{1}", variablePrefix, x), randomDistribution));
    }

    public static Expression RationalExpression(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp) {
      var numerators =
        Enumerable.Range(0, 20)
          .Select(
            i =>
              NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, false)
                .Instantiate("numerator" + i, uniformRandom, sampleWithRepetition: false))
          .ToArray();
      var denominators =
        Enumerable.Range(0, 20)
          .Select(
            i =>
              NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, false)
                .Instantiate("denominator" + i, uniformRandom, sampleWithRepetition: false))
          .ToArray();


      var scaledNumeratorTemplate = new ScalingTemplate(new PointDistribution<double>(1.0));
      scaledNumeratorTemplate.AddArguments(numerators);

      var scaledDenominatorTemplate = new RangeTemplate(
        minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.01, 1)),
        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 2, 10)));
      scaledDenominatorTemplate.AddArguments(denominators);


      var scaledNumerators =
        Enumerable.Range(0, 20)
          .Select(i => scaledNumeratorTemplate.Instantiate("scaledNumerator" + i, uniformRandom, false));

      var scaledDenominators =
        Enumerable.Range(0, 20)
          .Select(i => scaledDenominatorTemplate.Instantiate("scaledDenom" + i, uniformRandom, false));

      var template = new BinaryOperatorTemplate(Division) { Label = "/" };
      template.AddLeftArguments(scaledNumerators);
      template.AddRightArguments(scaledDenominators);

      return template.Instantiate("rational", uniformRandom, false);
    }

    public static Expression SumOfCompactNonlinearTerms(IRandom uniformRandom, Expression[] variables, bool useLog,
      bool useExp, bool useFrac) {
      var numInstances = 2 * variables.Length;

      var scalingVarsTemplate = new ScalingTemplate(new DoublePrngDistribution(new GammaDistributedRandom(uniformRandom, 2, 2))); // exp(x) = 1, var(x) = 8
      scalingVarsTemplate.AddArguments(variables);
      var scaledVars = Instantiate(scalingVarsTemplate, uniformRandom, numInstances, "scaledVar");

      var sumOfScaledVarsTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "+" };
      sumOfScaledVarsTemplate.AddArguments(scaledVars);
      var sumOfScaledVars = Instantiate(sumOfScaledVarsTemplate, uniformRandom, numInstances, "sumOfScaledVars");

      var prodTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "*" };
      prodTemplate.AddArguments(variables);

      var logTermsTemplate = LogOfScaledExpression(uniformRandom, sumOfScaledVars,
      minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 2)),
      valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));
      var logTerms = Instantiate(logTermsTemplate, uniformRandom, numInstances, "log");

      var expTemplate = ExpOfScaledExpression(uniformRandom, Instantiate(prodTemplate, uniformRandom, numInstances, "prodOfVars"),
                           minValue: new PointDistribution<double>(-2.0),
                           valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 4, 6)));
      var expTerms = Instantiate(expTemplate, uniformRandom, numInstances, "exp");

      var fracTemplate = new BinaryOperatorTemplate(Division) { Label = "/" };
      fracTemplate.AddLeftArgument(Expression.Constant("const", 1.0), variables.Length);
      fracTemplate.AddLeftArguments(variables);
      fracTemplate.AddRightArguments(sumOfScaledVars);
      var fracTerms = Enumerable.Range(1, numInstances).Select(i => fracTemplate.Instantiate("frac" + i, uniformRandom, false));

      var prodOfFactorsTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(uniformRandom, 1, 4)) { Label = "*" };
      prodOfFactorsTemplate.AddArguments(variables, variables.Select(_ => 1.0));
      if (useLog) prodOfFactorsTemplate.AddArguments(logTerms, logTerms.Select(_ => .3));
      if (useExp) prodOfFactorsTemplate.AddArguments(expTerms, expTerms.Select(_ => .3));
      if (useFrac) prodOfFactorsTemplate.AddArguments(fracTerms, fracTerms.Select(_ => .3));
      var prodFactors = Instantiate(prodOfFactorsTemplate, uniformRandom, numInstances, "prod");

      var scaledTermsTemplate =
        new ScalingTemplate(new DoublePrngDistribution(new GammaDistributedRandom(uniformRandom, 2, 2))); // exp(x) = 1, var(x) = 8
      scaledTermsTemplate.AddArguments(variables, variables.Select(_ => 1.0));
      if (useLog) scaledTermsTemplate.AddArguments(logTerms, logTerms.Select(_ => 1.0));
      if (useExp) scaledTermsTemplate.AddArguments(expTerms, expTerms.Select(_ => 1.0));
      if (useFrac) scaledTermsTemplate.AddArguments(fracTerms, fracTerms.Select(_ => 1.0));
      scaledTermsTemplate.AddArguments(prodFactors, prodFactors.Select(_ => 4.0));

      var scaledTerms = Instantiate(scaledTermsTemplate, uniformRandom, 100, "scaledTerm");

      var sumTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 5, 25)) { Label = "+" };
      sumTemplate.AddArguments(scaledTerms);

      return sumTemplate.Instantiate("sum", uniformRandom, false);
    }

    public static Expression NonlinearExpression(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp, bool useFrac) {
      return NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, useFrac)
        .Instantiate("nonlinearexpr", uniformRandom, sampleWithRepetition: false);
    }

    public static ExpressionTemplate NonlinearExpressionTemplate(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp, bool useFrac) {
      var scalingTemplate = ScaledExpression(uniformRandom, variables, varianceDistribution: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));
      var scaledVars = Instantiate(scalingTemplate, uniformRandom, variables.Length, "scaledVar");

      var sumTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "+" };
      sumTemplate.AddArguments(scaledVars);
      var prodTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "*" };
      prodTemplate.AddArguments(variables);

      var logTemplate = LogOfScaledExpression(uniformRandom, Instantiate(sumTemplate, uniformRandom, scaledVars.Count(), "sumOfScaledVars"),
        minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 2)),
        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));

      var expTemplate = ExpOfScaledExpression(uniformRandom, Instantiate(prodTemplate, uniformRandom, variables.Length, "prodOfVars"),
        minValue: new PointDistribution<double>(-3.0),
        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 4, 6)));

      var variableSumTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 4)) { Label = "+" };
      variableSumTemplate.AddArguments(variables);
      var variableSums = Instantiate(variableSumTemplate, uniformRandom, variables.Length * 2, "varsum");

      var scaledVariableSumTemplate =
        new RangeTemplate(minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 1)),
          valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 5))) { Label = "*" };
      scaledVariableSumTemplate.AddArguments(variableSums);
      var scaledVariableSums = Instantiate(scaledVariableSumTemplate, uniformRandom, variables.Length * 2,
        "scaledvarsum");

      var fracTemplate = new BinaryOperatorTemplate(Division) { Label = "/" };
      fracTemplate.AddLeftArguments(variables);
      fracTemplate.AddRightArguments(scaledVariableSums);

      var scaledExprTemplate = new ScalingTemplate(new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10))) { Label = "*" };
      if (useLog) scaledExprTemplate.AddArguments(Instantiate(logTemplate, uniformRandom, scaledVars.Count(), "log"));
      if (useExp) scaledExprTemplate.AddArguments(Instantiate(expTemplate, uniformRandom, variables.Length, "exp"));
      if (useFrac) scaledExprTemplate.AddArguments(Enumerable.Range(0, 20).Select(i => fracTemplate.Instantiate("frac" + i, uniformRandom, false)));

      var mainTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 3, 5));
      mainTemplate.AddArguments(scaledVars);
      if (useLog || useExp) {
        mainTemplate.AddArguments(Instantiate(scaledExprTemplate, uniformRandom, 20, "scaledExpr"));
      }
      mainTemplate.Label = "+";

      return mainTemplate;
    }

    public static Expression Polynomial(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp) {
      const int count = 10; // how many instances of each template should be produce?
      int i = 1;
      // the main template
      var template = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 2, count)) { Label = "+" };
      template.AddArguments(variables);

      var sumTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 1, variables.Length)) { Label = "+" };
      sumTemplate.AddArguments(variables);

      var productTemplate = new RandomArityTemplate(Product, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 1, variables.Length)) { Label = "*" };
      productTemplate.AddArguments(variables);

      var inverseTemplate = new FixedArityTemplate(Division, 1) { Label = "/" };
      inverseTemplate.AddArguments(variables);
      inverseTemplate.AddArguments(Enumerable.Range(1, count).Select(x => sumTemplate.Instantiate(string.Format("sum{0}", i++), uniformRandom)));
      inverseTemplate.AddArguments(Enumerable.Range(1, count).Select(x => productTemplate.Instantiate(string.Format("prod{0}", i++), uniformRandom)));

      if (useLog) {
        var logTemplate = new FixedArityTemplate(Log, 1) { Label = "log" };
        logTemplate.AddArguments(variables);
        logTemplate.AddArguments(Enumerable.Range(1, count).Select(x => sumTemplate.Instantiate(string.Format("sum{0}", i++), uniformRandom)));
        template.AddArguments(Enumerable.Range(1, count).Select(x => logTemplate.Instantiate(string.Format("log{0}", i++), uniformRandom)));
        inverseTemplate.AddArguments(Enumerable.Range(1, count).Select(x => logTemplate.Instantiate(string.Format("log{0}", i++), uniformRandom)));
      }

      if (useExp) {
        var expTemplate = new FixedArityTemplate(Exp, 1) { Label = "exp" };
        expTemplate.AddArguments(variables);
        expTemplate.AddArguments(Enumerable.Range(1, count).Select(x => productTemplate.Instantiate(string.Format("prod{0}", i++), uniformRandom)));
        template.AddArguments(Enumerable.Range(1, count).Select(x => expTemplate.Instantiate(string.Format("exp{0}", i++), uniformRandom)));
        inverseTemplate.AddArguments(Enumerable.Range(1, count).Select(x => expTemplate.Instantiate(string.Format("exp{0}", i++), uniformRandom)));
      }

      template.AddArguments(Enumerable.Range(1, count).Select(x => inverseTemplate.Instantiate(string.Format("inv{0}", i++), uniformRandom)));
      return template.Instantiate("polynomial", uniformRandom);
    }

    // variance random must have support only positive numbers
    private static ExpressionTemplate ScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments, IDistribution<double> varianceDistribution) {
      var scalingTemplate = new ScalingTemplate(scaledVariance: varianceDistribution);
      scalingTemplate.AddArguments(arguments);
      scalingTemplate.Label = "*";
      return scalingTemplate;
    }

    /// template scales and translates the argument expression first to guarantee positive values
    private static ExpressionTemplate LogOfScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments,
      IDistribution<double> minValue = null, IDistribution<double> valueRange = null) {
      var limitToRangeTemplate = new RangeTemplate(minValue, valueRange);
      limitToRangeTemplate.AddArguments(arguments);

      var logTemplate = new FixedArityTemplate(Log, 1) { Label = "log" };
      logTemplate.AddArguments(Enumerable.Range(1, arguments.Count()).Select(i => limitToRangeTemplate.Instantiate(string.Format("log{0}", i), uniformRandom, false)));
      return logTemplate;
    }

    /// template scales the argument expression first to guarantee reasonable values
    private static ExpressionTemplate ExpOfScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments,
      IDistribution<double> minValue = null,
      IDistribution<double> valueRange = null) {
      var limitToRangeTemplate = new RangeTemplate(minValue, valueRange);
      limitToRangeTemplate.AddArguments(arguments);

      var expTemplate = new FixedArityTemplate(Exp, 1) { Label = "exp" };
      expTemplate.AddArguments(Enumerable.Range(1, arguments.Count()).Select(i => limitToRangeTemplate.Instantiate(string.Format("exp{0}", i), uniformRandom, false)));
      return expTemplate;
    }

    public static IEnumerable<Expression> Instantiate(ExpressionTemplate template, IRandom random, int count, string name) {
      return Enumerable.Range(1, count).Select(i => template.Instantiate(name + i, random, false));
    }

    #region static functions
    public static double Sum(IEnumerable<double> args) {
      return args.Sum();
    }

    public static double Product(IEnumerable<double> args) {
      return args.Aggregate((x, y) => x * y);
    }

    public static double Division(IEnumerable<double> args) {
      if (args.Count() == 1)
        return 1 / args.First();

      return args.Aggregate((x, y) => x / y);
    }

    public static double Subtraction(IEnumerable<double> args) {
      if (args.Count() == 1)
        return -args.First();

      return args.Aggregate((x, y) => x - y);
    }

    public static double Exp(IEnumerable<double> args) {
      return Math.Exp(args.Single());
    }

    public static double Log(IEnumerable<double> args) {
      return Math.Log(args.Single());
    }

    public static double Square(IEnumerable<double> args) {
      var v = args.Single();
      return v * v;
    }
    #endregion
  }
}