source: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableBase.cs @ 14826

Last change on this file since 14826 was 14826, checked in by gkronber, 6 months ago

#2650: merged the factors branch into trunk

File size: 6.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 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 HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
27namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
28  [StorableClass]
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(bool deserializing)
155      : base(deserializing) {
156      variableNames = new List<string>();
157      allVariableNames = new List<string>();
158    }
159    protected VariableBase(VariableBase original, Cloner cloner)
160      : base(original, cloner) {
161      weightMu = original.weightMu;
162      weightSigma = original.weightSigma;
163      variableNames = new List<string>(original.variableNames);
164      allVariableNames = new List<string>(original.allVariableNames);
165      weightManipulatorMu = original.weightManipulatorMu;
166      weightManipulatorSigma = original.weightManipulatorSigma;
167      multiplicativeWeightManipulatorSigma = original.multiplicativeWeightManipulatorSigma;
168      variableChangeProbability = original.variableChangeProbability;
169      }
170    protected VariableBase(string name, string description)
171      : base(name, description) {
172      weightMu = 1.0;
173      weightSigma = 1.0;
174      weightManipulatorMu = 0.0;
175      weightManipulatorSigma = 0.05;
176      multiplicativeWeightManipulatorSigma = 0.03;
177      variableChangeProbability = 0.2;
178      variableNames = new List<string>();
179      allVariableNames = new List<string>();
180    }
181  }
182}
Note: See TracBrowser for help on using the repository browser.