source: branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/Expression.cs @ 14409

#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.Globalization;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using HeuristicLab.Random;

namespace HeuristicLab.ExpressionGenerator {
  public class Expression : IExpression {
    public string Label { get; set; }

    public ExpressionType Type { get; }

    private readonly List<Expression> arguments;
    public IEnumerable<Expression> Arguments {
      get { return arguments ?? Enumerable.Empty<Expression>(); }
    }

    public IRandom Distribution { get; }

    public Func<IEnumerable<double>, double> Transform { get; }

    public double Value { get; }

    public Expression(string label, double value) {
      Type = ExpressionType.Constant;
      Value = value;
      Label = label;
    }

    public Expression(string label, IRandom distribution) {
      Type = ExpressionType.RandomVariable;
      Distribution = distribution;
      Label = label;
    }

    public Expression(string label, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
      Type = ExpressionType.Function;
      Transform = transform;
      this.arguments = this.arguments ?? new List<Expression>();
      this.arguments.AddRange(arguments);
      Label = label;
    }

    public static Expression Constant(string label, double value) {
      return new Expression(label, value);
    }

    public static Expression RandomVariable(string label, IRandom distribution) {
      return new Expression(label, distribution);
    }

    public static Expression Function(string label, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
      return new Expression(label, transform, arguments);
    }

    public override string ToString() {
      var sb = new StringBuilder();

      switch (Type) {
        case ExpressionType.Constant:
          sb.Append(Value.ToString("0.000", CultureInfo.CurrentCulture));
          break;
        case ExpressionType.RandomVariable:
          sb.Append(string.Format("{0} ~ {1}", Label, GetStringDescription(Distribution)));
          break;
        case ExpressionType.Function:
          sb.Append(string.Format("{0} (", Label));
          if (arguments != null) {
            for (int i = 0; i < arguments.Count - 1; ++i)
              sb.Append(string.Format("{0}, ", arguments[i]));
            sb.Append(string.Format("{0})", arguments.Last()));
          }
          break;
      }

      return sb.ToString();
    }

    private static string GetStringDescription(IRandom random) {
      var normal = random as NormalDistributedRandom;
      if (normal != null)
        return string.Format("N({0}, {1})", normal.Mu, normal.Sigma);

      var uniform = random as UniformDistributedRandom;
      if (uniform != null)
        return string.Format("U({0}, {1})", uniform.Min, uniform.Max);

      var gamma = random as GammaDistributedRandom;
      if (gamma != null)
        return string.Format("G({0}, {1})", gamma.Shape, gamma.Rate);

      return random.ToString();
    }
  }
}