source: branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/src/go-symexpr/compare.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: 14.2 KB
Line 
1package symexpr
2
3import (
4  "sort"
5
6  // "fmt"
7)
8
9func (n *Time) AmILess(r Expr) bool       { return TIME < r.ExprType() }
10func (n *Time) AmIEqual(r Expr) bool      { return r.ExprType() == TIME }
11func (n *Time) AmISame(r Expr) bool       { return r.ExprType() == TIME }
12func (n *Time) AmIAlmostSame(r Expr) bool { return r.ExprType() == TIME }
13func (n *Time) Sort()                     { return }
14
15func (v *Var) AmILess(r Expr) bool {
16  if VAR < r.ExprType() {
17    return true
18  }
19  if VAR > r.ExprType() {
20    return false
21  }
22  return v.P < r.(*Var).P
23}
24func (v *Var) AmIEqual(r Expr) bool      { return r.ExprType() == VAR && r.(*Var).P == v.P }
25func (v *Var) AmISame(r Expr) bool       { return r.ExprType() == VAR && r.(*Var).P == v.P }
26func (v *Var) AmIAlmostSame(r Expr) bool { return r.ExprType() == VAR && r.(*Var).P == v.P }
27func (v *Var) Sort()                     { return }
28
29func (c *Constant) AmILess(r Expr) bool {
30  if CONSTANT < r.ExprType() {
31    return true
32  }
33  if CONSTANT > r.ExprType() {
34    return false
35  }
36  return c.P < r.(*Constant).P
37}
38func (c *Constant) AmIEqual(r Expr) bool      { return r.ExprType() == CONSTANT && r.(*Constant).P == c.P }
39func (c *Constant) AmISame(r Expr) bool       { return r.ExprType() == CONSTANT }
40func (c *Constant) AmIAlmostSame(r Expr) bool { return r.ExprType() == CONSTANT }
41func (c *Constant) Sort()                     { return }
42
43func (c *ConstantF) AmILess(r Expr) bool {
44  if CONSTANTF < r.ExprType() {
45    return true
46  }
47  if CONSTANTF > r.ExprType() {
48    return false
49  }
50  return c.F < r.(*ConstantF).F
51}
52func (c *ConstantF) AmIEqual(r Expr) bool {
53  return r.ExprType() == CONSTANTF && r.(*ConstantF).F == c.F
54}
55func (c *ConstantF) AmISame(r Expr) bool       { return r.ExprType() == CONSTANTF }
56func (c *ConstantF) AmIAlmostSame(r Expr) bool { return r.ExprType() == CONSTANTF }
57func (c *ConstantF) Sort()                     { return }
58
59func (s *System) AmILess(r Expr) bool {
60  if SYSTEM < r.ExprType() {
61    return true
62  }
63  if SYSTEM > r.ExprType() {
64    return false
65  }
66  return s.P < r.(*System).P
67}
68func (s *System) AmIEqual(r Expr) bool      { return r.ExprType() == SYSTEM && r.(*System).P == s.P }
69func (s *System) AmISame(r Expr) bool       { return r.ExprType() == SYSTEM && r.(*System).P == s.P }
70func (s *System) AmIAlmostSame(r Expr) bool { return r.ExprType() == SYSTEM && r.(*System).P == s.P }
71func (s *System) Sort()                     { return }
72
73func (u *Neg) AmILess(r Expr) bool {
74  if NEG < r.ExprType() {
75    return true
76  }
77  if NEG > r.ExprType() {
78    return false
79  }
80  return u.C.AmILess(r.(*Neg).C)
81}
82func (u *Neg) AmIEqual(r Expr) bool { return r.ExprType() == NEG && u.C.AmIEqual(r.(*Neg).C) }
83func (u *Neg) AmISame(r Expr) bool  { return r.ExprType() == NEG && u.C.AmISame(r.(*Neg).C) }
84func (u *Neg) AmIAlmostSame(r Expr) bool {
85  return r.ExprType() == NEG && u.C.AmIAlmostSame(r.(*Neg).C)
86}
87func (u *Neg) Sort() { u.C.Sort() }
88
89func (u *Abs) AmILess(r Expr) bool {
90  if ABS < r.ExprType() {
91    return true
92  }
93  if ABS > r.ExprType() {
94    return false
95  }
96  return u.C.AmILess(r.(*Abs).C)
97}
98func (u *Abs) AmIEqual(r Expr) bool { return r.ExprType() == ABS && u.C.AmIEqual(r.(*Abs).C) }
99func (u *Abs) AmISame(r Expr) bool  { return r.ExprType() == ABS && u.C.AmISame(r.(*Abs).C) }
100func (u *Abs) AmIAlmostSame(r Expr) bool {
101  return r.ExprType() == ABS && u.C.AmIAlmostSame(r.(*Abs).C)
102}
103func (u *Abs) Sort() { u.C.Sort() }
104
105func (u *Sqrt) AmILess(r Expr) bool {
106  if SQRT < r.ExprType() {
107    return true
108  }
109  if SQRT > r.ExprType() {
110    return false
111  }
112  return u.C.AmILess(r.(*Sqrt).C)
113}
114func (u *Sqrt) AmIEqual(r Expr) bool { return r.ExprType() == SQRT && u.C.AmIEqual(r.(*Sqrt).C) }
115func (u *Sqrt) AmISame(r Expr) bool  { return r.ExprType() == SQRT && u.C.AmISame(r.(*Sqrt).C) }
116func (u *Sqrt) AmIAlmostSame(r Expr) bool {
117  return r.ExprType() == SQRT && u.C.AmIAlmostSame(r.(*Sqrt).C)
118}
119func (u *Sqrt) Sort() { u.C.Sort() }
120
121func (u *Sin) AmILess(r Expr) bool {
122  if SIN < r.ExprType() {
123    return true
124  }
125  if SIN > r.ExprType() {
126    return false
127  }
128  return u.C.AmILess(r.(*Sin).C)
129}
130func (u *Sin) AmIEqual(r Expr) bool { return r.ExprType() == SIN && u.C.AmIEqual(r.(*Sin).C) }
131func (u *Sin) AmISame(r Expr) bool  { return r.ExprType() == SIN && u.C.AmISame(r.(*Sin).C) }
132func (u *Sin) AmIAlmostSame(r Expr) bool {
133  return r.ExprType() == SIN && u.C.AmIAlmostSame(r.(*Sin).C)
134}
135func (u *Sin) Sort() { u.C.Sort() }
136
137func (u *Cos) AmILess(r Expr) bool {
138  if COS < r.ExprType() {
139    return true
140  }
141  if COS > r.ExprType() {
142    return false
143  }
144  return u.C.AmILess(r.(*Cos).C)
145}
146func (u *Cos) AmIEqual(r Expr) bool { return r.ExprType() == COS && u.C.AmIEqual(r.(*Cos).C) }
147func (u *Cos) AmISame(r Expr) bool  { return r.ExprType() == COS && u.C.AmISame(r.(*Cos).C) }
148func (u *Cos) AmIAlmostSame(r Expr) bool {
149  return r.ExprType() == COS && u.C.AmIAlmostSame(r.(*Cos).C)
150}
151func (u *Cos) Sort() { u.C.Sort() }
152
153func (u *Tan) AmILess(r Expr) bool {
154  if TAN < r.ExprType() {
155    return true
156  }
157  if TAN > r.ExprType() {
158    return false
159  }
160  return u.C.AmILess(r.(*Tan).C)
161}
162func (u *Tan) AmIEqual(r Expr) bool { return r.ExprType() == TAN && u.C.AmIEqual(r.(*Tan).C) }
163func (u *Tan) AmISame(r Expr) bool  { return r.ExprType() == TAN && u.C.AmISame(r.(*Tan).C) }
164func (u *Tan) AmIAlmostSame(r Expr) bool {
165  return r.ExprType() == TAN && u.C.AmIAlmostSame(r.(*Tan).C)
166}
167func (u *Tan) Sort() { u.C.Sort() }
168
169func (u *Exp) AmILess(r Expr) bool {
170  if EXP < r.ExprType() {
171    return true
172  }
173  if EXP > r.ExprType() {
174    return false
175  }
176  return u.C.AmILess(r.(*Exp).C)
177}
178func (u *Exp) AmIEqual(r Expr) bool { return r.ExprType() == EXP && u.C.AmIEqual(r.(*Exp).C) }
179func (u *Exp) AmISame(r Expr) bool  { return r.ExprType() == EXP && u.C.AmISame(r.(*Exp).C) }
180func (u *Exp) AmIAlmostSame(r Expr) bool {
181  return r.ExprType() == EXP && u.C.AmIAlmostSame(r.(*Exp).C)
182}
183func (u *Exp) Sort() { u.C.Sort() }
184
185func (u *Log) AmILess(r Expr) bool {
186  if LOG < r.ExprType() {
187    return true
188  }
189  if LOG > r.ExprType() {
190    return false
191  }
192  return u.C.AmILess(r.(*Log).C)
193}
194func (u *Log) AmIEqual(r Expr) bool { return r.ExprType() == LOG && u.C.AmIEqual(r.(*Log).C) }
195func (u *Log) AmISame(r Expr) bool  { return r.ExprType() == LOG && u.C.AmISame(r.(*Log).C) }
196func (u *Log) AmIAlmostSame(r Expr) bool {
197  return r.ExprType() == LOG && u.C.AmIAlmostSame(r.(*Log).C)
198}
199func (u *Log) Sort() { u.C.Sort() }
200
201func (u *PowI) AmILess(r Expr) bool {
202  if POWI < r.ExprType() {
203    return true
204  }
205  if POWI > r.ExprType() {
206    return false
207  }
208  if u.Base.AmILess(r.(*PowI).Base) {
209    return true
210  }
211  if r.(*PowI).Base.AmILess(u.Base) {
212    return false
213  }
214  return u.Power < r.(*PowI).Power
215}
216func (u *PowI) AmIEqual(r Expr) bool {
217  return r.ExprType() == POWI && r.(*PowI).Power == u.Power && u.Base.AmIEqual(r.(*PowI).Base)
218}
219func (u *PowI) AmISame(r Expr) bool {
220  return r.ExprType() == POWI && r.(*PowI).Power == u.Power && u.Base.AmISame(r.(*PowI).Base)
221}
222func (u *PowI) AmIAlmostSame(r Expr) bool {
223  return r.ExprType() == POWI && r.(*PowI).Power == u.Power && u.Base.AmIAlmostSame(r.(*PowI).Base)
224}
225func (u *PowI) Sort() { u.Base.Sort() }
226
227func (u *PowF) AmILess(r Expr) bool {
228  if POWF < r.ExprType() {
229    return true
230  }
231  if POWF > r.ExprType() {
232    return false
233  }
234  if u.Base.AmILess(r.(*PowF).Base) {
235    return true
236  }
237  if r.(*PowF).Base.AmILess(u.Base) {
238    return false
239  }
240  return u.Power < r.(*PowF).Power
241}
242func (u *PowF) AmIEqual(r Expr) bool {
243  return r.ExprType() == POWF && r.(*PowF).Power == u.Power && u.Base.AmIEqual(r.(*PowF).Base)
244}
245func (u *PowF) AmISame(r Expr) bool {
246  return r.ExprType() == POWF && r.(*PowF).Power == u.Power && u.Base.AmISame(r.(*PowF).Base)
247}
248func (u *PowF) AmIAlmostSame(r Expr) bool {
249  return r.ExprType() == POWF && r.(*PowF).Power == u.Power && u.Base.AmIAlmostSame(r.(*PowF).Base)
250}
251func (u *PowF) Sort() { u.Base.Sort() }
252
253func (n *PowE) AmILess(r Expr) bool {
254  if POWE < r.ExprType() {
255    return true
256  }
257  if POWE > r.ExprType() {
258    return false
259  }
260  if n.Base.AmILess(r.(*PowE).Base) {
261    return true
262  }
263  if r.(*PowE).Base.AmILess(n.Base) {
264    return false
265  }
266  return n.Power.AmILess(r.(*PowE).Power)
267}
268func (n *PowE) AmIEqual(r Expr) bool {
269  return r.ExprType() == POWE && n.Base.AmIEqual(r.(*PowE).Base) && n.Power.AmIEqual(r.(*PowE).Power)
270}
271func (n *PowE) AmISame(r Expr) bool {
272  return r.ExprType() == POWE && n.Base.AmISame(r.(*PowE).Base) && n.Power.AmISame(r.(*PowE).Power)
273}
274func (n *PowE) AmIAlmostSame(r Expr) bool {
275  return r.ExprType() == POWE && n.Base.AmIAlmostSame(r.(*PowE).Base) && n.Power.AmIAlmostSame(r.(*PowE).Power)
276}
277func (n *PowE) Sort() { n.Base.Sort(); n.Power.Sort() }
278
279func (n *Div) AmILess(r Expr) bool {
280  if r == nil {
281    return false
282  }
283  if DIV < r.ExprType() {
284    return true
285  }
286  if DIV > r.ExprType() {
287    return false
288  }
289  rp := r.(*Div)
290  if n.Numer.AmILess(rp.Numer) {
291    return true
292  }
293  if rp.Numer.AmILess(n.Numer) {
294    return false
295  }
296  return n.Denom.AmILess(r.(*Div).Denom)
297}
298func (n *Div) AmIEqual(r Expr) bool {
299  if r == nil || r.ExprType() != DIV {
300    return false
301  }
302  rp := r.(*Div)
303  if (n.Numer != nil && rp.Numer == nil) || (n.Numer == nil && rp.Numer != nil) {
304    return false
305  }
306  if (n.Denom != nil && rp.Denom == nil) || (n.Denom == nil && rp.Denom != nil) {
307    return false
308  }
309  return r.ExprType() == DIV && n.Numer.AmIEqual(rp.Numer) && rp.Denom.AmIEqual(rp.Denom)
310}
311func (n *Div) AmISame(r Expr) bool {
312  if r == nil || r.ExprType() != DIV {
313    return false
314  }
315  rp := r.(*Div)
316  if (n.Numer != nil && rp.Numer == nil) || (n.Numer == nil && rp.Numer != nil) {
317    return false
318  }
319  if (n.Denom != nil && rp.Denom == nil) || (n.Denom == nil && rp.Denom != nil) {
320    return false
321  }
322  return r.ExprType() == DIV && n.Numer.AmISame(rp.Numer) && n.Denom.AmISame(rp.Denom)
323}
324func (n *Div) AmIAlmostSame(r Expr) bool {
325  if r == nil || r.ExprType() != DIV {
326    return false
327  }
328  rp := r.(*Div)
329  if (n.Numer != nil && rp.Numer == nil) || (n.Numer == nil && rp.Numer != nil) {
330    return false
331  }
332  if (n.Denom != nil && rp.Denom == nil) || (n.Denom == nil && rp.Denom != nil) {
333    return false
334  }
335  return r.ExprType() == DIV && n.Numer.AmIAlmostSame(rp.Numer) && n.Denom.AmIAlmostSame(rp.Denom)
336}
337func (n *Div) Sort() {
338  if n.Numer != nil {
339    n.Numer.Sort()
340  }
341  if n.Denom != nil {
342    n.Denom.Sort()
343  }
344}
345
346func (n *Add) AmILess(r Expr) bool {
347  if ADD < r.ExprType() {
348    return true
349  }
350  if ADD > r.ExprType() {
351    return false
352  }
353  m := r.(*Add)
354  ln := len(n.CS)
355  lm := len(m.CS)
356  if ln < lm {
357    return true
358  }
359  if lm < ln {
360    return false
361  }
362  for i, C := range n.CS {
363    if C.AmILess(m.CS[i]) {
364      return true
365    }
366    if m.CS[i].AmILess(C) {
367      return false
368    }
369  }
370  return false
371}
372func (n *Add) AmIEqual(r Expr) bool {
373  if r.ExprType() != ADD {
374    return false
375  }
376  m := r.(*Add)
377  if len(n.CS) != len(m.CS) {
378    return false
379  }
380  for i, C := range n.CS {
381    if !C.AmIEqual(m.CS[i]) {
382      return false
383    }
384    //     if m.CS[i].AmILess( C ) { return false }
385  }
386  return true
387}
388func (n *Add) AmISame(r Expr) bool {
389  if r.ExprType() != ADD {
390    return false
391  }
392  m := r.(*Add)
393  if len(n.CS) != len(m.CS) {
394    return false
395  }
396  for i, C := range n.CS {
397    if !C.AmISame(m.CS[i]) {
398      return false
399    }
400    //     if m.CS[i].AmILess( C ) { return false }
401  }
402  return true
403}
404func (n *Add) AmIAlmostSame(r Expr) bool {
405  if r.ExprType() != ADD {
406    return false
407  }
408  m := r.(*Add)
409  if len(n.CS) != len(m.CS) {
410    return false
411  }
412  same := true
413  for i, C := range n.CS {
414    if !C.AmIAlmostSame(m.CS[i]) {
415      return false
416    }
417  }
418  return same
419}
420func (n *Add) Sort() {
421  for _, C := range n.CS {
422    if C != nil {
423      C.Sort()
424    }
425  }
426  sort.Sort(ExprArray(n.CS))
427  i := len(n.CS) - 1
428  for i >= 0 && n.CS[i] == nil {
429    n.CS = n.CS[:i]
430    i = len(n.CS) - 1
431  }
432  return
433}
434
435func (n *Mul) AmILess(r Expr) bool {
436  if r.ExprType() != MUL {
437    if len(n.CS) == 2 {
438      if n.CS[0].ExprType() == CONSTANT && n.CS[1].AmISame(r) {
439        return true
440      }
441      if n.CS[0].ExprType() == CONSTANTF && n.CS[1].AmISame(r) {
442        return true
443      }
444    }
445    return false
446  }
447  m := r.(*Mul)
448  ln, lm := len(n.CS), len(m.CS)
449  sn, sm := 0, 0
450  if n.CS[0].ExprType() == CONSTANT || n.CS[0].ExprType() == CONSTANTF {
451    sn++
452  }
453  if m.CS[0].ExprType() == CONSTANT || m.CS[0].ExprType() == CONSTANTF {
454    sm++
455  }
456
457  if ln-sn != lm-sm {
458    return ln-sn < lm-sm
459  }
460  for i, j := sn, sm; i < ln && j < lm; {
461    if n.CS[i].AmILess(m.CS[j]) {
462      return true
463    }
464    if m.CS[j].AmILess(n.CS[i]) {
465      return false
466    }
467    i++
468    j++
469  }
470  return false
471}
472
473func (n *Mul) AmIEqual(r Expr) bool {
474  if r.ExprType() != MUL {
475    return false
476  }
477  m := r.(*Mul)
478  if len(n.CS) != len(m.CS) {
479    return false
480  }
481  for i, C := range n.CS {
482    if !C.AmIEqual(m.CS[i]) {
483      return false
484    }
485    //     if m.CS[i].AmILess( C ) { return false }
486  }
487  return true
488}
489
490func (n *Mul) AmISame(r Expr) bool {
491  if r.ExprType() != MUL {
492    return false
493  }
494  m := r.(*Mul)
495  if len(n.CS) != len(m.CS) {
496    return false
497  }
498  for i, C := range n.CS {
499    if !C.AmISame(m.CS[i]) {
500      return false
501    }
502    //     if m.CS[i].AmILess( C ) { return false }
503  }
504  return true
505}
506
507func (n *Mul) AmIAlmostSame(r Expr) bool {
508  if r.ExprType() != MUL {
509    // fmt.Printf("~MUL:  %v  %v\n", n, r)
510    if len(n.CS) == 2 {
511      if n.CS[0].ExprType() == CONSTANT && n.CS[1].AmIAlmostSame(r) {
512        return true
513      }
514      if n.CS[0].ExprType() == CONSTANTF && n.CS[1].AmIAlmostSame(r) {
515        return true
516      }
517    }
518    return false
519  }
520  // fmt.Printf("MUL:  %v  %v\n", n, r)
521
522  m := r.(*Mul)
523  ln, lm := len(n.CS), len(m.CS)
524  sn, sm := 0, 0
525  if n.CS[0].ExprType() == CONSTANT || n.CS[0].ExprType() == CONSTANTF {
526    sn++
527  }
528  if m.CS[0].ExprType() == CONSTANT || m.CS[0].ExprType() == CONSTANTF {
529    sm++
530  }
531  // fmt.Printf("lens: %d %d %d %d\n", sn, ln, sm, lm)
532
533  if ln-sn != lm-sm {
534    return false
535  }
536  for i, j := sn, sm; i < ln && j < lm; {
537    // fmt.Printf("COMPARE:  %v   %v", n.CS[i], m.CS[j])
538    if !n.CS[i].AmIAlmostSame(m.CS[j]) {
539      // fmt.Println("SAME")
540      return false
541    }
542    i++
543    j++
544  }
545  // fmt.Printf("\n")
546  return true
547}
548
549func (n *Mul) Sort() {
550  for _, C := range n.CS {
551    if C != nil {
552      C.Sort()
553    }
554  }
555  sort.Sort(ExprArray(n.CS))
556  i := len(n.CS) - 1
557  for i >= 0 && n.CS[i] == nil {
558    n.CS = n.CS[:i]
559    i = len(n.CS) - 1
560  }
561  return
562}
Note: See TracBrowser for help on using the repository browser.