source: branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-symexpr/convert.go @ 16183

Last change on this file since 16183 was 16183, checked in by hmaislin, 13 months ago

#2929: Adapted PGE Go code to work as dll

File size: 5.7 KB
Line 
1package symexpr
2
3
4
5func (n *Time) ConvertToConstantFs( cs []float64 ) Expr     { return n }
6func (v *Var) ConvertToConstantFs( cs []float64 ) Expr      { return v }
7func (c *Constant) ConvertToConstantFs( cs []float64 ) Expr { return &ConstantF{F: cs[c.P]} }
8func (c *ConstantF) ConvertToConstantFs( cs []float64 ) Expr { return c }
9func (s *System) ConvertToConstantFs( cs []float64 ) Expr   { return s }
10
11func (u *Neg) ConvertToConstantFs( cs []float64 ) Expr     {
12  e := u.C.ConvertToConstantFs(cs)
13  if u.C != e {
14    u.C = e
15  }
16  return u
17}
18func (u *Abs) ConvertToConstantFs( cs []float64 ) Expr     {
19  e := u.C.ConvertToConstantFs(cs)
20  if u.C != e {
21    u.C = e
22  }
23  return u
24}
25func (u *Sqrt) ConvertToConstantFs( cs []float64 ) Expr    {
26  e := u.C.ConvertToConstantFs(cs)
27  if u.C != e {
28    u.C = e
29  }
30  return u
31}
32func (u *Sin) ConvertToConstantFs( cs []float64 ) Expr     {
33  e := u.C.ConvertToConstantFs(cs)
34  if u.C != e {
35    u.C = e
36  }
37  return u
38}
39func (u *Cos) ConvertToConstantFs( cs []float64 ) Expr     {
40  e := u.C.ConvertToConstantFs(cs)
41  if u.C != e {
42    u.C = e
43  }
44  return u
45}
46func (u *Tan) ConvertToConstantFs( cs []float64 ) Expr     {
47  e := u.C.ConvertToConstantFs(cs)
48  if u.C != e {
49    u.C = e
50  }
51  return u
52}
53func (u *Exp) ConvertToConstantFs( cs []float64 ) Expr     {
54  e := u.C.ConvertToConstantFs(cs)
55  if u.C != e {
56    u.C = e
57  }
58  return u
59}
60func (u *Log) ConvertToConstantFs( cs []float64 ) Expr     {
61  e := u.C.ConvertToConstantFs(cs)
62  if u.C != e {
63    u.C = e
64  }
65  return u
66}
67func (u *PowI) ConvertToConstantFs( cs []float64 ) Expr    {
68  e := u.Base.ConvertToConstantFs(cs)
69  if u.Base != e {
70    u.Base = e
71  }
72  return u
73}
74func (u *PowF) ConvertToConstantFs( cs []float64 ) Expr    {
75  e := u.Base.ConvertToConstantFs(cs)
76  if u.Base != e {
77    u.Base = e
78  }
79  return u
80}
81
82func (n *Add) ConvertToConstantFs( cs []float64 ) Expr      {
83  for i,_ := range n.CS {
84    if n.CS[i] != nil {
85      e := n.CS[i].ConvertToConstantFs(cs)
86      if n.CS[i] != e {
87        n.CS[i] = e
88      }
89    }
90  }
91  return n
92}
93
94func (n *Mul) ConvertToConstantFs( cs []float64 ) Expr      {
95  for i,_ := range n.CS {
96    if n.CS[i] != nil {
97      e := n.CS[i].ConvertToConstantFs(cs)
98      if n.CS[i] != e {
99        n.CS[i] = e
100      }
101    }
102  }
103  return n
104}
105
106func (n *Div) ConvertToConstantFs( cs []float64 ) Expr      {
107  e1,e2 := n.Numer.ConvertToConstantFs(cs), n.Denom.ConvertToConstantFs(cs)
108  if n.Numer != e1 { n.Numer = e1 }
109  if n.Denom != e2 { n.Denom = e2 }
110  return n
111
112}
113func (n *PowE) ConvertToConstantFs( cs []float64 ) Expr     {
114  e1,e2 := n.Base.ConvertToConstantFs(cs), n.Power.ConvertToConstantFs(cs)
115  if n.Base != e1 { n.Base = e1 }
116  if n.Power != e2 { n.Power = e2 }
117  return n
118}
119
120
121
122
123
124
125func (n *Time) ConvertToConstants( cs []float64 ) ( []float64, Expr )     { return cs,n }
126func (v *Var) ConvertToConstants( cs []float64 ) ( []float64, Expr )      { return cs,v }
127func (c *Constant) ConvertToConstants( cs []float64 ) ( []float64, Expr ) {
128  c.P = len(cs)
129  return append(cs,float64(c.P)),c
130}
131func (c *ConstantF) ConvertToConstants( cs []float64 ) ( []float64, Expr ) {
132  C := &Constant{P:len(cs)}
133  return append(cs,c.F),C
134}
135func (s *System) ConvertToConstants( cs []float64 ) ( []float64, Expr )   { return cs,s }
136
137func (u *Neg) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
138  css,e := u.C.ConvertToConstants(cs)
139  if u.C != e { u.C = e }
140  return css,u
141}
142func (u *Abs) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
143  css,e := u.C.ConvertToConstants(cs)
144  if u.C != e { u.C = e }
145  return css,u
146}
147func (u *Sqrt) ConvertToConstants( cs []float64 ) ( []float64, Expr )    {
148  css,e := u.C.ConvertToConstants(cs)
149  if u.C != e { u.C = e }
150  return css,u
151}
152func (u *Sin) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
153  css,e := u.C.ConvertToConstants(cs)
154  if u.C != e { u.C = e }
155  return css,u
156}
157func (u *Cos) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
158  css,e := u.C.ConvertToConstants(cs)
159  if u.C != e { u.C = e }
160  return css,u
161}
162func (u *Tan) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
163  css,e := u.C.ConvertToConstants(cs)
164  if u.C != e { u.C = e }
165  return css,u
166}
167func (u *Exp) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
168  css,e := u.C.ConvertToConstants(cs)
169  if u.C != e { u.C = e }
170  return css,u
171}
172func (u *Log) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
173  css,e := u.C.ConvertToConstants(cs)
174  if u.C != e { u.C = e }
175  return css,u
176}
177func (u *PowI) ConvertToConstants( cs []float64 ) ( []float64, Expr )    {
178  css,e := u.Base.ConvertToConstants(cs)
179  if u.Base != e { u.Base = e }
180  return css,u
181}
182func (u *PowF) ConvertToConstants( cs []float64 ) ( []float64, Expr )    {
183  css,e := u.Base.ConvertToConstants(cs)
184  if u.Base != e { u.Base = e }
185  return css,u
186}
187
188func (n *Add) ConvertToConstants( cs []float64 ) ( []float64, Expr )      {
189  for i,_ := range n.CS {
190    if n.CS[i] != nil {
191      var e Expr
192      cs,e = n.CS[i].ConvertToConstants(cs)
193      if n.CS[i] != e { n.CS[i] = e }
194    }
195  }
196  return cs,n
197}
198
199
200func (n *Mul) ConvertToConstants( cs []float64 ) ( []float64, Expr )      {
201  for i,_ := range n.CS {
202    if n.CS[i] != nil {
203      var e Expr
204      cs,e = n.CS[i].ConvertToConstants(cs)
205      if n.CS[i] != e { n.CS[i] = e }
206    }
207  }
208  return cs,n
209}
210
211func (n *Div) ConvertToConstants( cs []float64 ) ( []float64, Expr )      {
212  var e Expr
213  cs,e = n.Numer.ConvertToConstants(cs)
214  if n.Numer != e { n.Numer = e }
215  cs,e = n.Denom.ConvertToConstants(cs)
216  if n.Denom != e { n.Denom = e }
217  return cs,n
218}
219func (n *PowE) ConvertToConstants( cs []float64 ) ( []float64, Expr )     {
220  var e Expr
221  cs,e = n.Base.ConvertToConstants(cs)
222  if n.Base != e { n.Base = e }
223  cs,e = n.Power.ConvertToConstants(cs)
224  if n.Power != e { n.Power = e }
225  return cs,n
226}
Note: See TracBrowser for help on using the repository browser.