Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ModelAnalyzerExporter.cs @ 2285

Last change on this file since 2285 was 2235, checked in by gkronber, 15 years ago

Fixed #323 (The default representation of FunctionTreeView should show coefficients and time-offsets of variables and values of constants).

File size: 8.3 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2008 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 HeuristicLab.GP.Interfaces;
23using System;
24
25namespace HeuristicLab.GP.StructureIdentification {
26  public class ModelAnalyzerExporter : IFunctionTreeSerializer {
27    #region IFunctionTreeExporter Members
28
29    public string Name {
30      get {
31        return "HL2 ModelAnalyzer Exporter";
32      }
33    }
34
35    public bool TryExport(IFunctionTree tree, out string exported) {
36      try {
37        exported = Export(tree);
38        return true;
39      } catch(UnknownFunctionException) {
40        exported = "";
41        return false;
42      }
43    }
44
45    public string Export(IFunctionTree tree) {
46      string result = ExportFunction(tree.Function, tree);
47      if(tree.SubTrees.Count>0)
48        result += "(\n";
49      foreach(IFunctionTree subTree in tree.SubTrees) {
50        result += Export(subTree);
51        result += ";\n";
52      }
53      result = result.TrimEnd(';', '\n');
54      if(tree.SubTrees.Count > 0) result += ")";
55      return result;
56    }
57
58    public IFunctionTree Import(string tree) {
59      throw new UnknownFunctionException(tree);
60    }
61
62    public bool TryImport(string tree, out IFunctionTree importedTree) {
63      try {
64        importedTree = Import(tree);
65        return true;
66      }
67      catch (UnknownFunctionException) {
68        importedTree = null;
69        return false;
70      }
71    }
72
73    #endregion
74
75    private static string ExportFunction(IFunction function, IFunctionTree tree) {
76      // this is smelly, if there is a cleaner way to have a 'dynamic' visitor
77      // please let me know! (gkronber 14.10.2008)
78      if(function is Addition) return ((Addition)function).ExportToHL2(tree);
79      if(function is And) return ((And)function).ExportToHL2(tree);
80      if(function is Average) return ((Average)function).ExportToHL2(tree);
81      if(function is Constant) return ((Constant)function).ExportToHL2(tree);
82      if(function is Cosinus) return ((Cosinus)function).ExportToHL2(tree);
83      if(function is Differential) return ((Differential)function).ExportToHL2(tree);
84      if(function is Division) return ((Division)function).ExportToHL2(tree);
85      if(function is Equal) return ((Equal)function).ExportToHL2(tree);
86      if(function is Exponential) return ((Exponential)function).ExportToHL2(tree);
87      if(function is GreaterThan) return ((GreaterThan)function).ExportToHL2(tree);
88      if(function is IfThenElse) return ((IfThenElse)function).ExportToHL2(tree);
89      if(function is LessThan) return ((LessThan)function).ExportToHL2(tree);
90      if(function is Logarithm) return ((Logarithm)function).ExportToHL2(tree);
91      if(function is Multiplication) return ((Multiplication)function).ExportToHL2(tree);
92      if(function is Not) return ((Not)function).ExportToHL2(tree);
93      if(function is Or) return ((Or)function).ExportToHL2(tree);
94      if(function is Power) return ((Power)function).ExportToHL2(tree);
95      if(function is Signum) return ((Signum)function).ExportToHL2(tree);
96      if(function is Sinus) return ((Sinus)function).ExportToHL2(tree);
97      if(function is Sqrt) return ((Sqrt)function).ExportToHL2(tree);
98      if(function is Subtraction) return ((Subtraction)function).ExportToHL2(tree);
99      if(function is Tangens) return ((Tangens)function).ExportToHL2(tree);
100      if(function is Variable) return ((Variable)function).ExportToHL2(tree);
101      if(function is Xor) return ((Xor)function).ExportToHL2(tree);
102      throw new UnknownFunctionException(function.Name);
103    }
104
105    public static string GetName(IFunctionTree tree) {
106      string name = "";
107      try {
108        name = ExportFunction(tree.Function, tree);
109      } catch(UnknownFunctionException) {
110        name = "N/A";
111      }
112      return name;
113    }
114  }
115
116  internal static class HL2ExporterExtensions {
117    private static string GetHL2FunctionName(string name) {
118      return "[F]" + name ;
119    }
120
121    public static string ExportToHL2(this Addition addition, IFunctionTree tree) {
122      return GetHL2FunctionName("Addition[0]");
123    }
124
125    public static string ExportToHL2(this Constant constant, IFunctionTree tree) {
126      double value = ((ConstantFunctionTree)tree).Value;
127      return "[T]Constant(" + value.ToString("r") + ";0;0)";
128    }
129
130    public static string ExportToHL2(this Cosinus cosinus, IFunctionTree tree) {
131      return GetHL2FunctionName("Trigonometrics[1]");
132    }
133
134    public static string ExportToHL2(this Differential differential, IFunctionTree tree) {
135      var varTree = (VariableFunctionTree)tree;
136      return "[T]Differential(" + varTree.Weight.ToString("r") + ";" + varTree.VariableName + ";" + -varTree.SampleOffset + ")";
137    }
138
139    public static string ExportToHL2(this Division division, IFunctionTree tree) {
140      return GetHL2FunctionName("Division[0]");
141    }
142
143    public static string ExportToHL2(this Exponential exponential, IFunctionTree tree) {
144      return GetHL2FunctionName("Exponential[0]");
145    }
146
147    public static string ExportToHL2(this Logarithm logarithm, IFunctionTree tree) {
148      return GetHL2FunctionName("Logarithm[0]");
149    }
150
151    public static string ExportToHL2(this Multiplication multiplication, IFunctionTree tree) {
152      return GetHL2FunctionName("Multiplication[0]");
153    }
154
155    public static string ExportToHL2(this Power power, IFunctionTree tree) {
156      return GetHL2FunctionName("Power[0]");
157    }
158
159    public static string ExportToHL2(this Signum signum, IFunctionTree tree) {
160      return GetHL2FunctionName("Signum[0]");
161    }
162
163    public static string ExportToHL2(this Sinus sinus, IFunctionTree tree) {
164      return GetHL2FunctionName("Trigonometrics[0]");
165    }
166
167    public static string ExportToHL2(this Sqrt sqrt, IFunctionTree tree) {
168      return GetHL2FunctionName("Sqrt[0]");
169    }
170
171    public static string ExportToHL2(this Subtraction substraction, IFunctionTree tree) {
172      return GetHL2FunctionName("Subtraction[0]");
173    }
174
175    public static string ExportToHL2(this Tangens tangens, IFunctionTree tree) {
176      return GetHL2FunctionName("Trigonometrics[2]");
177    }
178
179    public static string ExportToHL2(this Variable variable, IFunctionTree tree) {
180      var varTree = (VariableFunctionTree)tree;
181      return "[T]Variable(" + varTree.Weight.ToString("r") + ";" + varTree.VariableName + ";" + -varTree.SampleOffset + ")";
182    }
183
184    public static string ExportToHL2(this And and, IFunctionTree tree) {
185      return GetHL2FunctionName("Logical[0]");
186    }
187
188    public static string ExportToHL2(this Average average, IFunctionTree tree) {
189      return GetHL2FunctionName("Average[0]");
190    }
191
192    public static string ExportToHL2(this IfThenElse ifThenElse, IFunctionTree tree) {
193      return GetHL2FunctionName("Conditional[0]");
194    }
195
196    public static string ExportToHL2(this Not not, IFunctionTree tree) {
197      return GetHL2FunctionName("Logical[2]");
198    }
199
200    public static string ExportToHL2(this Or or, IFunctionTree tree) {
201      return GetHL2FunctionName("Logical[1]");
202    }
203
204    public static string ExportToHL2(this Xor xor, IFunctionTree tree) {
205      return GetHL2FunctionName("Logical[3]");
206    }
207
208    public static string ExportToHL2(this Equal equal, IFunctionTree tree) {
209      return GetHL2FunctionName("Boolean[2]");
210    }
211
212    public static string ExportToHL2(this LessThan lessThan, IFunctionTree tree) {
213      return GetHL2FunctionName("Boolean[0]");
214    }
215
216    public static string ExportToHL2(this GreaterThan greaterThan, IFunctionTree tree) {
217      return GetHL2FunctionName("Boolean[4]");
218    }
219  }
220}
Note: See TracBrowser for help on using the repository browser.