Exemple #1
0
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
}
Exemple #3
0
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
}
Exemple #4
0
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
}