Free cookie consent management tool by TermsFeed Policy Generator

source: branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs @ 18112

Last change on this file since 18112 was 18112, checked in by chaider, 2 years ago

#3140

  • Adding INumericSymbol and INumericTreeNode
  • Using the new interfaces inside of interpreters and formatters
  • Renaming Num to Number, RealConstant to Constant
  • More classes refactored
File size: 11.5 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 System.Diagnostics;
25using System.Linq;
26using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
27
28namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
29  public class SymbolicExpressionImporter {
30    private const string VARSTART = "VAR";
31    private const string LAGGEDVARSTART = "LAGVARIABLE";
32    private const string INTEGRALSTART = "INTEG";
33    private const string DEFUNSTART = "DEFUN";
34    private const string ARGSTART = "ARG";
35    private const string INVOKESTART = "CALL";
36    private const string TIMELAGSTART = "LAG";
37    private Dictionary<string, Symbol> knownSymbols = new Dictionary<string, Symbol>()
38      {
39        {"+", new Addition()},
40        {"/", new Division()},
41        {"*", new Multiplication()},
42        {"-", new Subtraction()},
43        {"ABS", new Absolute() },
44        {"EXP", new Exponential()},
45        {"LOG", new Logarithm()},
46        {"POW", new Power()},
47        {"ROOT", new Root()},
48        {"SQR", new Square()},
49        {"SQRT", new SquareRoot()},
50        {"CUBE", new Cube()},
51        {"CUBEROOT", new CubeRoot()},
52        {"SIN",new Sine()},
53        {"COS", new Cosine()},
54        {"TAN", new Tangent()},
55        {"TANH", new HyperbolicTangent ()},
56        {"AIRYA", new AiryA()},
57        {"AIRYB", new AiryB()},
58        {"BESSEL", new Bessel()},
59        {"COSINT", new CosineIntegral()},
60        {"SININT", new SineIntegral()},
61        {"HYPCOSINT", new HyperbolicCosineIntegral()},
62        {"HYPSININT", new HyperbolicSineIntegral()},
63        {"FRESNELSININT", new FresnelSineIntegral()},
64        {"FRESNELCOSINT", new FresnelCosineIntegral()},
65        {"NORM", new Norm()},
66        {"ERF", new Erf()},
67        {"GAMMA", new Gamma()},
68        {"PSI", new Psi()},
69        {"DAWSON", new Dawson()},
70        {"EXPINT", new ExponentialIntegralEi()},
71        {"AQ", new AnalyticQuotient() },
72        {"MEAN", new Average()},
73        {"IF", new IfThenElse()},
74        {">", new GreaterThan()},
75        {"<", new LessThan()},
76        {"AND", new And()},
77        {"OR", new Or()},
78        {"NOT", new Not()},
79        {"XOR", new Xor()},
80        {"DIFF", new Derivative()},
81        {"PROG", new ProgramRootSymbol()},
82        {"MAIN", new StartSymbol()},
83        {"FACTOR", new FactorVariable() },
84        {"BINFACTOR", new BinaryFactorVariable()}
85      };
86
87    Number number = new Number();
88    Constant constant = new Constant();
89    Variable variable = new Variable();
90    LaggedVariable laggedVariable = new LaggedVariable();
91    Defun defun = new Defun();
92    TimeLag timeLag = new TimeLag();
93    Integral integral = new Integral();
94    FactorVariable factorVar = new FactorVariable();
95    BinaryFactorVariable binFactorVar = new BinaryFactorVariable();
96
97    ProgramRootSymbol programRootSymbol = new ProgramRootSymbol();
98    StartSymbol startSymbol = new StartSymbol();
99
100    public ISymbolicExpressionTree Import(string str) {
101      str = str.Replace("(", " ( ").Replace(")", " ) ");
102      ISymbolicExpressionTreeNode root = programRootSymbol.CreateTreeNode();
103      ISymbolicExpressionTreeNode start = startSymbol.CreateTreeNode();
104      ISymbolicExpressionTreeNode mainBranch = ParseSexp(new Queue<Token>(GetTokenStream(str)));
105      if (mainBranch.Symbol is ProgramRootSymbol) {
106        // when a root symbol was parsed => use main branch as root
107        root = mainBranch;
108      } else {
109        // only a main branch was given => insert the main branch into the default tree template
110        root.AddSubtree(start);
111        start.AddSubtree(mainBranch);
112      }
113      return new SymbolicExpressionTree(root);
114    }
115
116    private IEnumerable<Token> GetTokenStream(string str) {
117      return
118             from strToken in str.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries).AsEnumerable()
119             let t = Token.Parse(strToken)
120             where t != null
121             select t;
122    }
123
124    private ISymbolicExpressionTreeNode ParseSexp(Queue<Token> tokens) {
125      if (tokens.Peek().Symbol == TokenSymbol.LPAR) {
126        ISymbolicExpressionTreeNode tree;
127        Expect(Token.LPAR, tokens);
128        if (tokens.Peek().StringValue.StartsWith(VARSTART)) {
129          tree = ParseVariable(tokens);
130        } else if (tokens.Peek().StringValue.StartsWith(LAGGEDVARSTART)) {
131          tree = ParseLaggedVariable(tokens);
132        } else if (tokens.Peek().StringValue.StartsWith(TIMELAGSTART)) {
133          tree = ParseTimeLag(tokens);
134          tree.AddSubtree(ParseSexp(tokens));
135        } else if (tokens.Peek().StringValue.StartsWith(INTEGRALSTART)) {
136          tree = ParseIntegral(tokens);
137          tree.AddSubtree(ParseSexp(tokens));
138        } else if (tokens.Peek().StringValue.StartsWith(DEFUNSTART)) {
139          tree = ParseDefun(tokens);
140          while (!tokens.Peek().Equals(Token.RPAR)) {
141            tree.AddSubtree(ParseSexp(tokens));
142          }
143        } else if (tokens.Peek().StringValue.StartsWith(ARGSTART)) {
144          tree = ParseArgument(tokens);
145        } else if (tokens.Peek().StringValue.StartsWith(INVOKESTART)) {
146          tree = ParseInvoke(tokens);
147          while (!tokens.Peek().Equals(Token.RPAR)) {
148            tree.AddSubtree(ParseSexp(tokens));
149          }
150        } else if (tokens.Peek().StringValue.StartsWith("FACTOR")) {
151          tree = ParseFactor(tokens);
152        } else if (tokens.Peek().StringValue.StartsWith("BINFACTOR")) {
153          tree = ParseBinaryFactor(tokens);
154        } else {
155          Token curToken = tokens.Dequeue();
156          tree = CreateTree(curToken);
157          while (!tokens.Peek().Equals(Token.RPAR)) {
158            tree.AddSubtree(ParseSexp(tokens));
159          }
160        }
161        Expect(Token.RPAR, tokens);
162        return tree;
163      } else if (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
164        var t = (INumericTreeNode)number.CreateTreeNode();
165        t.Value = tokens.Dequeue().DoubleValue;
166        return t;
167      } else throw new FormatException("Expected function or constant symbol");
168    }
169
170    private ISymbolicExpressionTreeNode ParseInvoke(Queue<Token> tokens) {
171      Token invokeTok = tokens.Dequeue();
172      Debug.Assert(invokeTok.StringValue == "CALL");
173      InvokeFunction invokeSym = new InvokeFunction(tokens.Dequeue().StringValue);
174      ISymbolicExpressionTreeNode invokeNode = invokeSym.CreateTreeNode();
175      return invokeNode;
176    }
177
178    private ISymbolicExpressionTreeNode ParseArgument(Queue<Token> tokens) {
179      Token argTok = tokens.Dequeue();
180      Debug.Assert(argTok.StringValue == "ARG");
181      Argument argument = new Argument((int)tokens.Dequeue().DoubleValue);
182      ISymbolicExpressionTreeNode argNode = argument.CreateTreeNode();
183      return argNode;
184    }
185
186    private ISymbolicExpressionTreeNode ParseDefun(Queue<Token> tokens) {
187      Token defTok = tokens.Dequeue();
188      Debug.Assert(defTok.StringValue == "DEFUN");
189      DefunTreeNode t = (DefunTreeNode)defun.CreateTreeNode();
190      t.FunctionName = tokens.Dequeue().StringValue;
191      return t;
192    }
193
194    private ISymbolicExpressionTreeNode ParseTimeLag(Queue<Token> tokens) {
195      Token varTok = tokens.Dequeue();
196      Debug.Assert(varTok.StringValue == "LAG");
197      LaggedTreeNode t = (LaggedTreeNode)timeLag.CreateTreeNode();
198      t.Lag = (int)tokens.Dequeue().DoubleValue;
199      return t;
200    }
201
202    private ISymbolicExpressionTreeNode ParseIntegral(Queue<Token> tokens) {
203      Token varTok = tokens.Dequeue();
204      Debug.Assert(varTok.StringValue == "INTEGRAL");
205      LaggedTreeNode t = (LaggedTreeNode)integral.CreateTreeNode();
206      t.Lag = (int)tokens.Dequeue().DoubleValue;
207      return t;
208    }
209
210    private ISymbolicExpressionTreeNode ParseVariable(Queue<Token> tokens) {
211      Token varTok = tokens.Dequeue();
212      Debug.Assert(varTok.StringValue == "VARIABLE");
213      VariableTreeNode t = (VariableTreeNode)variable.CreateTreeNode();
214      t.Weight = tokens.Dequeue().DoubleValue;
215      t.VariableName = tokens.Dequeue().StringValue;
216      return t;
217    }
218
219    private ISymbolicExpressionTreeNode ParseFactor(Queue<Token> tokens) {
220      Token tok = tokens.Dequeue();
221      Debug.Assert(tok.StringValue == "FACTOR");
222      FactorVariableTreeNode t = (FactorVariableTreeNode)(new FactorVariable()).CreateTreeNode(); // create a new symbol each time on purpose
223      var varNameTok = tokens.Dequeue();
224      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
225      t.VariableName = varNameTok.StringValue;
226
227      var weights = new List<double>();
228      while (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
229        weights.Add(tokens.Dequeue().DoubleValue);
230      }
231
232      t.Weights = weights.ToArray();
233
234      // create a set of (virtual) values to match the number of weights
235      t.Symbol.VariableNames = new string[] { t.VariableName };
236      t.Symbol.VariableValues = new[]
237      { new KeyValuePair<string, Dictionary<string,int>>(
238        t.VariableName,
239        weights.Select((_, i) => Tuple.Create(_,i)).ToDictionary(tup=>"X" + tup.Item2, tup=>tup.Item2)) };
240      return t;
241    }
242
243    private ISymbolicExpressionTreeNode ParseBinaryFactor(Queue<Token> tokens) {
244      Token tok = tokens.Dequeue();
245      Debug.Assert(tok.StringValue == "BINFACTOR");
246      var t = (BinaryFactorVariableTreeNode)binFactorVar.CreateTreeNode();
247      var varNameTok = tokens.Dequeue();
248      Debug.Assert(varNameTok.Symbol == TokenSymbol.SYMB);
249      t.VariableName = varNameTok.StringValue;
250
251      var varValTok = tokens.Dequeue();
252      Debug.Assert(varValTok.Symbol == TokenSymbol.SYMB);
253      t.VariableValue = varValTok.StringValue;
254
255      var weightTok = tokens.Dequeue();
256      Debug.Assert(weightTok.Symbol == TokenSymbol.NUMBER);
257      t.Weight = weightTok.DoubleValue;
258
259      return t;
260    }
261
262
263    private ISymbolicExpressionTreeNode ParseLaggedVariable(Queue<Token> tokens) {
264      Token varTok = tokens.Dequeue();
265      Debug.Assert(varTok.StringValue == "LAGVARIABLE");
266      LaggedVariableTreeNode t = (LaggedVariableTreeNode)laggedVariable.CreateTreeNode();
267      t.Weight = tokens.Dequeue().DoubleValue;
268      t.VariableName = tokens.Dequeue().StringValue;
269      t.Lag = (int)tokens.Dequeue().DoubleValue;
270      return t;
271    }
272
273    private ISymbolicExpressionTreeNode CreateTree(Token token) {
274      if (token.Symbol != TokenSymbol.SYMB) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
275      return knownSymbols[token.StringValue].CreateTreeNode();
276    }
277
278    private void Expect(Token token, Queue<Token> tokens) {
279      Token cur = tokens.Dequeue();
280      if (!token.Equals(cur)) throw new FormatException("Expected: " + token.StringValue + ", but got: " + cur.StringValue);
281    }
282  }
283}
Note: See TracBrowser for help on using the repository browser.