source: branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/src/go-symexpr/deriv.go @ 16620

Last change on this file since 16620 was 16620, checked in by hmaislin, 9 months ago

#2929: Reorganized folder structure for make script, removed explicit marshalling, erased go-side logging

File size: 7.9 KB
Line 
1package symexpr
2
3
4
5func (l *Leaf) DerivVar( i int) Expr     { return NewConstantF(0.0) }
6func (l *Leaf) DerivConst( i int) Expr  { return NewConstantF(0.0) }
7
8func (u *Unary) DerivVar( i int ) Expr { return nil }
9func (u *Unary) DerivConst( i int ) Expr { return nil }
10
11func (n *N_ary) DerivVar( i int ) Expr { return nil }
12func (n *N_ary) DerivConst( i int ) Expr { return nil }
13
14
15func (v *Var) DerivVar( i int) Expr      {
16  var f float64
17  if v.P == i { f = 1.0 }
18  return NewConstantF(f)
19}
20
21
22func (u *Neg) DerivVar( i int) Expr    { return NewNeg(u.C.DerivVar(i)) }
23func (u *Abs) DerivVar( i int) Expr    { return NewAbs(u.C.DerivVar(i)) }
24func (u *Sqrt) DerivVar( i int) Expr     { return NewPowF(u.C.Clone(),0.5).DerivVar(i) }
25func (u *Sin) DerivVar( i int) Expr    {
26  if u.C.HasVarI(i) {
27    c := NewCos(u.C.Clone())
28    g := u.C.DerivVar(i)
29    m := NewMul()
30    m.Insert(g)
31    m.Insert(c)
32    return m
33  }
34  return NewConstantF(0.0)
35}
36func (u *Cos) DerivVar( i int) Expr    {
37  if u.C.HasVarI(i) {
38    n := NewNeg(NewSin(u.C.Clone()))
39    g := u.C.DerivVar(i)
40    m := NewMul()
41    m.Insert(g)
42    m.Insert(n)
43    return m
44  }
45  return NewConstantF(0.0)
46}
47func (u *Tan) DerivVar( i int) Expr    {
48  if u.C.HasVarI(i) {
49    n := u.C.DerivVar(i)
50    d := NewPowI(NewCos(u.C.Clone()),2)
51    return NewDiv(n,d)
52  }
53  return NewConstantF(0.0)
54}
55func (u *Exp) DerivVar( i int) Expr    {
56  if u.C.HasVarI(i) {
57    e := u.Clone()
58    g := u.C.DerivVar(i)
59    m := NewMul()
60    m.Insert(g)
61    m.Insert(e)
62    return m
63  }
64  return NewConstantF(0.0)
65}
66func (u *Log) DerivVar( i int) Expr    {
67  if u.C.HasVarI(i) {
68    var d Div
69    d.Numer = u.C.DerivVar(i)
70    d.Denom = u.C.Clone()
71    return &d
72  }
73  return NewConstantF(0.0)
74}
75func (u *PowI) DerivVar( i int) Expr     {
76  if u.Base.HasVarI(i) {
77    p := NewPowI(u.Base.Clone(),u.Power-1.0)
78    c := &ConstantF{F: float64(u.Power)}
79    g := u.Base.DerivVar(i)
80    m := NewMul()
81    m.Insert(c)
82    m.Insert(g)
83    m.Insert(p)
84    return m
85  }
86  return NewConstantF(0.0)
87}
88func (u *PowF) DerivVar( i int) Expr     {
89  if u.Base.HasVarI(i) {
90    p := NewPowF(u.Base.Clone(),u.Power-1.0)
91    c := &ConstantF{F: u.Power}
92    g := u.Base.DerivVar(i)
93    m := NewMul()
94    m.Insert(c)
95    m.Insert(g)
96    m.Insert(p)
97    return m
98  }
99  return NewConstantF(0.0)
100}
101
102func (n *Add) DerivVar( i int) Expr      {
103  if n.HasVarI(i) {
104    a := NewAdd()
105    for _,C := range n.CS {
106      if C == nil { continue }
107      if C.HasVarI(i) {
108        a.Insert( C.DerivVar(i) )
109      }
110    }
111    if len(a.CS) > 0 {
112      return a
113    }
114  }
115  return NewConstantF(0.0)
116}
117func (n *Mul) DerivVar( i int) Expr      {
118  if n.HasVarI(i) {
119    a := NewAdd()
120    for j,J := range n.CS {
121      if J == nil { continue }
122      if J.HasVarI(i) {
123        m := NewMul()
124        for I,C := range n.CS {
125          if C == nil { continue }
126//           fmt.Printf( "%d,%d  %v\n", j,I, C)
127          if j==I {
128            m.Insert( C.DerivVar(i) )
129          } else {
130            m.Insert( C.Clone() )
131          }
132        }
133        a.Insert(m)
134      }
135
136    }
137    if len(a.CS) > 0 {
138      return a
139    }
140  }
141  return NewConstantF(0.0)
142}
143func (n *Div) DerivVar( i int) Expr      {
144  if n.HasVarI(i) {
145    d := new(Div)
146
147    a := NewAdd()
148    m1 := NewMul()
149    m1.Insert(n.Numer.DerivVar(i))
150    m1.Insert(n.Denom.Clone())
151    m2 := NewMul()
152    m2.Insert(NewConstantF(-1.0))
153    m2.Insert(n.Numer.Clone())
154    m2.Insert(n.Denom.DerivVar(i))
155    a.Insert(m1)
156    a.Insert(m2)
157    d.Numer = a
158
159    p2 := NewPowI(n.Denom.Clone(),2)
160    d.Denom = p2
161    return d
162  }
163  return NewConstantF(0.0)
164}
165
166// TODO TODO TODO fix me and the next one
167func (n *PowE) DerivVar( i int) Expr     {
168  if n.HasVarI(i) {
169    a := NewAdd()
170
171    m1 := NewMul()
172    m1.Insert(n.Base.DerivVar(i))
173    m1.Insert(n.Power.Clone())
174
175    // ???
176    p1 := new(PowE)
177    p1.Base = n.Base.Clone()
178    // ???
179    a1 := NewAdd()
180    a1.Insert(n.Power.Clone())
181    a1.Insert(NewConstantF(-1.0))
182
183    m2 := NewMul()
184    m2.Insert(n.Power.DerivVar(i))
185    m2.Insert(n.Clone())
186    m2.Insert(NewLog(n.Base.Clone()))
187
188    a.Insert(m1)
189    a.Insert(m2)
190
191
192  }
193  return NewConstantF(0.0)
194}
195
196
197
198
199
200
201func (c *Constant) DerivConst( i int) Expr {
202  var f float64
203  if c.P == i { f = 1.0 }
204  return NewConstantF(f)
205}
206
207
208func (u *Neg) DerivConst( i int) Expr    { return NewNeg(u.C.DerivConst(i)) }
209func (u *Abs) DerivConst( i int) Expr    { return NewAbs(u.C.DerivConst(i)) }
210func (u *Sqrt) DerivConst( i int) Expr     { return (NewPowF(u.C.Clone(),0.5)).DerivConst(i) }
211func (u *Sin) DerivConst( i int) Expr    {
212  if u.C.HasConstI(i) {
213    c := NewCos(u.C.Clone())
214    g := u.C.DerivConst(i)
215    m := NewMul()
216    m.Insert(g)
217    m.Insert(c)
218    return m
219  }
220  return NewConstantF(0.0)
221}
222func (u *Cos) DerivConst( i int) Expr    {
223  if u.C.HasConstI(i) {
224    n := NewNeg(NewSin(u.C.Clone()))
225    g := u.C.DerivConst(i)
226    m := NewMul()
227    m.Insert(g)
228    m.Insert(n)
229    return m
230  }
231  return NewConstantF(0.0)
232}
233func (u *Exp) DerivConst( i int) Expr    {
234  if u.C.HasConstI(i) {
235    e := u.Clone()
236    g := u.C.DerivConst(i)
237    m := NewMul()
238    m.Insert(g)
239    m.Insert(e)
240    return m
241  }
242  return NewConstantF(0.0)
243}
244func (u *Log) DerivConst( i int) Expr    {
245  if u.C.HasConstI(i) {
246    return NewDiv(u.C.DerivConst(i),u.C.Clone())
247  }
248  return NewConstantF(0.0)
249}
250func (u *PowI) DerivConst( i int) Expr     {
251  if u.Base.HasConstI(i) {
252    p := NewPowI(u.Base.Clone(),u.Power-1)
253    c := &ConstantF{F: float64(u.Power)}
254    g := u.Base.DerivConst(i)
255    m := NewMul()
256    m.Insert(c)
257    m.Insert(g)
258    m.Insert(p)
259    return m
260  }
261  return NewConstantF(0.0)
262}
263func (u *PowF) DerivConst( i int) Expr     {
264  if u.Base.HasVarI(i) {
265    p := NewPowF(u.Base.Clone(),u.Power-1.0)
266    c := NewConstantF(u.Power)
267    g := u.Base.DerivConst(i)
268    m := NewMul()
269    m.Insert(c)
270    m.Insert(g)
271    m.Insert(p)
272    return m
273  }
274  return NewConstantF(0.0)
275}
276
277func (n *Add) DerivConst( i int) Expr      {
278  if n.HasConstI(i) {
279    a := NewAdd()
280    for _,C := range n.CS {
281      if C == nil { continue }
282      if C.HasConstI(i) {
283        a.Insert( C.DerivConst(i) )
284      }
285    }
286    if len(a.CS) > 0 {
287      return a
288    }
289  }
290  return NewConstantF(0.0)
291}
292
293func (n *Mul) DerivConst( i int) Expr      {
294  if n.HasConstI(i) {
295    a := NewAdd()
296    for j,J := range n.CS {
297      if J == nil { continue }
298      if J.HasConstI(i) {
299        m := NewMul()
300        for I,C := range n.CS {
301          if C == nil { continue }
302          if j==I {
303            m.Insert( C.DerivConst(i) )
304          } else {
305            m.Insert( C.Clone() )
306          }
307        }
308        a.Insert(m)
309      }
310
311    }
312    if len(a.CS) > 0 {
313      return a
314    }
315  }
316  return NewConstantF(0.0)
317}
318func (n *Div) DerivConst( i int) Expr      {
319  if n.HasConstI(i) {
320    d := new(Div)
321
322    a := NewAdd()
323    m1 := NewMul()
324    m1.Insert(n.Denom.Clone())
325    m1.Insert(n.Numer.DerivConst(i))
326    a.Insert(m1)
327
328    m2 := NewMul()
329    m2.Insert(n.Numer.Clone())
330    m2.Insert(n.Denom.DerivConst(i))
331    n2 := NewNeg(m2)
332    a.Insert(n2)
333
334    d.Numer = a
335
336    p2 := NewPowI(n.Denom.Clone(),2)
337    d.Denom = p2
338    return d
339  }
340  return NewConstantF(0.0)
341}
342func (n *PowE) DerivConst( i int) Expr     {
343  if n.HasConstI(i) {
344    a := NewAdd()
345
346    m1 := NewMul()
347    m1.Insert(n.Base.DerivConst(i))
348    m1.Insert(n.Power.Clone())
349    p1 := new(PowE)
350    p1.Base = n.Base.Clone()
351    a1 := NewAdd()
352    a1.Insert(n.Power.Clone())
353    a1.Insert( NewConstantF(-1.0))
354
355    m2 := NewMul()
356    m2.Insert(n.Power.DerivConst(i))
357    m2.Insert(n.Clone())
358    m2.Insert( NewLog(n.Base.Clone()) )
359
360    a.Insert(m1)
361    a.Insert(m2)
362
363
364  }
365  return NewConstantF(0.0)
366}
Note: See TracBrowser for help on using the repository browser.