Free cookie consent management tool by TermsFeed Policy Generator

source: branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs @ 18114

Last change on this file since 18114 was 18114, checked in by gkronber, 2 years ago

#3140: made several more changes while reviewing the branch.

File size: 24.2 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.Linq;
25using System.Text;
26using HEAL.Attic;
27using HeuristicLab.Common;
28using HeuristicLab.Core;
29using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
30
31namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
32  [Item("LaTeX String Formatter", "Formatter for symbolic expression trees for import into LaTeX documents.")]
33  [StorableType("D7186DFF-1596-4A58-B27D-974DF0D93E4F")]
34  public sealed class SymbolicDataAnalysisExpressionLatexFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
35    private readonly List<KeyValuePair<string, double>> parameters;
36    private int paramIdx;
37    private int targetCount;
38    private int currentLag;
39    private string targetVariable;
40    private bool containsTimeSeriesSymbol;
41
42    [StorableConstructor]
43    private SymbolicDataAnalysisExpressionLatexFormatter(StorableConstructorFlag _) : base(_) { }
44    private SymbolicDataAnalysisExpressionLatexFormatter(SymbolicDataAnalysisExpressionLatexFormatter original, Cloner cloner)
45      : base(original, cloner) {
46      parameters = new List<KeyValuePair<string, double>>(original.parameters);
47      paramIdx = original.paramIdx;
48      currentLag = original.currentLag;
49      targetCount = original.targetCount;
50    }
51    public SymbolicDataAnalysisExpressionLatexFormatter()
52      : base() {
53      Name = ItemName;
54      Description = ItemDescription;
55      parameters = new List<KeyValuePair<string, double>>();
56    }
57
58    public override IDeepCloneable Clone(Cloner cloner) {
59      return new SymbolicDataAnalysisExpressionLatexFormatter(this, cloner);
60    }
61
62    public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
63      return Format(symbolicExpressionTree, null);
64    }
65    public string Format(ISymbolicExpressionTree symbolicExpressionTree, string targetVariable) {
66      try {
67        StringBuilder strBuilder = new StringBuilder();
68        parameters.Clear();
69        paramIdx = 0;
70        this.targetVariable = targetVariable;
71        containsTimeSeriesSymbol = symbolicExpressionTree.IterateNodesBreadth().Any(n => IsTimeSeriesSymbol(n.Symbol));
72        strBuilder.AppendLine(FormatRecursively(symbolicExpressionTree.Root));
73        return strBuilder.ToString();
74      } catch (NotImplementedException ex) {
75        return ex.Message + Environment.NewLine + ex.StackTrace;
76      }
77    }
78    static bool IsTimeSeriesSymbol(ISymbol s) {
79      return s is TimeLag || s is Integral || s is Derivative || s is LaggedVariable;
80    }
81
82    private string FormatRecursively(ISymbolicExpressionTreeNode node) {
83      StringBuilder strBuilder = new StringBuilder();
84      currentLag = 0;
85      FormatBegin(node, strBuilder);
86
87      if (node.SubtreeCount > 0) {
88        strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
89      }
90      int i = 1;
91      foreach (var subTree in node.Subtrees.Skip(1)) {
92        FormatSep(node, strBuilder, i);
93        // format the whole subtree
94        strBuilder.Append(FormatRecursively(subTree));
95        i++;
96      }
97
98      FormatEnd(node, strBuilder);
99
100      return strBuilder.ToString();
101    }
102
103    private void FormatBegin(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
104      if (node.Symbol is Addition) {
105        strBuilder.Append(@" \left( ");
106      } else if (node.Symbol is Subtraction) {
107        if (node.SubtreeCount == 1) {
108          strBuilder.Append(@"- \left( ");
109        } else {
110          strBuilder.Append(@" \left( ");
111        }
112      } else if (node.Symbol is Multiplication) {
113      } else if (node.Symbol is Division) {
114        if (node.SubtreeCount == 1) {
115          strBuilder.Append(@" \cfrac{1}{");
116        } else {
117          strBuilder.Append(@" \cfrac{ ");
118        }
119      } else if (node.Symbol is Absolute) {
120        strBuilder.Append(@"\operatorname{abs} \left( ");
121      } else if (node.Symbol is AnalyticQuotient) {
122        strBuilder.Append(@" \frac { ");
123      } else if (node.Symbol is Average) {
124        // skip output of (1/1) if only one subtree
125        if (node.SubtreeCount > 1) {
126          strBuilder.Append(@" \cfrac{1}{" + node.SubtreeCount + @"}");
127        }
128        strBuilder.Append(@" \left( ");
129      } else if (node.Symbol is Logarithm) {
130        strBuilder.Append(@"\log \left( ");
131      } else if (node.Symbol is Exponential) {
132        strBuilder.Append(@"\exp \left( ");
133      } else if (node.Symbol is Square) {
134        strBuilder.Append(@"\left(");
135      } else if (node.Symbol is SquareRoot) {
136        strBuilder.Append(@"\sqrt{");
137      } else if (node.Symbol is Cube) {
138        strBuilder.Append(@"\left(");
139      } else if (node.Symbol is CubeRoot) {
140        strBuilder.Append(@"\operatorname{cbrt}\left(");
141      } else if (node.Symbol is Sine) {
142        strBuilder.Append(@"\sin \left( ");
143      } else if (node.Symbol is Cosine) {
144        strBuilder.Append(@"\cos \left( ");
145      } else if (node.Symbol is Tangent) {
146        strBuilder.Append(@"\tan \left( ");
147      } else if (node.Symbol is HyperbolicTangent) {
148        strBuilder.Append(@"\tanh \left( ");
149      } else if (node.Symbol is AiryA) {
150        strBuilder.Append(@"\operatorname{airy}_a \left( ");
151      } else if (node.Symbol is AiryB) {
152        strBuilder.Append(@"\operatorname{airy}_b \left( ");
153      } else if (node.Symbol is Bessel) {
154        strBuilder.Append(@"\operatorname{bessel}_1 \left( ");
155      } else if (node.Symbol is CosineIntegral) {
156        strBuilder.Append(@"\operatorname{cosInt} \left( ");
157      } else if (node.Symbol is Dawson) {
158        strBuilder.Append(@"\operatorname{dawson} \left( ");
159      } else if (node.Symbol is Erf) {
160        strBuilder.Append(@"\operatorname{erf} \left( ");
161      } else if (node.Symbol is ExponentialIntegralEi) {
162        strBuilder.Append(@"\operatorname{expInt}_i \left( ");
163      } else if (node.Symbol is FresnelCosineIntegral) {
164        strBuilder.Append(@"\operatorname{fresnel}_\operatorname{cosInt} \left( ");
165      } else if (node.Symbol is FresnelSineIntegral) {
166        strBuilder.Append(@"\operatorname{fresnel}_\operatorname{sinInt} \left( ");
167      } else if (node.Symbol is Gamma) {
168        strBuilder.Append(@"\Gamma \left( ");
169      } else if (node.Symbol is HyperbolicCosineIntegral) {
170        strBuilder.Append(@"\operatorname{hypCosInt} \left( ");
171      } else if (node.Symbol is HyperbolicSineIntegral) {
172        strBuilder.Append(@"\operatorname{hypSinInt} \left( ");
173      } else if (node.Symbol is Norm) {
174        strBuilder.Append(@"\operatorname{norm} \left( ");
175      } else if (node.Symbol is Psi) {
176        strBuilder.Append(@"\operatorname{digamma} \left( ");
177      } else if (node.Symbol is SineIntegral) {
178        strBuilder.Append(@"\operatorname{sinInt} \left( ");
179      } else if (node.Symbol is GreaterThan) {
180        strBuilder.Append(@"  \left( ");
181      } else if (node.Symbol is LessThan) {
182        strBuilder.Append(@"  \left( ");
183      } else if (node.Symbol is And) {
184        strBuilder.Append(@"  \left( \left( ");
185      } else if (node.Symbol is Or) {
186        strBuilder.Append(@"   \left( \left( ");
187      } else if (node.Symbol is Not) {
188        strBuilder.Append(@" \neg \left( ");
189      } else if (node.Symbol is IfThenElse) {
190        strBuilder.Append(@" \operatorname{if}  \left( ");
191      } else if (node.Symbol is INumericSymbol numNode) {
192        var numName = "c_{" + paramIdx + "}";
193        paramIdx++;
194        var numericNode = node as INumericTreeNode;
195        if (numericNode.Value.IsAlmost(1.0)) {
196          strBuilder.Append("1 ");
197        } else {
198          strBuilder.Append(numName);
199          parameters.Add(new KeyValuePair<string, double>(numName, numericNode.Value));
200        }
201      } else if (node.Symbol is FactorVariable) {
202        var factorNode = node as FactorVariableTreeNode;
203        var paramName = "c_{" + paramIdx + "}";
204        strBuilder.Append(paramName + " ");
205        foreach (var e in factorNode.Symbol.GetVariableValues(factorNode.VariableName)
206          .Zip(factorNode.Weights, Tuple.Create)) {
207          parameters.Add(new KeyValuePair<string, double>("c_{" + paramIdx + ", " + EscapeLatexString(factorNode.VariableName) + "=" + EscapeLatexString(e.Item1) + "}", e.Item2));
208        }
209        paramIdx++;
210      } else if (node.Symbol is BinaryFactorVariable) {
211        var binFactorNode = node as BinaryFactorVariableTreeNode;
212        if (!binFactorNode.Weight.IsAlmost((1.0))) {
213          var paramName = "c_{" + paramIdx + "}";
214          strBuilder.Append(paramName + "  \\cdot");
215          parameters.Add(new KeyValuePair<string, double>(paramName, binFactorNode.Weight));
216          paramIdx++;
217        }
218        strBuilder.Append("(" + EscapeLatexString(binFactorNode.VariableName));
219        strBuilder.Append(LagToString(currentLag));
220        strBuilder.Append(" = " + EscapeLatexString(binFactorNode.VariableValue) + " )");
221      } else if (node.Symbol is LaggedVariable) {
222        var laggedVarNode = node as LaggedVariableTreeNode;
223        if (!laggedVarNode.Weight.IsAlmost(1.0)) {
224          var paramName = "c_{" + paramIdx + "}";
225          strBuilder.Append(paramName + "  \\cdot");
226          parameters.Add(new KeyValuePair<string, double>(paramName, laggedVarNode.Weight));
227          paramIdx++;
228        }
229        strBuilder.Append(EscapeLatexString(laggedVarNode.VariableName));
230        strBuilder.Append(LagToString(currentLag + laggedVarNode.Lag));
231
232      } else if (node.Symbol is Variable) {
233        var varNode = node as VariableTreeNode;
234        if (!varNode.Weight.IsAlmost((1.0))) {
235          var paramName = "c_{" + paramIdx + "}";
236          strBuilder.Append(paramName + "  \\cdot");
237          parameters.Add(new KeyValuePair<string, double>(paramName, varNode.Weight));
238          paramIdx++;
239        }
240        strBuilder.Append(EscapeLatexString(varNode.VariableName));
241        strBuilder.Append(LagToString(currentLag));
242      } else if (node.Symbol is ProgramRootSymbol) {
243        strBuilder
244          .AppendLine("\\begin{align*}")
245          .AppendLine("\\nonumber");
246      } else if (node.Symbol is Defun) {
247        var defunNode = node as DefunTreeNode;
248        strBuilder.Append(defunNode.FunctionName + " & = ");
249      } else if (node.Symbol is InvokeFunction) {
250        var invokeNode = node as InvokeFunctionTreeNode;
251        strBuilder.Append(invokeNode.Symbol.FunctionName + @" \left( ");
252      } else if (node.Symbol is StartSymbol) {
253        FormatStartSymbol(strBuilder);
254      } else if (node.Symbol is Argument) {
255        var argSym = node.Symbol as Argument;
256        strBuilder.Append(" ARG+" + argSym.ArgumentIndex + " ");
257      } else if (node.Symbol is Derivative) {
258        strBuilder.Append(@" \cfrac{d \left( ");
259      } else if (node.Symbol is TimeLag) {
260        var laggedNode = node as ILaggedTreeNode;
261        currentLag += laggedNode.Lag;
262      } else if (node.Symbol is Power) {
263        strBuilder.Append(@" \left( ");
264      } else if (node.Symbol is Root) {
265        strBuilder.Append(@" \left( ");
266      } else if (node.Symbol is Integral) {
267        // actually a new variable for t is needed in all subtrees (TODO)
268        var laggedTreeNode = node as ILaggedTreeNode;
269        strBuilder.Append(@"\sum_{t=" + (laggedTreeNode.Lag + currentLag) + @"}^0 \left( ");
270      } else if (node.Symbol is VariableCondition) {
271        var conditionTreeNode = node as VariableConditionTreeNode;
272        var paramName = "c_{" + parameters.Count + "}";
273        string p = @"1 /  1 + \exp  - " + paramName + " ";
274        parameters.Add(new KeyValuePair<string, double>(paramName, conditionTreeNode.Slope));
275        paramIdx++;
276        var const2Name = "c_{" + parameters.Count + @"}";
277        p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - " + const2Name + "   ";
278        parameters.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
279        paramIdx++;
280        strBuilder.Append(@" \left( " + p + @"\cdot ");
281      } else {
282        throw new NotImplementedException("Export of " + node.Symbol + " is not implemented.");
283      }
284    }
285
286    private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, int step) {
287      if (node.Symbol is Addition) {
288        strBuilder.Append(" + ");
289      } else if (node.Symbol is Subtraction) {
290        strBuilder.Append(" - ");
291      } else if (node.Symbol is Multiplication) {
292        strBuilder.Append(@" \cdot ");
293      } else if (node.Symbol is Division) {
294        if (step + 1 == node.SubtreeCount)
295          strBuilder.Append(@"}{");
296        else
297          strBuilder.Append(@" }{ \cfrac{ ");
298      } else if (node.Symbol is Absolute) {
299        throw new InvalidOperationException();
300      } else if (node.Symbol is AnalyticQuotient) {
301        strBuilder.Append(@"}{\sqrt{1 + \left( ");
302      } else if (node.Symbol is Average) {
303        strBuilder.Append(@" + ");
304      } else if (node.Symbol is Logarithm) {
305        throw new InvalidOperationException();
306      } else if (node.Symbol is Exponential) {
307        throw new InvalidOperationException();
308      } else if (node.Symbol is Square) {
309        throw new InvalidOperationException();
310      } else if (node.Symbol is SquareRoot) {
311        throw new InvalidOperationException();
312      } else if (node.Symbol is Cube) {
313        throw new InvalidOperationException();
314      } else if (node.Symbol is CubeRoot) {
315        throw new InvalidOperationException();
316      } else if (node.Symbol is Sine) {
317        throw new InvalidOperationException();
318      } else if (node.Symbol is Cosine) {
319        throw new InvalidOperationException();
320      } else if (node.Symbol is Tangent) {
321        throw new InvalidOperationException();
322      } else if (node.Symbol is HyperbolicTangent) {
323        throw new InvalidOperationException();
324      } else if (node.Symbol is AiryA) {
325        throw new InvalidOperationException();
326      } else if (node.Symbol is AiryB) {
327        throw new InvalidOperationException();
328      } else if (node.Symbol is Bessel) {
329        throw new InvalidOperationException();
330      } else if (node.Symbol is CosineIntegral) {
331        throw new InvalidOperationException();
332      } else if (node.Symbol is Dawson) {
333        throw new InvalidOperationException();
334      } else if (node.Symbol is Erf) {
335        throw new InvalidOperationException();
336      } else if (node.Symbol is ExponentialIntegralEi) {
337        throw new InvalidOperationException();
338      } else if (node.Symbol is FresnelCosineIntegral) {
339        throw new InvalidOperationException();
340      } else if (node.Symbol is FresnelSineIntegral) {
341        throw new InvalidOperationException();
342      } else if (node.Symbol is Gamma) {
343        throw new InvalidOperationException();
344      } else if (node.Symbol is HyperbolicCosineIntegral) {
345        throw new InvalidOperationException();
346      } else if (node.Symbol is HyperbolicSineIntegral) {
347        throw new InvalidOperationException();
348      } else if (node.Symbol is Norm) {
349        throw new InvalidOperationException();
350      } else if (node.Symbol is Psi) {
351        throw new InvalidOperationException();
352      } else if (node.Symbol is SineIntegral) {
353        throw new InvalidOperationException();
354      } else if (node.Symbol is GreaterThan) {
355        strBuilder.Append(@" > ");
356      } else if (node.Symbol is LessThan) {
357        strBuilder.Append(@" < ");
358      } else if (node.Symbol is And) {
359        strBuilder.Append(@" > 0  \right) \land \left(");
360      } else if (node.Symbol is Or) {
361        strBuilder.Append(@" > 0  \right) \lor \left(");
362      } else if (node.Symbol is Not) {
363        throw new InvalidOperationException();
364      } else if (node.Symbol is IfThenElse) {
365        strBuilder.Append(@" , ");
366      } else if (node.Symbol is ProgramRootSymbol) {
367        strBuilder.Append(@"\\" + Environment.NewLine);
368      } else if (node.Symbol is Defun) {
369      } else if (node.Symbol is InvokeFunction) {
370        strBuilder.Append(" , ");
371      } else if (node.Symbol is StartSymbol) {
372        strBuilder.Append(@"\\" + Environment.NewLine);
373        FormatStartSymbol(strBuilder);
374      } else if (node.Symbol is Power) {
375        strBuilder.Append(@"\right) ^ { \operatorname{round} \left(");
376      } else if (node.Symbol is Root) {
377        strBuilder.Append(@"\right) ^ {  \cfrac{1}{ \operatorname{round} \left(");
378      } else if (node.Symbol is VariableCondition) {
379        var conditionTreeNode = node as VariableConditionTreeNode;
380        var const1Name = "c_{" + parameters.Count + "}";
381        string p = @"1 / \left( 1 + \exp \left( - " + const1Name + " ";
382        parameters.Add(new KeyValuePair<string, double>(const1Name, conditionTreeNode.Slope));
383        paramIdx++;
384        var const2Name = "c_{" + parameters.Count + "}";
385        p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - " + const2Name + " \right) \right) \right)   ";
386        parameters.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
387        paramIdx++;
388        strBuilder.Append(@" +  \left( 1 - " + p + @" \right) \cdot ");
389      } else {
390        throw new NotImplementedException("Export of " + node.Symbol + " is not implemented.");
391      }
392    }
393
394    private void FormatEnd(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
395      if (node.Symbol is Addition) {
396        strBuilder.Append(@" \right) ");
397      } else if (node.Symbol is Subtraction) {
398        strBuilder.Append(@" \right) ");
399      } else if (node.Symbol is Multiplication) {
400      } else if (node.Symbol is Division) {
401        strBuilder.Append(" } ");
402        for (int i = 2; i < node.SubtreeCount; i++)
403          strBuilder.Append(" } ");
404      } else if (node.Symbol is Absolute) {
405        strBuilder.Append(@" \right)");
406      } else if (node.Symbol is AnalyticQuotient) {
407        strBuilder.Append(@" \right)^2}}");
408      } else if (node.Symbol is Average) {
409        strBuilder.Append(@" \right) ");
410      } else if (node.Symbol is Logarithm) {
411        strBuilder.Append(@" \right) ");
412      } else if (node.Symbol is Exponential) {
413        strBuilder.Append(@" \right) ");
414      } else if (node.Symbol is Square) {
415        strBuilder.Append(@"\right)^2");
416      } else if (node.Symbol is SquareRoot) {
417        strBuilder.Append(@"}");
418      } else if (node.Symbol is Cube) {
419        strBuilder.Append(@"\right)^3");
420      } else if (node.Symbol is CubeRoot) {
421        strBuilder.Append(@"\right)");
422      } else if (node.Symbol is Sine) {
423        strBuilder.Append(@" \right) ");
424      } else if (node.Symbol is Cosine) {
425        strBuilder.Append(@" \right) ");
426      } else if (node.Symbol is Tangent) {
427        strBuilder.Append(@" \right) ");
428      } else if (node.Symbol is HyperbolicTangent) {
429        strBuilder.Append(@" \right) ");
430      } else if (node.Symbol is AiryA) {
431        strBuilder.Append(@" \right) ");
432      } else if (node.Symbol is AiryB) {
433        strBuilder.Append(@" \right) ");
434      } else if (node.Symbol is Bessel) {
435        strBuilder.Append(@" \right) ");
436      } else if (node.Symbol is CosineIntegral) {
437        strBuilder.Append(@" \right) ");
438      } else if (node.Symbol is Dawson) {
439        strBuilder.Append(@" \right) ");
440      } else if (node.Symbol is Erf) {
441        strBuilder.Append(@" \right) ");
442      } else if (node.Symbol is ExponentialIntegralEi) {
443        strBuilder.Append(@" \right) ");
444      } else if (node.Symbol is FresnelCosineIntegral) {
445        strBuilder.Append(@" \right) ");
446      } else if (node.Symbol is FresnelSineIntegral) {
447        strBuilder.Append(@" \right) ");
448      } else if (node.Symbol is Gamma) {
449        strBuilder.Append(@" \right) ");
450      } else if (node.Symbol is HyperbolicCosineIntegral) {
451        strBuilder.Append(@" \right) ");
452      } else if (node.Symbol is HyperbolicSineIntegral) {
453        strBuilder.Append(@" \right) ");
454      } else if (node.Symbol is Norm) {
455        strBuilder.Append(@" \right) ");
456      } else if (node.Symbol is Psi) {
457        strBuilder.Append(@" \right) ");
458      } else if (node.Symbol is SineIntegral) {
459        strBuilder.Append(@" \right) ");
460      } else if (node.Symbol is GreaterThan) {
461        strBuilder.Append(@" \right) ");
462      } else if (node.Symbol is LessThan) {
463        strBuilder.Append(@" \right) ");
464      } else if (node.Symbol is And) {
465        strBuilder.Append(@" > 0 \right) \right) ");
466      } else if (node.Symbol is Or) {
467        strBuilder.Append(@" > 0 \right) \right) ");
468      } else if (node.Symbol is Not) {
469        strBuilder.Append(@" \right) ");
470      } else if (node.Symbol is IfThenElse) {
471        strBuilder.Append(@" \right) ");
472      } else if (node.Symbol is Number) {
473      } else if (node.Symbol is Constant) {
474      }else if (node.Symbol is LaggedVariable) {
475      } else if (node.Symbol is Variable) {
476      } else if (node.Symbol is FactorVariable) {
477      } else if (node.Symbol is BinaryFactorVariable) {
478      } else if (node.Symbol is ProgramRootSymbol) {
479        strBuilder
480          .AppendLine("\\end{align*}")
481          .AppendLine("\\begin{align*}")
482          .AppendLine("\\nonumber");
483        // output all parameter values
484        if (parameters.Count > 0) {
485          foreach (var param in parameters) {
486            // replace "." with ".&" to align decimal points
487            var paramStr = string.Format(System.Globalization.NumberFormatInfo.InvariantInfo, "{0:G5}", param.Value);
488            if (!paramStr.Contains(".")) paramStr = paramStr + ".0";
489            paramStr = paramStr.Replace(".", "&.");  // fix problem in rendering of aligned expressions
490            strBuilder.Append(param.Key + "& = & " + paramStr);
491            strBuilder.Append(@"\\");
492          }
493        }
494        strBuilder.AppendLine("\\end{align*}");
495      } else if (node.Symbol is Defun) {
496      } else if (node.Symbol is InvokeFunction) {
497        strBuilder.Append(@" \right) ");
498      } else if (node.Symbol is StartSymbol) {
499      } else if (node.Symbol is Argument) {
500      } else if (node.Symbol is Derivative) {
501        strBuilder.Append(@" \right) }{dt} ");
502      } else if (node.Symbol is TimeLag) {
503        var laggedNode = node as ILaggedTreeNode;
504        currentLag -= laggedNode.Lag;
505      } else if (node.Symbol is Power) {
506        strBuilder.Append(@" \right) } ");
507      } else if (node.Symbol is Root) {
508        strBuilder.Append(@" \right) } } ");
509      } else if (node.Symbol is Integral) {
510        strBuilder.Append(@" \right) ");
511      } else if (node.Symbol is VariableCondition) {
512        strBuilder.Append(@"\right) ");
513      } else {
514        throw new NotImplementedException("Export of " + node.Symbol + " is not implemented.");
515      }
516    }
517
518    private void FormatStartSymbol(StringBuilder strBuilder) {
519      strBuilder.Append(targetVariable != null ? EscapeLatexString(targetVariable) : "\\text{target}_{" + targetCount++ + "}");
520      if (containsTimeSeriesSymbol)
521        strBuilder.Append("(t)");
522      strBuilder.Append(" & = ");
523    }
524
525    private string LagToString(int lag) {
526      if (lag < 0) {
527        return "(t" + lag + ")";
528      } else if (lag > 0) {
529        return "(t+" + lag + ")";
530      } else return "";
531    }
532
533    private string EscapeLatexString(string s) {
534      return "\\text{" +
535        s
536         .Replace("\\", "\\\\")
537         .Replace("{", "\\{")
538         .Replace("}", "\\}")
539        + "}";
540    }
541  }
542}
Note: See TracBrowser for help on using the repository browser.