Golang Expr.Clone方法代码示例

// 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) 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 (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()
//.........这里部分代码省略.........

// 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
}