source: branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAParameters.cs @ 9129

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2013 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 HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System.Collections.Generic;
using System.ComponentModel;

namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
  [Item("CMAParameters", "CMA-ES controls many strategy parameters that guide the search and which are combined in this class.")]
  [StorableClass]
  public sealed class CMAParameters : Item, INotifyPropertyChanged {

    [Storable]
    private DoubleValue axisRatio;
    public DoubleValue AxisRatio {
      get { return axisRatio; }
      set {
        if (axisRatio == value) return;
        axisRatio = value;
        OnPropertyChanged("AxisRatio");
      }
    }

    [Storable]
    private DoubleValue sigma;
    public DoubleValue Sigma {
      get { return sigma; }
      set {
        if (sigma == value) return;
        sigma = value;
        OnPropertyChanged("Sigma");
      }
    }

    [Storable]
    private DoubleMatrix sigmaBounds;
    public DoubleMatrix SigmaBounds {
      get { return sigmaBounds; }
      set {
        if (sigmaBounds == value) return;
        sigmaBounds = value;
        OnPropertyChanged("SigmaBounds");
      }
    }

    [Storable]
    private IntValue mu;
    public IntValue Mu {
      get { return mu; }
      set {
        if (mu == value) return;
        mu = value;
        OnPropertyChanged("Mu");
      }
    }

    [Storable]
    private DoubleArray weights;
    public DoubleArray Weights {
      get { return weights; }
      set {
        if (weights == value) return;
        weights = value;
        OnPropertyChanged("Weights");
      }
    }

    [Storable]
    private DoubleValue muEff;
    public DoubleValue MuEff {
      get { return muEff; }
      set {
        if (muEff == value) return;
        muEff = value;
        OnPropertyChanged("MuEff");
      }
    }

    [Storable]
    private DoubleValue cc;
    public DoubleValue CC {
      get { return cc; }
      set {
        if (cc == value) return;
        cc = value;
        OnPropertyChanged("CC");
      }
    }

    [Storable]
    private DoubleValue cs;
    public DoubleValue CS {
      get { return cs; }
      set {
        if (cs == value) return;
        cs = value;
        OnPropertyChanged("CS");
      }
    }

    [Storable]
    private DoubleValue damps;
    public DoubleValue Damps {
      get { return damps; }
      set {
        if (damps == value) return;
        damps = value;
        OnPropertyChanged("Damps");
      }
    }

    [Storable]
    private DoubleValue muCov;
    public DoubleValue MuCov {
      get { return muCov; }
      set {
        if (muCov == value) return;
        muCov = value;
        OnPropertyChanged("MuCov");
      }
    }

    [Storable]
    private DoubleValue cCov;
    public DoubleValue CCov {
      get { return cCov; }
      set {
        if (cCov == value) return;
        cCov = value;
        OnPropertyChanged("CCov");
      }
    }

    [Storable]
    private DoubleValue cCovSep;
    public DoubleValue CCovSep {
      get { return cCovSep; }
      set {
        if (cCovSep == value) return;
        cCovSep = value;
        OnPropertyChanged("CCovSep");
      }
    }

    [Storable]
    private DoubleArray pc;
    public DoubleArray PC {
      get { return pc; }
      set {
        if (pc == value) return;
        pc = value;
        OnPropertyChanged("PC");
      }
    }

    [Storable]
    private DoubleArray ps;
    public DoubleArray PS {
      get { return ps; }
      set {
        if (ps == value) return;
        ps = value;
        OnPropertyChanged("PS");
      }
    }

    [Storable]
    private DoubleMatrix b;
    public DoubleMatrix B {
      get { return b; }
      set {
        if (b == value) return;
        b = value;
        OnPropertyChanged("B");
      }
    }

    [Storable]
    private DoubleArray d;
    public DoubleArray D {
      get { return d; }
      set {
        if (d == value) return;
        d = value;
        OnPropertyChanged("D");
      }
    }

    [Storable]
    private DoubleMatrix c;
    public DoubleMatrix C {
      get { return c; }
      set {
        if (c == value) return;
        c = value;
        OnPropertyChanged("C");
      }
    }

    [Storable]
    private DoubleArray bDz;
    public DoubleArray BDz {
      get { return bDz; }
      set {
        if (bDz == value) return;
        bDz = value;
        OnPropertyChanged("BDz");
      }
    }

    [Storable]
    private DoubleValue chiN;
    public DoubleValue ChiN {
      get { return chiN; }
      set {
        if (chiN == value) return;
        chiN = value;
        OnPropertyChanged("ChiN");
      }
    }

    [Storable]
    private IntValue initialIterations;
    public IntValue InitialIterations {
      get { return initialIterations; }
      set {
        if (initialIterations == value) return;
        initialIterations = value;
        OnPropertyChanged("InitialIterations");
      }
    }

    [Storable]
    private Queue<double> qualityHistory;
    public Queue<double> QualityHistory {
      get { return qualityHistory; }
      set { qualityHistory = value; }
    }

    [Storable]
    private int qualityHistorySize;
    public int QualityHistorySize {
      get { return qualityHistorySize; }
      set { qualityHistorySize = value; }
    }

    [StorableConstructor]
    private CMAParameters(bool deserializing) : base(deserializing) { }
    private CMAParameters(CMAParameters original, Cloner cloner)
      : base(original, cloner) {
      this.axisRatio = cloner.Clone(original.axisRatio);
      this.b = cloner.Clone(original.b);
      this.bDz = cloner.Clone(original.bDz);
      this.c = cloner.Clone(original.c);
      this.cCov = cloner.Clone(original.cCov);
      this.cCovSep = cloner.Clone(original.cCovSep);
      this.cc = cloner.Clone(original.cc);
      this.chiN = cloner.Clone(original.chiN);
      this.cs = cloner.Clone(original.cs);
      this.d = cloner.Clone(original.d);
      this.damps = cloner.Clone(original.damps);
      this.initialIterations = cloner.Clone(original.initialIterations);
      this.mu = cloner.Clone(original.mu);
      this.muCov = cloner.Clone(original.muCov);
      this.muEff = cloner.Clone(original.muEff);
      this.pc = cloner.Clone(original.pc);
      this.ps = cloner.Clone(original.ps);
      this.sigma = cloner.Clone(original.sigma);
      this.sigmaBounds = cloner.Clone(original.sigmaBounds);
      this.weights = cloner.Clone(original.weights);

      this.qualityHistory = new Queue<double>(original.qualityHistory);
      this.qualityHistorySize = original.qualityHistorySize;
    }
    public CMAParameters() { }

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

    public event PropertyChangedEventHandler PropertyChanged;
    private void OnPropertyChanged(string name) {
      var handler = PropertyChanged;
      if (handler != null) handler(this, new PropertyChangedEventArgs(name));
    }
  }
}