Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 16666 was 16620, checked in by hmaislin, 5 years ago

#2929: Reorganized folder structure for make script, removed explicit marshalling, erased go-side logging
File size: 39.7 KB
Line 
1package symexpr
2
3import (
4  "testing"
5
6  "fmt"
7  "math"
8)
9
10func Test_SimpLeafs(TEST *testing.T) {
11  fmt.Printf("Testing: Simplifying Leafs    ")
12  var rules = DefaultRules()
13
14  t := NewTime()
15  t_simp := t.Simplify(rules)
16  if t != t_simp {
17    TEST.Fatalf("FAIL Time: t != t_simp  ~  %v -> %v", t, t_simp)
18  } else {
19    TEST.Logf("Time Simp:  %v -> %v", t, t_simp)
20  }
21
22  v := NewVar(0)
23  v_simp := v.Simplify(rules)
24  if v != v_simp {
25    TEST.Fatalf("FAIL Var: v != v_simp ~  %v ->%v", v, v_simp)
26  } else {
27    TEST.Logf("Var Simp:  %v -> %v", v, v_simp)
28  }
29
30  c := NewConstant(0)
31  c_simp := c.Simplify(rules)
32  if c != c_simp {
33    TEST.Fatalf("FAIL Constant: c != c_simp  ~  %v -> %v", c, c_simp)
34  } else {
35    TEST.Logf("Constant Simp  %v -> %v", c, c_simp)
36  }
37
38  s := NewSystem(0)
39  s_simp := s.Simplify(rules)
40  if s != s_simp {
41    TEST.Fatalf("FAIL System: s != s_simp  ~  %v -> %v", s, s_simp)
42  } else {
43    TEST.Logf("System Simp:  %v -> %v", s, s_simp)
44  }
45
46  f := NewConstantF(3.141529)
47  f_simp := f.Simplify(rules)
48  if f != f_simp {
49    TEST.Fatalf("FAIL ConstantF: f != f_simp  ~  %v -> %v", f, f_simp)
50  } else {
51    TEST.Logf("ConstantF Simp:  %v -> %v", f, f_simp)
52  }
53
54  n := NewConstantF(math.NaN())
55  n_simp := n.Simplify(rules)
56  if n_simp != nil {
57    TEST.Fatalf("FAIL NaN: n_simp != nil  ~  %v -> %v", n, n_simp)
58  } else {
59    TEST.Logf("NaN Simp:  %v -> %v", n, n_simp)
60  }
61
62  i := NewConstantF(math.Inf(1))
63  i_simp := i.Simplify(rules)
64  if i_simp != nil {
65    TEST.Fatalf("FAIL Inf: i == i_simp  ~  %v -> %v", i, i_simp)
66  } else {
67    TEST.Logf("Inf Simp:  %v -> %v", i, i_simp)
68  }
69
70  fmt.Printf("Passed\n")
71}
72
73func Test_SimpNeg(TEST *testing.T) {
74  fmt.Printf("Testing: Simplifying Neg      ")
75  var rules = DefaultRules()
76
77  nn := NewNeg(nil)
78  nn_simp := nn.Simplify(rules)
79  if nn_simp != nil {
80    TEST.Fatalf("FAIL NegNil: nn_simp != nil  ~  %v -> %v", nn, nn_simp)
81  } else {
82    TEST.Logf("NegNil:  %v -> %v", nn, nn_simp)
83  }
84
85  nl := NewNeg(NewNull())
86  nl_simp := nl.Clone().Simplify(rules)
87  if nl_simp != nil {
88    TEST.Fatalf("FAIL NegNull: nn_simp != Null  ~  %v -> %v", nl, nl_simp)
89  } else {
90    TEST.Logf("NegNull:  %v -> %v", nl, nl_simp)
91  }
92
93  nv := NewNeg(NewVar(0))
94  nv_simp := nv.Simplify(rules)
95  if nv != nv_simp {
96    TEST.Fatalf("FAIL NegVar: nv != nv_simp  ~  %v -> %v", nv, nv_simp)
97  } else {
98    TEST.Logf("NegVar:  %v -> %v", nv, nv_simp)
99  }
100
101  c := NewConstant(0)
102  nc := NewNeg(c)
103  nc_simp := nc.Clone().Simplify(rules)
104  if !c.AmISame(nc_simp) {
105    TEST.Fatalf("FAIL NegConst: c != nc_simp  ~  %v -> %v", nc, nc_simp)
106  } else {
107    TEST.Logf("NegConst:  %v -> %v", nc, nc_simp)
108  }
109
110  m := NewMul()
111  m.Insert(NewVar(0))
112  m.Insert(NewConstant(0))
113  nm := NewNeg(m)
114  nm_simp := nm.Clone().Simplify(rules)
115  if !nm_simp.AmISame(m) {
116    TEST.Fatalf("FAIL NegMul: m != nm_simp  ~  %v -> %v", nm, nm_simp)
117  } else {
118    TEST.Logf("NegMul:  %v -> %v", nm, nm_simp)
119  }
120
121  fmt.Printf("Passed\n")
122}
123
124func Test_SimpAbs(TEST *testing.T) {
125  fmt.Printf("Testing: Simplifying Abs      ")
126  var rules = DefaultRules()
127
128  nn := NewAbs(nil)
129  nn_simp := nn.Clone().Simplify(rules)
130  if nn_simp != nil {
131    TEST.Fatalf("FAIL AbsNil: nn_simp != nil  ~  %v -> %v", nn, nn_simp)
132  } else {
133    TEST.Logf("AbsNil:  %v -> %v", nn, nn_simp)
134  }
135
136  nl := NewAbs(NewNull())
137  nl_simp := nl.Clone().Simplify(rules)
138  if nl_simp != nil {
139    TEST.Fatalf("FAIL AbsNull: nn_simp != Null  ~  %v -> %v", nl, nl_simp)
140  } else {
141    TEST.Logf("AbsNull:  %v -> %v", nl, nl_simp)
142  }
143
144  nv := NewAbs(NewVar(0))
145  nv_simp := nv.Simplify(rules)
146  if !nv.AmISame(nv_simp) {
147    TEST.Fatalf("FAIL AbsVar: nv != nv_simp  ~  %v -> %v", nv, nv_simp)
148  } else {
149    TEST.Logf("AbsVar:  %v -> %v", nv, nv_simp)
150  }
151
152  c := NewConstant(0)
153  nc := NewAbs(c)
154  nc_simp := nc.Simplify(rules)
155  if !nc.AmISame(nc_simp) {
156    TEST.Fatalf("FAIL AbsConst: c != nc_simp  ~  %v -> %v", nc, nc_simp)
157  } else {
158    TEST.Logf("AbsConst:  %v -> %v", nc, nc_simp)
159  }
160
161  m := NewMul()
162  m.Insert(NewVar(0))
163  m.Insert(NewConstant(0))
164  nm := NewAbs(m)
165  nm_simp := nm.Simplify(rules)
166  if !nm_simp.AmISame(nm) {
167    TEST.Fatalf("FAIL AbsMul: m != nm_simp  ~  %v -> %v", nm, nm_simp)
168  } else {
169    TEST.Logf("AbsMul:  %v -> %v", nm, nm_simp)
170  }
171
172  fmt.Printf("Passed\n")
173}
174
175func Test_SimpSqrt(TEST *testing.T) {
176  fmt.Printf("Testing: Simplifying Sqrt     ")
177  var rules = DefaultRules()
178
179  nn := NewSqrt(nil)
180  nn_simp := nn.Clone().Simplify(rules)
181  if nn_simp != nil {
182    TEST.Fatalf("FAIL SqrtNil: nn_simp != nil  ~  %v -> %v", nn, nn_simp)
183  } else {
184    TEST.Logf("SqrtNil:  %v -> %v", nn, nn_simp)
185  }
186
187  nl := NewSqrt(NewNull())
188  nl_simp := nl.Clone().Simplify(rules)
189  if nl_simp != nil {
190    TEST.Fatalf("FAIL SqrtNull: nn_simp != Null  ~  %v -> %v", nl, nl_simp)
191  } else {
192    TEST.Logf("SqrtNull:  %v -> %v", nl, nl_simp)
193  }
194
195  ns := NewSqrt(NewSqrt(NewVar(0)))
196  ns_simp := ns.Clone().Simplify(rules)
197  ns_corr := NewPowF(NewVar(0), 0.25)
198  if !ns_simp.AmISame(ns_corr) {
199    TEST.Fatalf("FAIL SqrtSqrt: ns_simp != ns_corr  ~  %v -> %v  ==  %v", ns, ns_simp, ns_corr)
200  } else {
201    TEST.Logf("SqrtSqrt:  %v -> %v", ns, ns_simp)
202  }
203
204  c := NewConstant(0)
205  nc := NewSqrt(c)
206  nc_simp := nc.Clone().Simplify(rules)
207  if !c.AmISame(nc_simp) {
208    TEST.Fatalf("FAIL SqrtConst: c != nc_simp  ~  %v -> %v", nc, nc_simp)
209  } else {
210    TEST.Logf("SqrtConst:  %v -> %v", nc, nc_simp)
211  }
212
213  nf := NewSqrt(NewPowF(NewVar(0), 3.14))
214  nf_simp := nf.Clone().Simplify(rules)
215  nf_corr := NewPowF(NewVar(0), 3.14/2.0)
216  if !nf_simp.AmISame(nf_corr) {
217    TEST.Fatalf("FAIL SqrtPowF: nf_simp != nf_corr  ~  %v -> %v  ==  %v", nf, nf_simp, nf_corr)
218  } else {
219    TEST.Logf("SqrtPowF:  %v -> %v", nf, nf_simp)
220  }
221
222  ni1 := NewSqrt(NewPowI(NewVar(0), 1))
223  ni1_simp := ni1.Clone().Simplify(rules)
224  ni1_corr := NewSqrt(NewVar(0))
225  if !ni1_simp.AmISame(ni1_corr) {
226    TEST.Fatalf("FAIL SqrtPowI(ni1): ni1_simp != ni1_corr  ~  %v -> %v  ==  %v", ni1, ni1_simp, ni1_corr)
227  } else {
228    TEST.Logf("SqrtPowI(ni1):  %v -> %v", ni1, ni1_simp)
229  }
230
231  //   ni1n := NewSqrt(NewPowI(NewVar(0),-1))
232  //   ni1n_simp := ni1n.Clone().Simplify(rules)
233  //   ni1n_corr := NewSqrt(NewVar(0))
234  //   if !ni1n_simp.AmISame(ni1n_corr) {
235  //  TEST.Fatalf( "FAIL SqrtPowI(ni1n): ni1n_simp != ni1n_corr  ~  %v -> %v  ==  %v", ni1n,ni1n_simp, ni1n_corr )
236  //   } else {
237  //  TEST.Logf( "SqrtPowI(ni1n):  %v -> %v", ni1n,ni1n_simp )
238  //   }
239  //
240  //   ni2 := NewSqrt(NewPowI(NewVar(0),2))
241  //   ni2_simp := ni2.Clone().Simplify(rules)
242  //   ni2_corr := NewSqrt(NewVar(0))
243  //   if !ni2_simp.AmISame(ni2_corr) {
244  //  TEST.Fatalf( "FAIL SqrtPowI(ni2): ni2_simp != ni2_corr  ~  %v -> %v  ==  %v", ni2,ni2_simp, ni2_corr )
245  //   } else {
246  //  TEST.Logf( "SqrtPowI(ni2):  %v -> %v", ni2,ni2_simp )
247  //   }
248  //
249  //   ni2n := NewSqrt(NewPowI(NewVar(0),-2))
250  //   ni2n_simp := ni2n.Clone().Simplify(rules)
251  //   ni2n_corr := NewSqrt(NewVar(0))
252  //   if !ni2n_simp.AmISame(ni2n_corr) {
253  //  TEST.Fatalf( "FAIL SqrtPowI(ni2n): ni2n_simp != ni2n_corr  ~  %v -> %v  ==  %v", ni2n,ni2n_simp, ni2n_corr )
254  //   } else {
255  //  TEST.Logf( "SqrtPowI(ni2n):  %v -> %v", ni2n,ni2n_simp )
256  //   }
257  //
258  //   niOdd := NewSqrt(NewPowI(NewVar(0),3))
259  //   niOdd_simp := niOdd.Clone().Simplify(rules)
260  //   niOdd_corr := NewSqrt(NewVar(0))
261  //   if !niOdd_simp.AmISame(niOdd_corr) {
262  //  TEST.Fatalf( "FAIL SqrtPowI(niOdd): niOdd_simp != niOdd_corr  ~  %v -> %v  ==  %v", niOdd,niOdd_simp, niOdd_corr )
263  //   } else {
264  //  TEST.Logf( "SqrtPowI(niOdd):  %v -> %v", niOdd,niOdd_simp )
265  //   }
266  //
267  //   niOddn := NewSqrt(NewPowI(NewVar(0),-3))
268  //   niOddn_simp := niOddn.Clone().Simplify(rules)
269  //   niOddn_corr := NewSqrt(NewVar(0))
270  //   if !niOddn_simp.AmISame(niOddn_corr) {
271  //  TEST.Fatalf( "FAIL SqrtPowI(niOddn): niOddn_simp != niOddn_corr  ~  %v -> %v  ==  %v", niOddn,niOddn_simp, niOddn_corr )
272  //   } else {
273  //  TEST.Logf( "SqrtPowI(niOddn):  %v -> %v", niOddn,niOddn_simp )
274  //   }
275  //
276  //   ni2N := NewSqrt(NewPowI(NewVar(0),4))
277  //   ni2N_simp := ni2N.Clone().Simplify(rules)
278  //   ni2N_corr := NewSqrt(NewVar(0))
279  //   if !ni2N_simp.AmISame(ni2N_corr) {
280  //  TEST.Fatalf( "FAIL SqrtPowI(ni2N): ni2N_simp != ni2N_corr  ~  %v -> %v  ==  %v", ni2N,ni2N_simp, ni2N_corr )
281  //   } else {
282  //  TEST.Logf( "SqrtPowI(ni2N):  %v -> %v", ni2N,ni2N_simp )
283  //   }
284  //
285  //   ni2Nn := NewSqrt(NewPowI(NewVar(0),-4))
286  //   ni2Nn_simp := ni2Nn.Clone().Simplify(rules)
287  //   ni2Nn_corr := NewSqrt(NewVar(0))
288  //   if !ni2Nn_simp.AmISame(ni2Nn_corr) {
289  //  TEST.Fatalf( "FAIL SqrtPowI(ni2Nn): ni2Nn_simp != ni2Nn_corr  ~  %v -> %v  ==  %v", ni2Nn,ni2Nn_simp, ni2Nn_corr )
290  //   } else {
291  //  TEST.Logf( "SqrtPowI(ni2Nn):  %v -> %v", ni2Nn,ni2Nn_simp )
292  //   }
293  //
294  //
295
296  // the following should not change
297
298  nv := NewSqrt(NewVar(0))
299  nv_simp := nv.Simplify(rules)
300  if nv != nv_simp {
301    TEST.Fatalf("FAIL SqrtVar: nv != nv_simp  ~  %v -> %v", nv, nv_simp)
302  } else {
303    TEST.Logf("SqrtVar:  %v -> %v", nv, nv_simp)
304  }
305
306  m := NewMul()
307  m.Insert(NewVar(0))
308  m.Insert(NewConstant(0))
309  nm := NewSqrt(m)
310  nm_simp := nm.Simplify(rules)
311  if nm_simp != nm {
312    TEST.Fatalf("FAIL SqrtMul: nm != nm_simp  ~  %v -> %v", nm, nm_simp)
313  } else {
314    TEST.Logf("SqrtMul:  %v -> %v", nm, nm_simp)
315  }
316
317  fmt.Printf("Passed\n")
318}
319
320func Test_SimpAdd(TEST *testing.T) {
321  fmt.Printf("Testing: Simplifying Add     ")
322  var rules = DefaultRules()
323
324  an := NewAdd()
325  an.Insert(nil)
326  an_simp := an.Clone().Simplify(rules)
327  if an_simp != nil {
328    TEST.Fatalf("FAIL AddNil: an_simp != nil  ~  %v -> %v", an, an_simp)
329  } else {
330    TEST.Logf("AddNil:  %v -> %v", an, an_simp)
331  }
332
333  al := NewAdd()
334  al.Insert(NewNull())
335  al_simp := al.Clone().Simplify(rules)
336  if al_simp != nil {
337    TEST.Fatalf("FAIL AddNull: nn_simp != Null  ~  %v -> %v", al, al_simp)
338  } else {
339    TEST.Logf("AddNull:  %v -> %v", al, al_simp)
340  }
341
342  as := NewAdd()
343  as.Insert(NewVar(0))
344  as_simp := as.Clone().Simplify(rules)
345  as_corr := NewVar(0)
346  if !as_simp.AmISame(as_corr) {
347    TEST.Fatalf("FAIL AddVar: as_simp != as_corr  ~  %v -> %v  ==  %v", as, as_simp, as_corr)
348  } else {
349    TEST.Logf("AddVar:  %v -> %v", as, as_simp)
350  }
351
352  c := NewConstant(0)
353  ac := NewAdd()
354  ac.Insert(c)
355  ac_simp := ac.Clone().Simplify(rules)
356  if !c.AmISame(ac_simp) {
357    TEST.Fatalf("FAIL AddConst: c != ac_simp  ~  %v -> %v", ac, ac_simp)
358  } else {
359    TEST.Logf("AddConst:  %v -> %v", ac, ac_simp)
360  }
361
362  // x + y
363  A1 := NewAdd()
364  A1.Insert(NewVar(0))
365  A1.Insert(NewVar(1))
366  // A1.CS[0], A1.CS[1] = A1.CS[1], A1.CS[0]
367  A1_simp := A1.Clone().Simplify(rules)
368  A1_corr := A1.Clone()
369  if !A1_simp.AmISame(A1_corr) {
370    TEST.Fatalf("FAIL Add_A1: A1_simp != A1_corr  ~  %v -> %v  ==  %v", A1, A1_simp, A1_corr)
371  } else {
372    TEST.Logf("AddVar:  %v -> %v", A1, A1_simp)
373  }
374
375  // x + x
376  A2 := NewAdd()
377  A2.Insert(NewVar(0))
378  A2.Insert(NewVar(0))
379  A2_simp := A2.Clone().Simplify(rules)
380  A2_corr := NewMul()
381  A2_corr.Insert(NewConstant(0))
382  A2_corr.Insert(NewVar(0))
383
384  if !A2_simp.AmISame(A2_corr) {
385    TEST.Fatalf("FAIL Add_A2: A2_simp != A2_corr  ~  %v -> %v  ==  %v", A2, A2_simp, A2_corr)
386  } else {
387    TEST.Logf("AddVar:  %v -> %v", A2, A2_simp)
388  }
389
390  // x + x + y
391  A3 := NewAdd()
392  A3.Insert(NewVar(0))
393  A3.Insert(NewVar(0))
394  A3.Insert(NewVar(1))
395  A3_simp := A3.Clone().Simplify(rules)
396  A3_corr := NewAdd()
397  A3m := NewMul()
398  A3m.Insert(NewConstant(0))
399  A3m.Insert(NewVar(0))
400  A3_corr.Insert(A3m)
401  A3_corr.Insert(NewVar(1))
402  if !A3_simp.AmISame(A3_corr) {
403    TEST.Fatalf("FAIL Add_A3: A3_simp != A3_corr  ~  %v -> %v  ==  %v", A3, A3_simp, A3_corr)
404  } else {
405    TEST.Logf("AddVar:  %v -> %v", A3, A3_simp)
406  }
407
408  // x + ( x + y )
409  A4 := NewAdd()
410  A4.Insert(NewVar(0))
411  A4b := NewAdd()
412  A4b.Insert(NewVar(0))
413  A4b.Insert(NewVar(1))
414  A4.Insert(A4b)
415  A4_simp := A4.Clone().Simplify(rules)
416  A4_corr := NewAdd()
417  A4m := NewMul()
418  A4m.Insert(NewConstant(0))
419  A4m.Insert(NewVar(0))
420  A4_corr.Insert(A4m)
421  A4_corr.Insert(NewVar(1))
422  if !A4_simp.AmISame(A4_corr) {
423    TEST.Fatalf("FAIL Add_A4: A4_simp != A4_corr  ~  %v -> %v  ==  %v", A4, A4_simp, A4_corr)
424  } else {
425    TEST.Logf("AddVar:  %v -> %v", A4, A4_simp)
426  }
427
428  //  F(x) +  F(x)
429  // x^2 + x^2
430  A5 := NewAdd()
431  A5.Insert(NewPowI(NewVar(0), 2))
432  A5.Insert(NewPowI(NewVar(0), 2))
433  A5_simp := A5.Clone().Simplify(rules)
434  A5_corr := NewMul()
435  A5_corr.Insert(NewConstant(0))
436  A5_corr.Insert(NewPowI(NewVar(0), 2))
437  if !A5_simp.AmISame(A5_corr) {
438    TEST.Fatalf("FAIL Add_A5: A5_simp != A5_corr  ~  %v -> %v  ==  %v", A5, A5_simp, A5_corr)
439  } else {
440    TEST.Logf("AddVar:  %v -> %v", A5, A5_simp)
441  }
442
443  // cF(x) + dF(x)
444  // cx^3.14 + dx^3.15
445  A6 := NewAdd()
446  A6m1 := NewMul()
447  A6m2 := NewMul()
448  A6m1.Insert(NewConstant(0))
449  A6m1.Insert(NewPowF(NewVar(0), 3.14))
450  A6m2.Insert(NewConstant(0))
451  A6m2.Insert(NewPowF(NewVar(0), 3.14))
452  A6.Insert(A6m1)
453  A6.Insert(A6m2)
454  A6_simp := A6.Clone().Simplify(rules)
455  A6_corr := NewMul()
456  A6_corr.Insert(NewConstant(0))
457  A6_corr.Insert(NewPowF(NewVar(0), 3.14))
458  if !A6_simp.AmISame(A6_corr) {
459    TEST.Fatalf("FAIL Add_A6: A6_simp != A6_corr  ~  %v -> %v  ==  %v", A6, A6_simp, A6_corr)
460  } else {
461    TEST.Logf("AddVar:  %v -> %v", A6, A6_simp)
462  }
463
464  // cF(x) +  F(x)
465  // cExp(x) + Exp(x)
466  A7 := NewAdd()
467  A7m1 := NewMul()
468  A7m1.Insert(NewConstant(0))
469  A7m1.Insert(NewExp(NewVar(0)))
470  A7.Insert(A7m1)
471  A7.Insert(NewExp(NewVar(0)))
472  A7_simp := A7.Clone().Simplify(rules)
473  A7_corr := NewMul()
474  A7_corr.Insert(NewConstant(0))
475  A7_corr.Insert(NewExp(NewVar(0)))
476  if !A7_simp.AmISame(A7_corr) {
477    TEST.Fatalf("FAIL Add_A7: A7_simp != A7_corr  ~  %v -> %v  ==  %v", A7, A7_simp, A7_corr)
478  } else {
479    TEST.Logf("AddVar:  %v -> %v", A7, A7_simp)
480  }
481
482  //  F(x) + cF(x)
483  //  sin(x) + csin(x)
484  A8 := NewAdd()
485  A8m2 := NewMul()
486  A8m2.Insert(NewConstant(0))
487  A8m2.Insert(NewSin(NewVar(0)))
488  A8.Insert(NewSin(NewVar(0)))
489  A8.Insert(A8m2)
490  A8_simp := A8.Clone().Simplify(rules)
491  A8_corr := NewMul()
492  A8_corr.Insert(NewConstant(0))
493  A8_corr.Insert(NewSin(NewVar(0)))
494  if !A8_simp.AmISame(A8_corr) {
495    TEST.Fatalf("FAIL Add_A8: A8_simp != A8_corr  ~  %v -> %v  ==  %v", A8, A8_simp, A8_corr)
496  } else {
497    TEST.Logf("AddVar:  %v -> %v", A8, A8_simp)
498  }
499
500  //  F(x) -  F(x)
501  // x - x
502  A9 := NewAdd()
503  A9.Insert(NewVar(0))
504  A9.Insert(NewNeg(NewVar(0)))
505  A9_simp := A9.Clone().Simplify(rules)
506  A9_corr := NewMul()
507  A9_corr.Insert(NewConstant(0))
508  A9_corr.Insert(NewVar(0))
509
510  if !A9_simp.AmISame(A9_corr) {
511    TEST.Fatalf("FAIL Add_A9: A9_simp != A9_corr  ~  %v -> %v  ==  %v", A9, A9_simp, A9_corr)
512  } else {
513    TEST.Logf("AddVar:  %v -> %v", A9, A9_simp)
514  }
515  // x + (-x+y)
516  A10 := NewAdd()
517  A10.Insert(NewVar(0))
518  A10b := NewAdd()
519  A10b.Insert(NewNeg(NewVar(0)))
520  A10b.Insert(NewVar(1))
521  A10.Insert(A10b)
522  A10_simp := A10.Clone().Simplify(rules)
523  A10_corr := NewAdd()
524  A10m := NewMul()
525  A10m.Insert(NewConstant(0))
526  A10m.Insert(NewVar(0))
527  A10_corr.Insert(A10m)
528  A10_corr.Insert(NewVar(1))
529  if !A10_simp.AmISame(A10_corr) {
530    TEST.Fatalf("FAIL Add_A10: A10_simp != A10_corr  ~  %v -> %v  ==  %v", A10, A10_simp, A10_corr)
531  } else {
532    TEST.Logf("AddVar:  %v -> %v", A10, A10_simp)
533  }
534  // x^2 - x^2
535  A11 := NewAdd()
536  A11.Insert(NewPowI(NewVar(0), 2))
537  A11.Insert(NewNeg(NewPowI(NewVar(0), 2)))
538  A11_simp := A11.Clone().Simplify(rules)
539  A11_corr := NewMul()
540  A11_corr.Insert(NewConstant(0))
541  A11_corr.Insert(NewPowI(NewVar(0), 2))
542  if !A11_simp.AmISame(A11_corr) {
543    TEST.Fatalf("FAIL Add_A11: A11_simp != A11_corr  ~  %v -> %v  ==  %v", A11, A11_simp, A11_corr)
544  } else {
545    TEST.Logf("AddVar:  %v -> %v", A11, A11_simp)
546  }
547
548  // cF(x) - dF(x)
549  // cx^3.14 - dx^3.15
550  A12 := NewAdd()
551  A12m1 := NewMul()
552  A12m2 := NewMul()
553  A12m1.Insert(NewConstant(0))
554  A12m1.Insert(NewPowF(NewVar(0), 3.14))
555  A12m2.Insert(NewConstant(0))
556  A12m2.Insert(NewPowF(NewVar(0), 3.14))
557  A12.Insert(A12m1)
558  A12.Insert(NewNeg(A12m2))
559  A12_simp := A12.Clone().Simplify(rules)
560  A12_corr := NewMul()
561  A12_corr.Insert(NewConstant(0))
562  A12_corr.Insert(NewPowF(NewVar(0), 3.14))
563  if !A12_simp.AmISame(A12_corr) {
564    TEST.Fatalf("FAIL Add_A12: A12_simp != A12_corr  ~  %v -> %v  ==  %v", A12, A12_simp, A12_corr)
565  } else {
566    TEST.Logf("AddVar:  %v -> %v", A12, A12_simp)
567  }
568
569  // cF(x) -  F(x)
570  // cExp(x) - Exp(x)
571  A13 := NewAdd()
572  A13m1 := NewMul()
573  A13m1.Insert(NewConstant(0))
574  A13m1.Insert(NewExp(NewVar(0)))
575  A13.Insert(A13m1)
576  A13.Insert(NewNeg(NewExp(NewVar(0))))
577  A13_simp := A13.Clone().Simplify(rules)
578  A13_corr := NewMul()
579  A13_corr.Insert(NewConstant(0))
580  A13_corr.Insert(NewExp(NewVar(0)))
581  if !A13_simp.AmISame(A13_corr) {
582    TEST.Fatalf("FAIL Add_A13: A13_simp != A13_corr  ~  %v -> %v  ==  %v", A13, A13_simp, A13_corr)
583  } else {
584    TEST.Logf("AddVar:  %v -> %v", A13, A13_simp)
585  }
586
587  //  F(x) - cF(x)
588  //  sin(x) - csin(x)
589  A14 := NewAdd()
590  A14m2 := NewMul()
591  A14m2.Insert(NewConstant(0))
592  A14m2.Insert(NewSin(NewVar(0)))
593  A14.Insert(NewSin(NewVar(0)))
594  A14.Insert(NewNeg(A14m2))
595  A14_simp := A14.Clone().Simplify(rules)
596  A14_corr := NewMul()
597  A14_corr.Insert(NewConstant(0))
598  A14_corr.Insert(NewSin(NewVar(0)))
599  if !A14_simp.AmISame(A14_corr) {
600    TEST.Fatalf("FAIL Add_A14: A14_simp != A14_corr  ~  %v -> %v  ==  %v", A14, A14_simp, A14_corr)
601  } else {
602    TEST.Logf("AddVar:  %v -> %v", A14, A14_simp)
603  }
604
605  // c0 + c1*x + c2*x*x*x
606  A15 := NewAdd()
607  A15.Insert(NewConstant(0))
608  A15m1 := NewMul()
609  A15m1.Insert(NewConstant(1))
610  A15m1.Insert(NewVar(0))
611  A15.Insert(A15m1)
612  A15m2 := NewMul()
613  A15m2.Insert(NewConstant(2))
614  A15m2.Insert(NewVar(0))
615  A15m2.Insert(NewVar(0))
616  A15m2.Insert(NewVar(0))
617  A15.Insert(A15m2)
618  A15_simp := A15.Clone().Simplify(rules)
619  A15_corr := NewAdd()
620  A15_corr.Insert(NewConstant(0))
621  A15_corrm1 := NewMul()
622  A15_corrm1.Insert(NewConstant(1))
623  A15_corrm1.Insert(NewVar(0))
624  A15_corr.Insert(A15_corrm1)
625  A15_corrm2 := NewMul()
626  A15_corrm2.Insert(NewConstant(2))
627  A15_corrm2.Insert(NewPowI(NewVar(0), 3))
628  A15_corr.Insert(A15_corrm2)
629  if !A15_simp.AmISame(A15_corr) {
630    TEST.Fatalf("FAIL Add_A15: A15_simp != A15_corr  ~  %v -> %v  ==  %v", A15, A15_simp, A15_corr)
631  } else {
632    TEST.Logf("AddVar:  %v -> %v", A15, A15_simp)
633  }
634
635  // X - (X+Y) ???
636
637}
638
639func Test_SimpMul(TEST *testing.T) {
640  fmt.Printf("Testing: Simplifying Mul      ")
641  var rules = DefaultRules()
642
643  mn := NewMul()
644  mn.Insert(nil)
645  mn_simp := mn.Clone().Simplify(rules)
646  if mn_simp != nil {
647    TEST.Fatalf("FAIL MulNil: mn_simp != nil  ~  %v -> %v", mn, mn_simp)
648  } else {
649    TEST.Logf("MulNil:  %v -> %v", mn, mn_simp)
650  }
651
652  ml := NewMul()
653  ml.Insert(NewNull())
654  ml_simp := ml.Clone().Simplify(rules)
655  if ml_simp != nil {
656    TEST.Fatalf("FAIL MulNull: nn_simp != Null  ~  %v -> %v", ml, ml_simp)
657  } else {
658    TEST.Logf("MulNull:  %v -> %v", ml, ml_simp)
659  }
660
661  mv := NewMul()
662  mv.Insert(NewVar(0))
663  mv_simp := mv.Clone().Simplify(rules)
664  mv_corr := NewVar(0)
665  if !mv_simp.AmISame(mv_corr) {
666    TEST.Fatalf("FAIL MulVar: mv_simp != mv_corr  ~  %v -> %v  ==  %v", mv, mv_simp, mv_corr)
667  } else {
668    TEST.Logf("MulVar:  %v -> %v", mv, mv_simp)
669  }
670
671  c := NewConstant(0)
672  mc := NewMul()
673  mc.Insert(c)
674  mc_simp := mc.Clone().Simplify(rules)
675  if !c.AmISame(mc_simp) {
676    TEST.Fatalf("FAIL MulConst: c != mc_simp  ~  %v -> %v", mc, mc_simp)
677  } else {
678    TEST.Logf("MulConst:  %v -> %v", mc, mc_simp)
679  }
680
681  cN := NewConstant(0)
682  mcN := NewMul()
683  mcN.Insert(cN)
684  mcN.Insert(NewConstant(1))
685  mcN.Insert(NewConstant(2))
686  mcN_simp := mcN.Clone().Simplify(rules)
687  if !cN.AmISame(mcN_simp) {
688    TEST.Fatalf("FAIL MulConst: c != mcN_simp  ~  %v -> %v", mcN, mcN_simp)
689  } else {
690    TEST.Logf("MulConst:  %v -> %v", mcN, mcN_simp)
691  }
692
693  mvN := NewMul()
694  mvN.Insert(NewVar(0))
695  mvN.Insert(NewVar(0))
696  mvN.Insert(NewVar(0))
697  mvN_simp := mvN.Clone().Simplify(rules)
698  mvN_corr := NewPowI(NewVar(0), 3)
699  if !mvN_simp.AmISame(mvN_corr) {
700    TEST.Fatalf("FAIL MulVar: mvN_simp != mvN_corr  ~  %v -> %v  ==  %v", mvN, mvN_simp, mvN_corr)
701  } else {
702    TEST.Logf("MulVar:  %v -> %v", mvN, mvN_simp)
703  }
704
705  mcvN := NewMul()
706  mcvN.Insert(NewConstant(0))
707  mcvN.Insert(NewConstant(1))
708  mcvN.Insert(NewConstant(2))
709  mcvN.Insert(NewVar(0))
710  mcvN.Insert(NewVar(0))
711  mcvN.Insert(NewVar(0))
712  mcvN_simp := mcvN.Clone().Simplify(rules)
713  mcvN_corr := NewMul()
714  mcvN_corr.Insert(NewConstant(0))
715  mcvN_corr.Insert(NewPowI(NewVar(0), 3))
716  if !mcvN_simp.AmISame(mcvN_corr) {
717    TEST.Fatalf("FAIL MulVar: mvN_simp != mvN_corr  ~  %v -> %v  ==  %v", mcvN, mcvN_simp, mcvN_corr)
718  } else {
719    TEST.Logf("MulVar:  %v -> %v", mcvN, mcvN_simp)
720  }
721
722  mcvNb := NewMul()
723  mcvNb.Insert(NewConstant(0))
724  mcvNb.Insert(NewConstant(1))
725  mcvNb.Insert(NewVar(0))
726  mcvNb.Insert(NewVar(0))
727  mcvNb.Insert(NewVar(0))
728  mcvNba := NewAdd()
729  mcvNba.Insert(NewVar(0))
730  mcvNbm := NewMul()
731  mcvNbm.Insert(NewConstant(-1))
732  mcvNbm.Insert(NewVar(0))
733  mcvNba.Insert(mcvNbm)
734  mcvNb.Insert(mcvNba)
735  mcvNb_simp := mcvNb.Clone().Simplify(rules)
736  mcvNb_corr := NewMul()
737  mcvNb_corr.Insert(NewConstant(0))
738  mcvNb_corr.Insert(NewPowI(NewVar(0), 4))
739  if !mcvNb_simp.AmISame(mcvNb_corr) {
740    TEST.Fatalf("FAIL MulVar: mvN_simp != mvN_corr  ~  %v -> %v  ==  %v", mcvNb, mcvNb_simp, mcvNb_corr)
741  } else {
742    TEST.Logf("MulVar:  %v -> %v", mcvNb, mcvNb_simp)
743  }
744
745  md := NewMul()
746  md.Insert(NewConstant(0))
747  mdiv := NewDiv(NewConstant(1), NewVar(0))
748  md.Insert(mdiv)
749  md_simp := md.Clone().Simplify(rules)
750  md_corr := NewDiv(NewConstant(0), NewVar(0))
751  if !md_simp.AmISame(md_corr) {
752    TEST.Fatalf("FAIL MulVar: md_simp != md_corr  ~  %v -> %v  ==  %v", md, md_simp, md_corr)
753  } else {
754    TEST.Logf("MulVar:  %v -> %v", md, md_simp)
755  }
756
757  md2 := NewMul()
758  md2.Insert(NewConstant(0))
759  md2m := NewMul()
760  md2m.Insert(NewConstant(1))
761  md2m.Insert(NewVar(0))
762  md2div := NewDiv(md2m, NewVar(0))
763  md2.Insert(md2div)
764  md2_corr := NewConstant(0)
765  md2_simp := md2div.Clone().Simplify(rules)
766  if !md2_simp.AmISame(md2_corr) {
767    TEST.Fatalf("FAIL MulVar: md2_simp != md2_corr  ~  %v -> %v  ==  %v", md2, md2_simp, md2_corr)
768  } else {
769    TEST.Logf("MulVar:  %v -> %v", md2, md2_simp)
770  }
771
772}
773
774func Test_Damd(TEST *testing.T) {
775  fmt.Printf("Testing: Damd Simps      \n")
776  var rules = DefaultRules()
777  vnames := []string{"x", "y", "z"}
778
779  f1 := parse("2*x^2* x^3", vnames)
780  fmt.Printf("f1 orig: %v\n", f1)
781  f1s := f1.Clone().Simplify(rules)
782  fmt.Printf("f1 simp: %v\n\n", f1s)
783
784  f2 := parse("2*x^-3 * x^2", vnames)
785  fmt.Printf("f2 orig: %v\n", f2)
786  f2s := f2.Clone().Simplify(rules)
787  fmt.Printf("f2 simp: %v\n\n", f2s)
788
789}
790
791func Test_ConstantF(TEST *testing.T) {
792  fmt.Printf("Testing: ConstantF Simps\n---------------------\n\n")
793  var rules = DefaultRules()
794  rules.ConvertConsts = false
795
796  vnames := []string{"x", "y", "z"}
797
798  f1 := parse("x + x", vnames)
799  fmt.Printf("f1 orig: %v\n", f1)
800  f1s := f1.Clone().Simplify(rules)
801  fmt.Printf("f1 simp: %v\n\n", f1s)
802
803  f2 := parse("2*x + x", vnames)
804  fmt.Printf("f2 orig: %v\n", f2)
805  f2s := f2.Clone().Simplify(rules)
806  fmt.Printf("f2 simp: %v\n\n", f2s)
807
808  f3 := parse("x + 2*x", vnames)
809  fmt.Printf("f3 orig: %v\n", f3)
810  f3s := f3.Clone().Simplify(rules)
811  fmt.Printf("f3 simp: %v\n\n", f3s)
812
813  f4 := parse("2*x + 3*x", vnames)
814  fmt.Printf("f4 orig: %v\n", f4)
815  f4s := f4.Clone().Simplify(rules)
816  fmt.Printf("f4 simp: %v\n\n", f4s)
817
818  f5 := parse("x - x", vnames)
819  fmt.Printf("f5 orig: %v\n", f5)
820  f5s := f5.Clone().Simplify(rules)
821  fmt.Printf("f5 simp: %v\n\n", f5s)
822
823  f6 := parse("2*x - x", vnames)
824  fmt.Printf("f6 orig: %v\n", f6)
825  f6s := f6.Clone().Simplify(rules)
826  fmt.Printf("f6 simp: %v\n\n", f6s)
827
828  f7 := parse("x - 2*x", vnames)
829  fmt.Printf("f7 orig: %v\n", f7)
830  f7s := f7.Clone().Simplify(rules)
831  fmt.Printf("f7 simp: %v\n\n", f7s)
832
833  f8 := parse("2*x - 3*x", vnames)
834  fmt.Printf("f8 orig: %v\n", f8)
835  f8s := f8.Clone().Simplify(rules)
836  fmt.Printf("f8 simp: %v\n\n", f8s)
837
838  f9 := parse("5*x - 2*x", vnames)
839  fmt.Printf("f9 orig: %v\n", f9)
840  f9s := f9.Clone().Simplify(rules)
841  fmt.Printf("f9 simp: %v\n\n", f9s)
842
843  /*
844    XX := parse("x + x", vnames)
845    fmt.Printf("XX orig: %v\n", XX)
846    XXs := XX.Clone().Simplify(rules)
847    fmt.Printf("XX simp: %v\n\n", XXs)
848  */
849}
850
851func Test_Div(TEST *testing.T) {
852  fmt.Printf("Testing: Div Simps\n---------------------\n\n")
853  var rules = DefaultRules()
854  vnames := []string{"x", "y", "z"}
855  rules.ConvertConsts = false
856
857  /*****************************************/
858  /*****************************************/
859
860  f1 := parse("x / x", vnames)
861  f1_corr := NewConstant(-1)
862  f1_simp := f1.Clone().Simplify(rules)
863  if !f1_simp.AmISame(f1_corr) {
864    TEST.Fatalf("FAIL Div: f1_simp != f1_corr  ~  %v -> %v  ==  %v", f1, f1_simp, f1_corr)
865  } else {
866    fmt.Printf("Div:  %v -> %v", f1, f1_simp)
867    TEST.Logf("Div:  %v -> %v", f1, f1_simp)
868  }
869
870  f2 := parse("( 2 * x ) / x", vnames)
871  f2_corr := NewConstant(-1)
872  f2_simp := f2.Clone().Simplify(rules)
873  if !f2_simp.AmISame(f2_corr) {
874    TEST.Fatalf("FAIL Div: f2_simp != f2_corr  ~  %v -> %v  ==  %v", f2, f2_simp, f2_corr)
875  } else {
876    fmt.Printf("Div:  %v -> %v", f2, f2_simp)
877    TEST.Logf("Div:  %v -> %v", f2, f2_simp)
878  }
879
880  f3 := parse("x^2 / x", vnames)
881  f3_corr := parse("x", vnames)
882  f3_simp := f3.Clone().Simplify(rules)
883  if !f3_simp.AmISame(f3_corr) {
884    TEST.Fatalf("FAIL Div: f3_simp != f3_corr  ~  %v -> %v  ==  %v", f3, f3_simp, f3_corr)
885  } else {
886    fmt.Printf("Div:  %v -> %v", f3, f3_simp)
887    TEST.Logf("Div:  %v -> %v", f3, f3_simp)
888  }
889
890  f4 := parse("x^3 / x^2", vnames)
891  f4_corr := parse("x", vnames)
892  f4_simp := f4.Clone().Simplify(rules)
893  if !f4_simp.AmISame(f4_corr) {
894    TEST.Fatalf("FAIL Div: f4_simp != f4_corr  ~  %v -> %v  ==  %v", f4, f4_simp, f4_corr)
895  } else {
896    fmt.Printf("Div:  %v -> %v", f4, f4_simp)
897    TEST.Logf("Div:  %v -> %v", f4, f4_simp)
898  }
899
900  f5 := parse("x^4 / x^2", vnames)
901  f5_corr := parse("x^2", vnames)
902  f5_simp := f5.Clone().Simplify(rules)
903  if !f5_simp.AmISame(f5_corr) {
904    TEST.Fatalf("FAIL Div: f5_simp != f5_corr  ~  %v -> %v  ==  %v", f5, f5_simp, f5_corr)
905  } else {
906    fmt.Printf("Div:  %v -> %v", f5, f5_simp)
907    TEST.Logf("Div:  %v -> %v", f5, f5_simp)
908  }
909
910  f6 := parse("x / x^2", vnames)
911  f6_corr := NewDiv(NewConstant(-1), NewVar(0))
912  f6_simp := f6.Clone().Simplify(rules)
913  if !f6_simp.AmISame(f6_corr) {
914    TEST.Fatalf("FAIL Div: f6_simp != f6_corr  ~  %v -> %v  ==  %v", f6, f6_simp, f6_corr)
915  } else {
916    fmt.Printf("Div:  %v -> %v", f6, f6_simp)
917    TEST.Logf("Div:  %v -> %v", f6, f6_simp)
918  }
919
920  f7 := parse("x^2 / x^3", vnames)
921  f7_corr := NewDiv(NewConstant(-1), NewVar(0))
922  f7_simp := f7.Clone().Simplify(rules)
923  if !f7_simp.AmISame(f7_corr) {
924    TEST.Fatalf("FAIL Div: f7_simp != f7_corr  ~  %v -> %v  ==  %v", f7, f7_simp, f7_corr)
925  } else {
926    fmt.Printf("Div:  %v -> %v", f7, f7_simp)
927    TEST.Logf("Div:  %v -> %v", f7, f7_simp)
928  }
929
930  f8 := parse("x^2 / x^4", vnames)
931  f8_corr := NewDiv(NewConstant(-1), NewPowI(NewVar(0), 2))
932  f8_simp := f8.Clone().Simplify(rules)
933  if !f8_simp.AmISame(f8_corr) {
934    TEST.Fatalf("FAIL Div: f8_simp != f8_corr  ~  %v -> %v  ==  %v", f8, f8_simp, f8_corr)
935  } else {
936    fmt.Printf("Div:  %v -> %v", f8, f8_simp)
937    TEST.Logf("Div:  %v -> %v", f8, f8_simp)
938  }
939
940  /*****************************************/
941  /*****************************************/
942
943  f1_n := parse("(y * x) / x", vnames)
944  f1_n_corr := NewVar(1)
945  f1_n_simp := f1_n.Clone().Simplify(rules)
946  if !f1_n_simp.AmISame(f1_n_corr) {
947    TEST.Fatalf("FAIL Div: f1_n_simp != f1_n_corr  ~  %v -> %v  ==  %v", f1_n, f1_n_simp, f1_n_corr)
948  } else {
949    fmt.Printf("Div:  %v -> %v", f1_n, f1_n_simp)
950    TEST.Logf("Div:  %v -> %v", f1_n, f1_n_simp)
951  }
952
953  f2_n := parse("( 2 * x * y ) / x", vnames)
954  f2_n_corr := parse("2 * y", vnames)
955  f2_n_simp := f2_n.Clone().Simplify(rules)
956  if !f2_n_simp.AmISame(f2_n_corr) {
957    TEST.Fatalf("FAIL Div: f2_n_simp != f2_n_corr  ~  %v -> %v  ==  %v", f2_n, f2_n_simp, f2_n_corr)
958  } else {
959    fmt.Printf("Div:  %v -> %v", f2_n, f2_n_simp)
960    TEST.Logf("Div:  %v -> %v", f2_n, f2_n_simp)
961  }
962
963  f3_n := parse("( y * x^2 ) / x", vnames)
964  f3_n_corr := parse("y * x", vnames)
965  f3_n_simp := f3_n.Clone().Simplify(rules)
966  if !f3_n_simp.AmISame(f3_n_corr) {
967    TEST.Fatalf("FAIL Div: f3_n_simp != f3_n_corr  ~  %v -> %v  ==  %v", f3_n, f3_n_simp, f3_n_corr)
968  } else {
969    fmt.Printf("Div:  %v -> %v", f3_n, f3_n_simp)
970    TEST.Logf("Div:  %v -> %v", f3_n, f3_n_simp)
971  }
972
973  f4_n := parse("(y * x^3) / x^2", vnames)
974  f4_n_corr := parse("y * x", vnames)
975  f4_n_simp := f4_n.Clone().Simplify(rules)
976  if !f4_n_simp.AmISame(f4_n_corr) {
977    TEST.Fatalf("FAIL Div: f4_n_simp != f4_n_corr  ~  %v -> %v  ==  %v", f4_n, f4_n_simp, f4_n_corr)
978  } else {
979    fmt.Printf("Div:  %v -> %v", f4_n, f4_n_simp)
980    TEST.Logf("Div:  %v -> %v", f4_n, f4_n_simp)
981  }
982
983  f5_n := parse("(y * x^4) / x^2", vnames)
984  f5_n_corr := parse("y * x^2", vnames)
985  f5_n_simp := f5_n.Clone().Simplify(rules)
986  if !f5_n_simp.AmISame(f5_n_corr) {
987    TEST.Fatalf("FAIL Div: f5_n_simp != f5_n_corr  ~  %v -> %v  ==  %v", f5_n, f5_n_simp, f5_n_corr)
988  } else {
989    fmt.Printf("Div:  %v -> %v", f5_n, f5_n_simp)
990    TEST.Logf("Div:  %v -> %v", f5_n, f5_n_simp)
991  }
992
993  f6_n := parse("(y * x)/ x^2", vnames)
994  f6_n_corr := parse("y / x", vnames)
995  f6_n_simp := f6_n.Clone().Simplify(rules)
996  if !f6_n_simp.AmISame(f6_n_corr) {
997    TEST.Fatalf("FAIL Div: f6_n_simp != f6_n_corr  ~  %v -> %v  ==  %v", f6_n, f6_n_simp, f6_n_corr)
998  } else {
999    fmt.Printf("Div:  %v -> %v", f6_n, f6_n_simp)
1000    TEST.Logf("Div:  %v -> %v", f6_n, f6_n_simp)
1001  }
1002
1003  f7_n := parse("(y * x^2) / x^3", vnames)
1004  f7_n_corr := parse("y / x", vnames)
1005  f7_n_simp := f7_n.Clone().Simplify(rules)
1006  if !f7_n_simp.AmISame(f7_n_corr) {
1007    TEST.Fatalf("FAIL Div: f7_n_simp != f7_n_corr  ~  %v -> %v  ==  %v", f7_n, f7_n_simp, f7_n_corr)
1008  } else {
1009    fmt.Printf("Div:  %v -> %v", f7_n, f7_n_simp)
1010    TEST.Logf("Div:  %v -> %v", f7_n, f7_n_simp)
1011  }
1012
1013  f8_n := parse("(y * x^2) / x^4", vnames)
1014  f8_n_corr := parse("y / x^2", vnames)
1015  f8_n_simp := f8_n.Clone().Simplify(rules)
1016  if !f8_n_simp.AmISame(f8_n_corr) {
1017    TEST.Fatalf("FAIL Div: f8_n_simp != f8_n_corr  ~  %v -> %v  ==  %v", f8_n, f8_n_simp, f8_n_corr)
1018  } else {
1019    fmt.Printf("Div:  %v -> %v", f8_n, f8_n_simp)
1020    TEST.Logf("Div:  %v -> %v", f8_n, f8_n_simp)
1021  }
1022
1023  /*****************************************/
1024  /*****************************************/
1025
1026  f1_d := parse("x / (x * y)", vnames)
1027  f1_d_corr := NewDiv(NewConstant(-1), NewVar(1))
1028  f1_d_simp := f1_d.Clone().Simplify(rules)
1029  if !f1_d_simp.AmISame(f1_d_corr) {
1030    TEST.Fatalf("FAIL Div: f1_d_simp != f1_d_corr  ~  %v -> %v  ==  %v", f1_d, f1_d_simp, f1_d_corr)
1031  } else {
1032    fmt.Printf("Div:  %v -> %v", f1_d, f1_d_simp)
1033    TEST.Logf("Div:  %v -> %v", f1_d, f1_d_simp)
1034  }
1035
1036  f2_d := parse("( 2 * x ) / (x * y)", vnames)
1037  f2_d_corr := parse("2 / y", vnames)
1038  f2_d_simp := f2_d.Clone().Simplify(rules)
1039  if !f2_d_simp.AmISame(f2_d_corr) {
1040    TEST.Fatalf("FAIL Div: f2_d_simp != f2_d_corr  ~  %v -> %v  ==  %v", f2_d, f2_d_simp, f2_d_corr)
1041  } else {
1042    fmt.Printf("Div:  %v -> %v", f2_d, f2_d_simp)
1043    TEST.Logf("Div:  %v -> %v", f2_d, f2_d_simp)
1044  }
1045
1046  f3_d := parse("x^2 / (x * y)", vnames)
1047  f3_d_corr := parse("x / y", vnames)
1048  f3_d_simp := f3_d.Clone().Simplify(rules)
1049  if !f3_d_simp.AmISame(f3_d_corr) {
1050    TEST.Fatalf("FAIL Div: f3_d_simp != f3_d_corr  ~  %v -> %v  ==  %v", f3_d, f3_d_simp, f3_d_corr)
1051  } else {
1052    fmt.Printf("Div:  %v -> %v", f3_d, f3_d_simp)
1053    TEST.Logf("Div:  %v -> %v", f3_d, f3_d_simp)
1054  }
1055
1056  f4_d := parse("x^3 / (x^2 * y)", vnames)
1057  f4_d_corr := parse("x / y", vnames)
1058  f4_d_simp := f4_d.Clone().Simplify(rules)
1059  if !f4_d_simp.AmISame(f4_d_corr) {
1060    TEST.Fatalf("FAIL Div: f4_d_simp != f4_d_corr  ~  %v -> %v  ==  %v", f4_d, f4_d_simp, f4_d_corr)
1061  } else {
1062    fmt.Printf("Div:  %v -> %v", f4_d, f4_d_simp)
1063    TEST.Logf("Div:  %v -> %v", f4_d, f4_d_simp)
1064  }
1065
1066  f5_d := parse("x^4 / (x^2 * y)", vnames)
1067  f5_d_corr := parse("x^2 / y", vnames)
1068  f5_d_simp := f5_d.Clone().Simplify(rules)
1069  if !f5_d_simp.AmISame(f5_d_corr) {
1070    TEST.Fatalf("FAIL Div: f5_d_simp != f5_d_corr  ~  %v -> %v  ==  %v", f5_d, f5_d_simp, f5_d_corr)
1071  } else {
1072    fmt.Printf("Div:  %v -> %v", f5_d, f5_d_simp)
1073    TEST.Logf("Div:  %v -> %v", f5_d, f5_d_simp)
1074  }
1075
1076  f6_d := parse("x / (x^2 * y)", vnames)
1077  f6_d_denom := parse("x * y", vnames)
1078  f6_d_corr := NewDiv(NewConstant(-1), f6_d_denom)
1079  f6_d_simp := f6_d.Clone().Simplify(rules)
1080  if !f6_d_simp.AmISame(f6_d_corr) {
1081    TEST.Fatalf("FAIL Div: f6_d_simp != f6_d_corr  ~  %v -> %v  ==  %v", f6_d, f6_d_simp, f6_d_corr)
1082  } else {
1083    fmt.Printf("Div:  %v -> %v", f6_d, f6_d_simp)
1084    TEST.Logf("Div:  %v -> %v", f6_d, f6_d_simp)
1085  }
1086
1087  f7_d := parse("x^2 / (x^3 * y)", vnames)
1088  f7_d_denom := parse("x * y", vnames)
1089  f7_d_corr := NewDiv(NewConstant(-1), f7_d_denom)
1090  f7_d_simp := f7_d.Clone().Simplify(rules)
1091  if !f7_d_simp.AmISame(f7_d_corr) {
1092    TEST.Fatalf("FAIL Div: f7_d_simp != f7_d_corr  ~  %v -> %v  ==  %v", f7_d, f7_d_simp, f7_d_corr)
1093  } else {
1094    fmt.Printf("Div:  %v -> %v", f7_d, f7_d_simp)
1095    TEST.Logf("Div:  %v -> %v", f7_d, f7_d_simp)
1096  }
1097
1098  f8_d := parse("x^2 / (x^4 * y)", vnames)
1099  f8_d_denom := parse("x^2 * y", vnames)
1100  f8_d_corr := NewDiv(NewConstant(-1), f8_d_denom)
1101  f8_d_simp := f8_d.Clone().Simplify(rules)
1102  if !f8_d_simp.AmISame(f8_d_corr) {
1103    TEST.Fatalf("FAIL Div: f8_d_simp != f8_d_corr  ~  %v -> %v  ==  %v", f8_d, f8_d_simp, f8_d_corr)
1104  } else {
1105    fmt.Printf("Div:  %v -> %v", f8_d, f8_d_simp)
1106    TEST.Logf("Div:  %v -> %v", f8_d, f8_d_simp)
1107  }
1108
1109  /*****************************************/
1110  /*****************************************/
1111
1112  f1_b := parse("(x * y) / (x * y)", vnames)
1113  f1_b_corr := NewConstant(-1)
1114  f1_b_simp := f1_b.Clone().Simplify(rules)
1115  if !f1_b_simp.AmISame(f1_b_corr) {
1116    TEST.Fatalf("FAIL Div: f1_b_simp != f1_b_corr  ~  %v -> %v  ==  %v", f1_b, f1_b_simp, f1_b_corr)
1117  } else {
1118    fmt.Printf("Div:  %v -> %v", f1_b, f1_b_simp)
1119    TEST.Logf("Div:  %v -> %v", f1_b, f1_b_simp)
1120  }
1121
1122  f2_b := parse("( 2 * x * y ) / (x * y)", vnames)
1123  f2_b_corr := parse("2", vnames)
1124  f2_b_simp := f2_b.Clone().Simplify(rules)
1125  if !f2_b_simp.AmISame(f2_b_corr) {
1126    TEST.Fatalf("FAIL Div: f2_b_simp != f2_b_corr  ~  %v -> %v  ==  %v", f2_b, f2_b_simp, f2_b_corr)
1127  } else {
1128    fmt.Printf("Div:  %v -> %v", f2_b, f2_b_simp)
1129    TEST.Logf("Div:  %v -> %v", f2_b, f2_b_simp)
1130  }
1131
1132  f3_b := parse("(x^2 * y) / (x * y)", vnames)
1133  f3_b_corr := parse("x", vnames)
1134  f3_b_simp := f3_b.Clone().Simplify(rules)
1135  if !f3_b_simp.AmISame(f3_b_corr) {
1136    TEST.Fatalf("FAIL Div: f3_b_simp != f3_b_corr  ~  %v -> %v  ==  %v", f3_b, f3_b_simp, f3_b_corr)
1137  } else {
1138    fmt.Printf("Div:  %v -> %v", f3_b, f3_b_simp)
1139    TEST.Logf("Div:  %v -> %v", f3_b, f3_b_simp)
1140  }
1141
1142  f4_b := parse("(x^3 * y) / (x^2 * y)", vnames)
1143  f4_b_corr := parse("x", vnames)
1144  f4_b_simp := f4_b.Clone().Simplify(rules)
1145  if !f4_b_simp.AmISame(f4_b_corr) {
1146    TEST.Fatalf("FAIL Div: f4_b_simp != f4_b_corr  ~  %v -> %v  ==  %v", f4_b, f4_b_simp, f4_b_corr)
1147  } else {
1148    fmt.Printf("Div:  %v -> %v", f4_b, f4_b_simp)
1149    TEST.Logf("Div:  %v -> %v", f4_b, f4_b_simp)
1150  }
1151
1152  f5_b := parse("(x^4 * y) / (x^2 * y)", vnames)
1153  f5_b_corr := parse("x^2", vnames)
1154  f5_b_simp := f5_b.Clone().Simplify(rules)
1155  if !f5_b_simp.AmISame(f5_b_corr) {
1156    TEST.Fatalf("FAIL Div: f5_b_simp != f5_b_corr  ~  %v -> %v  ==  %v", f5_b, f5_b_simp, f5_b_corr)
1157  } else {
1158    fmt.Printf("Div:  %v -> %v", f5_b, f5_b_simp)
1159    TEST.Logf("Div:  %v -> %v", f5_b, f5_b_simp)
1160  }
1161
1162  f6_b := parse("(x * y) / (x^2 * y)", vnames)
1163  f6_b_corr := NewDiv(NewConstant(-1), NewVar(0))
1164  f6_b_simp := f6_b.Clone().Simplify(rules)
1165  if !f6_b_simp.AmISame(f6_b_corr) {
1166    TEST.Fatalf("FAIL Div: f6_b_simp != f6_b_corr  ~  %v -> %v  ==  %v", f6_b, f6_b_simp, f6_b_corr)
1167  } else {
1168    fmt.Printf("Div:  %v -> %v", f6_b, f6_b_simp)
1169    TEST.Logf("Div:  %v -> %v", f6_b, f6_b_simp)
1170  }
1171
1172  f7_b := parse("(x^2 * y) / (x^3 * y)", vnames)
1173  f7_b_corr := NewDiv(NewConstant(-1), NewVar(0))
1174  f7_b_simp := f7_b.Clone().Simplify(rules)
1175  if !f7_b_simp.AmISame(f7_b_corr) {
1176    TEST.Fatalf("FAIL Div: f7_b_simp != f7_b_corr  ~  %v -> %v  ==  %v", f7_b, f7_b_simp, f7_b_corr)
1177  } else {
1178    fmt.Printf("Div:  %v -> %v", f7_b, f7_b_simp)
1179    TEST.Logf("Div:  %v -> %v", f7_b, f7_b_simp)
1180  }
1181
1182  f8_b := parse("(x^2 * y) / (x^4 * y)", vnames)
1183  f8_b_corr := NewDiv(NewConstant(-1), NewPowI(NewVar(0), 2))
1184  f8_b_simp := f8_b.Clone().Simplify(rules)
1185  if !f8_b_simp.AmISame(f8_b_corr) {
1186    TEST.Fatalf("FAIL Div: f8_b_simp != f8_b_corr  ~  %v -> %v  ==  %v", f8_b, f8_b_simp, f8_b_corr)
1187  } else {
1188    fmt.Printf("Div:  %v -> %v", f8_b, f8_b_simp)
1189    TEST.Logf("Div:  %v -> %v", f8_b, f8_b_simp)
1190  }
1191
1192  /*****************************************/
1193  /*****************************************/
1194
1195  f1_B := parse("(x * y) / (x * z)", vnames)
1196  f1_B_corr := parse("y / z", vnames)
1197  f1_B_simp := f1_B.Clone().Simplify(rules)
1198  if !f1_B_simp.AmISame(f1_B_corr) {
1199    TEST.Fatalf("FAIL Div: f1_B_simp != f1_B_corr  ~  %v -> %v  ==  %v", f1_B, f1_B_simp, f1_B_corr)
1200  } else {
1201    fmt.Printf("Div:  %v -> %v", f1_B, f1_B_simp)
1202    TEST.Logf("Div:  %v -> %v", f1_B, f1_B_simp)
1203  }
1204
1205  f2_B := parse("( 2 * x * y) / (x * z)", vnames)
1206  f2_B_corr := parse("(2 * y) / z", vnames)
1207  f2_B_simp := f2_B.Clone().Simplify(rules)
1208  if !f2_B_simp.AmISame(f2_B_corr) {
1209    TEST.Fatalf("FAIL Div: f2_B_simp != f2_B_corr  ~  %v -> %v  ==  %v", f2_B, f2_B_simp, f2_B_corr)
1210  } else {
1211    fmt.Printf("Div:  %v -> %v", f2_B, f2_B_simp)
1212    TEST.Logf("Div:  %v -> %v", f2_B, f2_B_simp)
1213  }
1214
1215  f3_B := parse("(x^2 * y) / (x * z)", vnames)
1216  f3_B_corr := parse("(x * y) / z", vnames)
1217  f3_B_simp := f3_B.Clone().Simplify(rules)
1218  if !f3_B_simp.AmISame(f3_B_corr) {
1219    TEST.Fatalf("FAIL Div: f3_B_simp != f3_B_corr  ~  %v -> %v  ==  %v", f3_B, f3_B_simp, f3_B_corr)
1220  } else {
1221    fmt.Printf("Div:  %v -> %v", f3_B, f3_B_simp)
1222    TEST.Logf("Div:  %v -> %v", f3_B, f3_B_simp)
1223  }
1224
1225  f4_B := parse("(x^3 * y) / (x^2 * z)", vnames)
1226  f4_B_corr := parse("(x * y) / z", vnames)
1227  f4_B_simp := f4_B.Clone().Simplify(rules)
1228  if !f4_B_simp.AmISame(f4_B_corr) {
1229    TEST.Fatalf("FAIL Div: f4_B_simp != f4_B_corr  ~  %v -> %v  ==  %v", f4_B, f4_B_simp, f4_B_corr)
1230  } else {
1231    fmt.Printf("Div:  %v -> %v", f4_B, f4_B_simp)
1232    TEST.Logf("Div:  %v -> %v", f4_B, f4_B_simp)
1233  }
1234
1235  f5_B := parse("(x^4 * y) / (x^2 * z)", vnames)
1236  f5_B_corr := parse("(x^2 * y) / z", vnames)
1237  f5_B_simp := f5_B.Clone().Simplify(rules)
1238  if !f5_B_simp.AmISame(f5_B_corr) {
1239    TEST.Fatalf("FAIL Div: f5_B_simp != f5_B_corr  ~  %v -> %v  ==  %v", f5_B, f5_B_simp, f5_B_corr)
1240  } else {
1241    fmt.Printf("Div:  %v -> %v", f5_B, f5_B_simp)
1242    TEST.Logf("Div:  %v -> %v", f5_B, f5_B_simp)
1243  }
1244
1245  f6_B := parse("(x * y) / (x^2 * z)", vnames)
1246  f6_B_corr := parse("y / (x * z)", vnames)
1247  f6_B_simp := f6_B.Clone().Simplify(rules)
1248  if !f6_B_simp.AmISame(f6_B_corr) {
1249    TEST.Fatalf("FAIL Div: f6_B_simp != f6_B_corr  ~  %v -> %v  ==  %v", f6_B, f6_B_simp, f6_B_corr)
1250  } else {
1251    fmt.Printf("Div:  %v -> %v", f6_B, f6_B_simp)
1252    TEST.Logf("Div:  %v -> %v", f6_B, f6_B_simp)
1253  }
1254
1255  f7_B := parse("(x^2 * y) / (x^3 * z)", vnames)
1256  f7_B_corr := parse("y / (x * z)", vnames)
1257  f7_B_simp := f7_B.Clone().Simplify(rules)
1258  if !f7_B_simp.AmISame(f7_B_corr) {
1259    TEST.Fatalf("FAIL Div: f7_B_simp != f7_B_corr  ~  %v -> %v  ==  %v", f7_B, f7_B_simp, f7_B_corr)
1260  } else {
1261    fmt.Printf("Div:  %v -> %v", f7_B, f7_B_simp)
1262    TEST.Logf("Div:  %v -> %v", f7_B, f7_B_simp)
1263  }
1264
1265  f8_B := parse("(x^2 * y) / (x^4 * z)", vnames)
1266  f8_B_corr := parse("y / (x^2 * z)", vnames)
1267  f8_B_simp := f8_B.Clone().Simplify(rules)
1268  if !f8_B_simp.AmISame(f8_B_corr) {
1269    TEST.Fatalf("FAIL Div: f8_B_simp != f8_B_corr  ~  %v -> %v  ==  %v", f8_B, f8_B_simp, f8_B_corr)
1270  } else {
1271    fmt.Printf("Div:  %v -> %v", f8_B, f8_B_simp)
1272    TEST.Logf("Div:  %v -> %v", f8_B, f8_B_simp)
1273  }
1274
1275  f1_R := parse("( {-1.004803*(x)^2}/{x} + {0.010163*(x)^12}/{x} + 0.995197*x )", vnames)
1276  f1_R_corr := parse("2 + (3 * x^4)", vnames)
1277  f1_R_simp := f1_R.Clone().Simplify(rules)
1278  if !f1_R_simp.AmISame(f1_R_corr) {
1279    TEST.Fatalf("FAIL Div: f1_R_simp != f1_R_corr  ~  %v -> %v  ==  %v", f1_R, f1_R_simp, f1_R_corr)
1280  } else {
1281    fmt.Printf("Div:  %v -> %v", f1_R, f1_R_simp)
1282    TEST.Logf("Div:  %v -> %v", f1_R, f1_R_simp)
1283  }
1284
1285  fmt.Println()
1286}
1287
1288// serial := make([]int, 0, 64)
1289// serial = e.Serial(serial)
1290// fmt.Printf("\nserial: %v\n", serial)
Note: See TracBrowser for help on using the repository browser.