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 }
// add complexity to a single multiplication term func (PS *PgeSearch) WidenTermInExprMethod1(O, E expr.Expr, pos int) (ret []expr.Expr) { ret = make([]expr.Expr, 0) // insert leafs f()*L for _, L := range PS.GenLeafs { l := L.Clone() C := O.Clone() P := pos e := C.GetExpr(&P) // fmt.Printf("pos(%d): %v\n", pos, e) M := e.(*expr.Mul) M.Insert(l) sort.Sort(M) C.CalcExprStats() good := PS.cnfg.treecfg.CheckExpr(C) if good { ret = append(ret, C) } } // insert node(L) : f() * c*node(L) for _, N := range PS.GenNodes { for _, L := range PS.GenLeafs { c := new(expr.Constant) c.P = -1 l := L.Clone() n := N.Clone() p := 1 n.SetExpr(&p, l) var E expr.Expr if N.ExprType() == expr.DIV { E = expr.NewDiv(c, l) } else { // mul it M := expr.NewMul() M.Insert(c) M.Insert(n) E = M } C := O.Clone() P := pos e := C.GetExpr(&P) // fmt.Printf("pos(%d): %v\n", pos, e) M := e.(*expr.Mul) M.Insert(E) sort.Sort(M) C.CalcExprStats() good := PS.cnfg.treecfg.CheckExpr(C) if good { ret = append(ret, C) } } } return ret }
// 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) GenInitExprMulMethod1() []expr.Expr { exprs := make([]expr.Expr, 0) 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) exprs = append(exprs, m) } fmt.Println("Initial Mul: ", exprs) return exprs }
// This is the FFXish style init function func (PS *PgeSearch) GenInitExprMethod3() *probs.ReportQueue { fmt.Printf("generating initial expressions\n") GP := PS.cnfg.treecfg fmt.Printf("%v\n", GP) bases := make([]expr.Expr, 0) // single constant bases = append(bases, expr.NewConstant(-1)) // c*x_i for _, v := range PS.prob.UsableVars { mul := expr.NewMul() mul.Insert(expr.NewConstant(-1)) mul.Insert(expr.NewVar(v)) bases = append(bases, mul) } // c*x_i^p & c*x_i^-p for p := 2; p <= 4; p++ { for _, v := range PS.prob.UsableVars { // positive powers mul := expr.NewMul() mul.Insert(expr.NewConstant(-1)) mul.Insert(expr.NewPowI(expr.NewVar(v), p)) bases = append(bases, mul) // negative powers nul := expr.NewMul() nul.Insert(expr.NewConstant(-1)) nul.Insert(expr.NewPowI(expr.NewVar(v), -p)) bases = append(bases, nul) } } // c*N(d*x_i) for _, N := range PS.GenNodes { if N.ExprType() == expr.DIV || N.ExprType() == expr.ADD || N.ExprType() == expr.MUL { continue } for _, v := range PS.prob.UsableVars { // positive powers mul := expr.NewMul() mul.Insert(expr.NewConstant(-1)) nul := expr.NewMul() nul.Insert(expr.NewConstant(-1)) nul.Insert(expr.NewVar(v)) n := N.Clone() p := 1 n.SetExpr(&p, nul) mul.Insert(n) bases = append(bases, mul) } } // copy bases for use later in expand PS.ffxBases = make([]expr.Expr, len(bases)) for i, b := range bases { PS.ffxBases[i] = b.Clone() } exprs := probs.NewReportQueue() // exprs.SetSort(PS.cnfg.sortType) exprs.SetSort(probs.PESORT_PARETO_TST_ERR) for i, e := range bases { fmt.Printf("%d: %v\n", i, e) serial := make([]int, 0, 64) serial = e.Serial(serial) PS.Trie.InsertSerial(serial) // on train data re := RegressExpr(e, PS.prob) re.SetUnitID(i) exprs.Push(re) } exprs.Sort() return exprs }
func (PS *PgeSearch) ExpandMethod3(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) } } // fmt.Println("Len of ret = ", len(ret)) return ret }
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 }
// add another term to an add expr func (PS *PgeSearch) AddTermToExprMethod1(O, E expr.Expr, pos int) (ret []expr.Expr) { ret = make([]expr.Expr, 0) A := E.(*expr.Add) // f() + cL for _, L := range PS.GenLeafs { c := new(expr.Constant) c.P = -1 l := L.Clone() // mul it M := expr.NewMul() M.Insert(c) M.Insert(l) // skip if the same term already exists in the add skip := false for _, e := range A.CS { if e == nil { continue } // fmt.Printf("ACMP %v %v\n", M, e) if e.AmIAlmostSame(M) || M.AmIAlmostSame(e) { skip = true break } } if skip { continue } C := O.Clone() P := pos AM := C.GetExpr(&P).(*expr.Add) AM.Insert(M) sort.Sort(AM) C.CalcExprStats() good := PS.cnfg.treecfg.CheckExpr(C) if good { ret = append(ret, C) } } // f() + c*node(L) for _, N := range PS.GenNodes { for _, L := range PS.GenLeafs { c := new(expr.Constant) c.P = -1 l := L.Clone() n := N.Clone() p := 1 n.SetExpr(&p, l) var E expr.Expr if N.ExprType() == expr.DIV { E = expr.NewDiv(c, l) } else { // mul it M := expr.NewMul() M.Insert(c) M.Insert(n) E = M } // skip if the same term already exists in the add skip := false for _, e := range A.CS { if e == nil { continue } // fmt.Printf("ACMP %v %v\n", M, e) if e.AmIAlmostSame(E) || E.AmIAlmostSame(e) { skip = true break } } if skip { continue } // fmt.Println(E.String()) C := O.Clone() P := pos AM := C.GetExpr(&P).(*expr.Add) AM.Insert(E) sort.Sort(AM) C.CalcExprStats() good := PS.cnfg.treecfg.CheckExpr(C) if good { ret = append(ret, C) } } } return ret }