Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableBase.cs @ 17507

Last change on this file since 17507 was 17180, checked in by swagner, 5 years ago

#2875: Removed years in copyrights

File size: 6.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using HeuristicLab.Common;
25using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
26using HEAL.Attic;
27namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
28  [StorableType("F8A6AD96-28D9-4BEC-8392-8B7BA824B085")]
29  public abstract class VariableBase : Symbol, IVariableSymbol {
30    #region Properties
31    [Storable]
32    private double weightMu;
33    public double WeightMu {
34      get { return weightMu; }
35      set {
36        if (value != weightMu) {
37          weightMu = value;
38          OnChanged(EventArgs.Empty);
39        }
40      }
41    }
42    [Storable]
43    private double weightSigma;
44    public double WeightSigma {
45      get { return weightSigma; }
46      set {
47        if (weightSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
48        if (value != weightSigma) {
49          weightSigma = value;
50          OnChanged(EventArgs.Empty);
51        }
52      }
53    }
54    [Storable]
55    private double weightManipulatorMu;
56    public double WeightManipulatorMu {
57      get { return weightManipulatorMu; }
58      set {
59        if (value != weightManipulatorMu) {
60          weightManipulatorMu = value;
61          OnChanged(EventArgs.Empty);
62        }
63      }
64    }
65    [Storable]
66    private double weightManipulatorSigma;
67    public double WeightManipulatorSigma {
68      get { return weightManipulatorSigma; }
69      set {
70        if (weightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
71        if (value != weightManipulatorSigma) {
72          weightManipulatorSigma = value;
73          OnChanged(EventArgs.Empty);
74        }
75      }
76    }
77    [Storable(DefaultValue = 0.0)]
78    private double multiplicativeWeightManipulatorSigma;
79    public double MultiplicativeWeightManipulatorSigma {
80      get { return multiplicativeWeightManipulatorSigma; }
81      set {
82        if (multiplicativeWeightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
83        if (value != multiplicativeWeightManipulatorSigma) {
84          multiplicativeWeightManipulatorSigma = value;
85          OnChanged(EventArgs.Empty);
86        }
87      }
88    }
89
90    [Storable(DefaultValue = 1.0)]
91    private double variableChangeProbability;
92
93    public double VariableChangeProbability {
94      get { return variableChangeProbability; }
95      set {
96        if (value < 0 || value > 1.0) throw new ArgumentException("Variable change probability must lie in the interval [0..1]");
97        variableChangeProbability = value;
98      }
99    }
100
101    private List<string> variableNames;
102    [Storable]
103    public IEnumerable<string> VariableNames {
104      get { return variableNames; }
105      set {
106        if (value == null) throw new ArgumentNullException();
107        variableNames.Clear();
108        variableNames.AddRange(value);
109        OnChanged(EventArgs.Empty);
110      }
111    }
112
113    private List<string> allVariableNames;
114    [Storable]
115    public IEnumerable<string> AllVariableNames {
116      get { return allVariableNames; }
117      set {
118        if (value == null) throw new ArgumentNullException();
119        allVariableNames.Clear();
120        allVariableNames.AddRange(value);
121      }
122    }
123
124    public override bool Enabled {
125      get {
126        if (variableNames.Count == 0) return false;
127        return base.Enabled;
128      }
129      set {
130        if (variableNames.Count == 0) base.Enabled = false;
131        else base.Enabled = value;
132      }
133    }
134
135    private const int minimumArity = 0;
136    private const int maximumArity = 0;
137
138    public override int MinimumArity {
139      get { return minimumArity; }
140    }
141    public override int MaximumArity {
142      get { return maximumArity; }
143    }
144    #endregion
145
146    [StorableHook(HookType.AfterDeserialization)]
147    private void AfterDeserialization() {
148      if (allVariableNames == null || (allVariableNames.Count == 0 && variableNames.Count > 0)) {
149        allVariableNames = variableNames;
150      }
151    }
152
153    [StorableConstructor]
154    protected VariableBase(StorableConstructorFlag _) : base(_) {
155      variableNames = new List<string>();
156      allVariableNames = new List<string>();
157    }
158    protected VariableBase(VariableBase original, Cloner cloner)
159      : base(original, cloner) {
160      weightMu = original.weightMu;
161      weightSigma = original.weightSigma;
162      variableNames = new List<string>(original.variableNames);
163      allVariableNames = new List<string>(original.allVariableNames);
164      weightManipulatorMu = original.weightManipulatorMu;
165      weightManipulatorSigma = original.weightManipulatorSigma;
166      multiplicativeWeightManipulatorSigma = original.multiplicativeWeightManipulatorSigma;
167      variableChangeProbability = original.variableChangeProbability;
168    }
169    protected VariableBase(string name, string description)
170      : base(name, description) {
171      weightMu = 1.0;
172      weightSigma = 1.0;
173      weightManipulatorMu = 0.0;
174      weightManipulatorSigma = 0.05;
175      multiplicativeWeightManipulatorSigma = 0.03;
176      variableChangeProbability = 0.2;
177      variableNames = new List<string>();
178      allVariableNames = new List<string>();
179    }
180  }
181}
Note: See TracBrowser for help on using the repository browser.