func (PS *PgeSearch) GenInitExprAddMethod1() []expr.Expr {
exprs := make([]expr.Expr, 0)
// WARNING adding a single coefficient results in the same traversal but with the added extra coefficient
cf := new(expr.Constant)
cf.P = 1
af := new(expr.Add)
af.Insert(cf)
exprs = append(exprs, af)
for _, i := range PS.cnfg.treecfg.UsableVars {
c := new(expr.Constant)
c.P = -1
v := new(expr.Var)
v.P = i
m := expr.NewMul()
m.Insert(c)
m.Insert(v)
a := expr.NewAdd()
a.Insert(m)
exprs = append(exprs, a)
}
fmt.Println("Initial Add: ", exprs)
return exprs
}
// change any term to something more complex...
func (PS *PgeSearch) DeepenTermInExprMethod1(O, E expr.Expr, pos int) []expr.Expr {
exprs := make([]expr.Expr, 0)
// make into add
A := expr.NewAdd()
A.Insert(E.Clone())
OA := A.Clone()
exprs = append(exprs, PS.AddTermToExprMethod1(OA, A, 0)[:]...)
// make into mul
M := expr.NewMul()
M.Insert(E.Clone())
OM := M.Clone()
exprs = append(exprs, PS.WidenTermInExprMethod1(OM, M, 0)[:]...)
// // make into div
// if E.ExprType() != expr.DIV {
// D := new(expr.Div)
// c := new(expr.Constant)
// c.P = -1
// D.Numer = c
// D.Denom = E.Clone()
// exprs = append(exprs, D)
// }
// make inside of nodes
for _, N := range PS.GenNodes {
if N.ExprType() == expr.DIV {
continue
}
T := N.Clone()
P := 1
T.SetExpr(&P, E.Clone())
exprs = append(exprs, T)
}
ret := make([]expr.Expr, 0)
for _, e := range exprs {
C := O.Clone()
P := pos
C.SetExpr(&P, e)
ret = append(ret, C)
}
return ret
}
func (PS *PgeSearch) expandPeeled(es []*probs.ExprReport) [][]expr.Expr {
eqns := make([][]expr.Expr, PS.cnfg.peelCnt)
for p := 0; p < PS.cnfg.peelCnt; p++ {
if es[p] == nil {
continue
}
// fmt.Printf("expand(%d): %v\n", p, es[p].Expr())
if es[p].Expr().ExprType() != expr.ADD {
add := expr.NewAdd()
add.Insert(es[p].Expr())
add.CalcExprStats()
es[p].SetExpr(add)
}
eqns[p] = PS.Expand(es[p].Expr())
// fmt.Printf("Results:\n")
// for i, e := range eqns[p] {
// fmt.Printf("%d,%d: %v\n", p, i, e)
// }
// fmt.Println()
}
fmt.Println("\n")
return eqns
}
func fillExprStuff(names []string) (types []expr.ExprType, exprs []expr.Expr) {
types = make([]expr.ExprType, len(names))
exprs = make([]expr.Expr, len(names))
for i, n := range names {
switch strings.ToLower(n) {
case "constant":
types[i] = expr.CONSTANT
exprs[i] = new(expr.Constant)
case "constantf":
types[i] = expr.CONSTANTF
exprs[i] = new(expr.ConstantF)
case "time":
types[i] = expr.TIME
exprs[i] = new(expr.Time)
case "system":
types[i] = expr.SYSTEM
exprs[i] = new(expr.System)
case "var":
types[i] = expr.VAR
exprs[i] = new(expr.Var)
case "neg":
types[i] = expr.NEG
exprs[i] = new(expr.Neg)
case "abs":
types[i] = expr.ABS
exprs[i] = new(expr.Abs)
case "sqrt":
types[i] = expr.SQRT
exprs[i] = new(expr.Sqrt)
case "sin":
types[i] = expr.SIN
exprs[i] = new(expr.Sin)
case "cos":
types[i] = expr.COS
exprs[i] = new(expr.Cos)
case "tan":
types[i] = expr.TAN
exprs[i] = new(expr.Tan)
case "exp":
types[i] = expr.EXP
exprs[i] = new(expr.Exp)
case "log":
types[i] = expr.LOG
exprs[i] = new(expr.Log)
case "powi":
types[i] = expr.POWI
exprs[i] = new(expr.PowI)
case "powf":
types[i] = expr.POWF
exprs[i] = new(expr.PowF)
case "powe":
types[i] = expr.POWE
exprs[i] = new(expr.PowE)
case "add":
types[i] = expr.ADD
exprs[i] = expr.NewAdd()
case "mul":
types[i] = expr.MUL
exprs[i] = expr.NewMul()
case "div":
types[i] = expr.DIV
exprs[i] = new(expr.Div)
default:
log.Fatalf("Unknown ExprType: %s\n", n)
}
}
return
}
func (PS *PgeSearch) ExpandMethod2(O expr.Expr) (ret []expr.Expr) {
O.Sort()
ret = make([]expr.Expr, 0)
// fmt.Printf("Expanding expression: %v\n", O)
add := O.(*expr.Add)
// adding term to addition
for _, B := range PS.ffxBases {
found := false
for _, C := range add.CS {
// fmt.Printf("checking %v in %v\n", B, add)
if C.AmISame(B) {
// fmt.Println("found\n\n")
found = true
break
}
}
if !found {
e := O.Clone()
a := e.(*expr.Add)
a.Insert(B.Clone())
sort.Sort(a)
a.CalcExprStats()
good := PS.cnfg.treecfg.CheckExpr(a)
if good {
ret = append(ret, a)
}
// fmt.Printf("grew %v\n\n", a)
// ret = append(ret, a)
}
}
// extending terms in addition
for _, B := range PS.ffxBases {
for i, C := range add.CS {
if C.ExprType() == expr.MUL {
m := C.(*expr.Mul)
if len(m.CS) > 3 {
continue
}
}
e := O.Clone()
a := e.(*expr.Add)
mul := expr.NewMul()
mul.Insert(a.CS[i])
mul.Insert(B.Clone())
a.CS[i] = mul
sort.Sort(a)
a.CalcExprStats()
good := PS.cnfg.treecfg.CheckExpr(a)
if good {
ret = append(ret, a)
}
// fmt.Printf("grew %v\n\n", a)
ret = append(ret, a)
}
}
// deepening terms
// if len(add.CS) < 2 {
// return ret
// }
for i, C := range add.CS {
if C.ExprType() == expr.MUL {
m := C.(*expr.Mul)
if len(m.CS) != 2 {
continue
}
if m.CS[1].ExprType() == expr.ADD {
continue
}
} else {
continue
}
for _, B := range PS.ffxBases {
e := O.Clone()
a := e.(*expr.Add)
m := a.CS[i].(*expr.Mul)
n := m.CS[1]
switch n.ExprType() {
case expr.SQRT:
A := expr.NewAdd()
A.Insert(n.(*expr.Sqrt).C)
A.Insert(B.Clone())
n.(*expr.Sqrt).C = A
case expr.SIN:
A := expr.NewAdd()
A.Insert(n.(*expr.Sin).C)
A.Insert(B.Clone())
n.(*expr.Sin).C = A
case expr.COS:
A := expr.NewAdd()
A.Insert(n.(*expr.Cos).C)
A.Insert(B.Clone())
n.(*expr.Cos).C = A
case expr.TAN:
A := expr.NewAdd()
A.Insert(n.(*expr.Tan).C)
A.Insert(B.Clone())
n.(*expr.Tan).C = A
case expr.EXP:
A := expr.NewAdd()
A.Insert(n.(*expr.Exp).C)
A.Insert(B.Clone())
n.(*expr.Exp).C = A
case expr.LOG:
A := expr.NewAdd()
A.Insert(n.(*expr.Log).C)
A.Insert(B.Clone())
n.(*expr.Log).C = A
default:
A := expr.NewAdd()
A.Insert(m.CS[1])
A.Insert(B.Clone())
m.CS[1] = A
}
sort.Sort(a)
a.CalcExprStats()
good := PS.cnfg.treecfg.CheckExpr(a)
if good {
ret = append(ret, a)
}
// fmt.Printf("grew %v\n", a)
ret = append(ret, a)
}
}
for i, C := range add.CS {
if C.ExprType() == expr.MUL {
m := C.(*expr.Mul)
if len(m.CS) != 2 {
continue
}
if m.CS[1].ExprType() == expr.ADD {
continue
}
} else {
continue
}
for _, B := range PS.ffxBases {
e := O.Clone()
a := e.(*expr.Add)
m := a.CS[i].(*expr.Mul)
n := m.CS[1]
switch n.ExprType() {
case expr.SQRT:
M := expr.NewMul()
M.Insert(n.(*expr.Sqrt).C)
M.Insert(B.Clone())
n.(*expr.Sqrt).C = M
case expr.SIN:
M := expr.NewMul()
M.Insert(n.(*expr.Sin).C)
M.Insert(B.Clone())
n.(*expr.Sin).C = M
case expr.COS:
M := expr.NewMul()
M.Insert(n.(*expr.Cos).C)
M.Insert(B.Clone())
n.(*expr.Cos).C = M
case expr.TAN:
M := expr.NewMul()
M.Insert(n.(*expr.Tan).C)
M.Insert(B.Clone())
n.(*expr.Tan).C = M
case expr.EXP:
M := expr.NewMul()
M.Insert(n.(*expr.Exp).C)
M.Insert(B.Clone())
n.(*expr.Exp).C = M
case expr.LOG:
M := expr.NewMul()
M.Insert(n.(*expr.Log).C)
M.Insert(B.Clone())
n.(*expr.Log).C = M
}
sort.Sort(a)
a.CalcExprStats()
good := PS.cnfg.treecfg.CheckExpr(a)
if good {
ret = append(ret, a)
}
// fmt.Printf("grew %v\n", a)
ret = append(ret, a)
}
}
// fmt.Println("Len of ret = ", len(ret))
return ret
}