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

#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.Random;

namespace HeuristicLab.ExpressionGenerator {
  public abstract class ExpressionTemplate {
    private List<Tuple<Expression, double>> arguments;
    private readonly Func<IEnumerable<double>, double> transform;

    protected Expression Instantiate(string label, IRandom random, int n, bool sampleWithRepetition = false) {
      var weights = arguments.Select(x => x.Item2);
      var args = sampleWithRepetition
       ? arguments.SampleProportional(random, n, weights).Select(x => x.Item1)
       : arguments.SampleProportionalWithoutRepetition(random, n, weights).Select(x => x.Item1);
      return Expression.Function(label, transform, 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 priority = 1d) {
      arguments = arguments ?? new List<Tuple<Expression, double>>();
      arguments.Add(Tuple.Create(expression, priority));
    }

    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> priorities) {
      arguments = arguments ?? new List<Tuple<Expression, double>>();
      arguments.AddRange(expressions.Zip(priorities, Tuple.Create));
    }
  }

  public class RandomArityTemplate : ExpressionTemplate {
    private readonly IRandom arityDistribution;

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

    public override Expression Instantiate(string name, IRandom random, bool sampleWithRepetition = false) {
      var arity = (int)Math.Round(arityDistribution.NextDouble());
      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);
    }
  }
}