private static ObjectFormulaTree sumSumInverse(ObjectFormulaTree tree) { ObjectFormulaTree tre = tree; IObjectOperation op = tree.Operation; if (op is PolySum) { PolySum ps = op as PolySum; tre = sumSumInverse(ps); op = tre.Operation; } List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); for (int i = 0; i < tre.Count; i++) { l.Add(sumSumInverse(tre[i])); } if (op is ElementaryBinaryOperation) { ElementaryBinaryOperation bo = op as ElementaryBinaryOperation; char c = bo.Symbol; if (c == '+' | c == '-') { if (PolyMult.IsZero(l[1])) { return(l[0]); } if (PolyMult.IsZero(l[0])) { return(signed(l[1], c)); } } } return(new ObjectFormulaTree(op, l)); }
private bool reduce() { List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(l); bool b = true; foreach (ObjectFormulaTree t in l) { if (t.Operation is PolyMult) { list.Remove(t); PolyMult pm = t.Operation as PolyMult; list.AddRange(pm.l); b = false; continue; } if (!(t.Operation is ElementaryBinaryOperation)) { continue; } ElementaryBinaryOperation op = t.Operation as ElementaryBinaryOperation; if (op.Symbol != '*') { continue; } list.Remove(t); for (int i = 0; i < 2; i++) { list.Add(t); b = false; } } l = list; return(b); }
/// <summary> /// Calculates derivation tree /// </summary> /// <param name="tree">Tree to calculate</param> /// <param name="variableName">Name of variable</param> /// <returns>Tree of derivation</returns> static public ObjectFormulaTree Derivation(this ObjectFormulaTree tree, string variableName) { if (tree.Operation is IDerivationOperation) { IDerivationOperation op = tree.Operation as IDerivationOperation; return(op.Derivation(tree, variableName)); } if (ElementaryBinaryOperation.IsInteger(tree.Operation.ReturnType)) { ElementaryRealConstant op = new ElementaryRealConstant(0); return(new ObjectFormulaTree(op, new List <ObjectFormulaTree>())); } if (tree.Operation is OptionalOperation) { OptionalOperation op = tree.Operation as OptionalOperation; op = op.Clone() as OptionalOperation; List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(); list.Add(tree[0]); for (int i = 1; i < 3; i++) { list.Add(tree[i].Derivation(variableName)); } return(new ObjectFormulaTree(op, list)); } return(null); }
/// <summary> /// Calculates derivation /// </summary> /// <param name="tree">The function for derivation calculation</param> /// <param name="variableName">Derivation string</param> /// <returns>The derivation</returns> public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName) { Double a = 0; bool[] b = new bool[] { false, false }; ObjectFormulaTree[] fc = new ObjectFormulaTree[2]; ObjectFormulaTree[] fd = new ObjectFormulaTree[2]; for (int i = 0; i < 2; i++) { fc[i] = tree[1 - i]; fd[i] = fc[i].Derivation(variableName); b[i] = ZeroPerformer.IsZero(fd[i]); } if (b[0] & b[1]) { return(ElementaryRealConstant.RealZero); } IObjectOperation nom = new ElementaryBinaryOperation('-', new object[] { a, a }); List <ObjectFormulaTree> nomList = new List <ObjectFormulaTree>(); for (int i = 0; i < 2; i++) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); l.Add(fd[1 - i]); //.Clone() as ObjectFormulaTree); l.Add(fc[i]); //.Clone() as ObjectFormulaTree); IObjectOperation o = new ElementaryBinaryOperation('*', new object[] { a, a }); nomList.Add(new ObjectFormulaTree(o, l)); } List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(); if (b[0] | b[1]) { for (int i = 0; i < 2; i++) { if (b[i]) { List <ObjectFormulaTree> lt = new List <ObjectFormulaTree>(); lt.Add(nomList[i]); list.Add(new ObjectFormulaTree(new ElementaryFunctionOperation('-'), lt)); } } } else { list.Add(new ObjectFormulaTree(nom, nomList)); } IObjectOperation square = ElementaryFunctionsCreator.Object.GetPowerOperation(a, a); List <ObjectFormulaTree> squareList = new List <ObjectFormulaTree>(); squareList.Add(fc[0]); squareList.Add(new ObjectFormulaTree(new ElementaryRealConstant(2), new List <ObjectFormulaTree>())); list.Add(new ObjectFormulaTree(square, squareList)); if (list.Count != 2) { // list = list; } return(new ObjectFormulaTree(new ElementaryFraction(), list)); }
private static ObjectFormulaTree sumSum(ObjectFormulaTree tree) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); for (int i = 0; i < tree.Count; i++) { ObjectFormulaTree t = tree[i]; // t = ElementaryFormulaSimplification.Object.Simplify(t); l.Add(sumSum(t)); } IObjectOperation op = tree.Operation; if (op is ElementaryBinaryOperation) { ElementaryBinaryOperation bo = op as ElementaryBinaryOperation; char c = bo.Symbol; PolySum ps = new PolySum(true); if (c == '+' | c == '-') { bool b = c == '+'; PolySum p = new PolySum(true); Dictionary <ObjectFormulaTree, bool> dic = p.summands; for (int i = 0; i < l.Count; i++) { ObjectFormulaTree t = l[i]; if (PolyMult.IsZero(t)) { continue; } bool kb = true; if (i > 0) { kb = b; } IObjectOperation oo = t.Operation; if (oo is PolySum) { PolySum pss = oo as PolySum; Dictionary <ObjectFormulaTree, bool> d = pss.summands; foreach (ObjectFormulaTree tr in d.Keys) { bool rb = d[tr]; if (!kb) { rb = !rb; } dic[tr] = rb; } continue; } dic[t] = kb; } return(new ObjectFormulaTree(p, new List <ObjectFormulaTree>())); } } return(new ObjectFormulaTree(op, l)); }
/// <summary> /// Accepts operation /// </summary> /// <param name="type">Argument type</param> /// <returns>The operation</returns> public IObjectOperation Accept(object type) { if (!ElementaryBinaryOperation.IsInteger(type)) { return(null); } this.type = type; return(this); }
/// <summary> /// Calculates derivation of i - th function /// </summary> /// <param name="tree">Object tree</param> /// <param name="i">Function number</param> /// <param name="variableName">Name of variable</param> /// <returns>The derivation</returns> static private ObjectFormulaTree Derivation(ObjectFormulaTree tree, int i, string variableName) { Double a = 0; ObjectFormulaTree f1 = tree[0].Derivation(variableName); if (ZeroPerformer.IsZero(f1)) { return(ElementaryRealConstant.RealZero); } ObjectFormulaTree fd = functionDerivations[i]; ObjectFormulaTree f0 = InsertVariable(fd, tree[0]); IObjectOperation operation = new ElementaryBinaryOperation('*', new object[] { a, a }); List <ObjectFormulaTree> children = new List <ObjectFormulaTree>(); children.Add(f0); children.Add(f1); return(new ObjectFormulaTree(operation, children)); }
/// <summary> /// Derivation of square root /// </summary> /// <param name="tree">Prototype tree</param> /// <param name="variableName">Name of variable</param> /// <returns>The derivation</returns> public static ObjectFormulaTree SquareRootDerivation(ObjectFormulaTree tree, string variableName) { ObjectFormulaTree co = ElementaryRealConstant.GetConstant(0.5); ObjectFormulaTree derNom = tree[0].Derivation(variableName); List <ObjectFormulaTree> lnom = new List <ObjectFormulaTree>() { co, derNom }; Double a = 0; ElementaryBinaryOperation bo = new ElementaryBinaryOperation('*', new object[] { a, a }); ObjectFormulaTree tn = new ObjectFormulaTree(bo, lnom); List <ObjectFormulaTree> l = new List <ObjectFormulaTree>() { tn, tree }; return(new ObjectFormulaTree(ElementaryFraction.Object, l)); }
/// <summary> /// Acceptor of binary operation /// </summary> /// <param name="typeA">Type of left part</param> /// <param name="typeB">Type of right part</param> /// <returns>Accepted operation</returns> public IObjectOperation Accept(object typeA, object typeB) { object type = ElementaryBinaryOperation.DetectType(typeA, typeB); if (type == null) { foreach (IBinaryAcceptor acceptor in acceptors) { IObjectOperation op = acceptor.Accept(typeA, typeB); if (op != null) { return(op); } } return(null); } return(new ElementaryBinaryOperation(symbol, new object[] { typeA, typeB })); }
/// <summary> /// Calculates derivation /// </summary> /// <param name="tree">The function for derivation calculation</param> /// <param name="variableName">Name of variable</param> /// <returns>The derivation</returns> public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName) { Double a = 0; ObjectFormulaTree[] fc = new ObjectFormulaTree[2]; ObjectFormulaTree[] fd = new ObjectFormulaTree[2]; for (int i = 0; i < 2; i++) { fc[i] = tree[i]; fd[i] = fc[i].Derivation(variableName); } List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(); IObjectOperation nom = new ElementaryBinaryOperation('-', new object[] { a, a }); List <ObjectFormulaTree> nomList = new List <ObjectFormulaTree>(); for (int i = 0; i < 2; i++) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); l.Add(fc[1 - i]); l.Add(fd[i]); IObjectOperation o = new ElementaryBinaryOperation('*', new object[] { a, a }); nomList.Add(new ObjectFormulaTree(o, l)); } list.Add(new ObjectFormulaTree(nom, nomList)); List <ObjectFormulaTree> plusList = new List <ObjectFormulaTree>(); for (int i = 0; i < 2; i++) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); l.Add(fc[i]); l.Add(new ObjectFormulaTree(new ElementaryRealConstant(2), new List <ObjectFormulaTree>())); IObjectOperation o = ElementaryFunctionsCreator.Object.GetPowerOperation(a, a); plusList.Add(new ObjectFormulaTree(o, l)); } IObjectOperation plusOp = new ElementaryBinaryOperation('+', new object[] { a, a }); IObjectOperation denomOp = new ElementaryRoot(); List <ObjectFormulaTree> denomList = new List <ObjectFormulaTree>(); // denomList.Add(new ObjectFormulaTree(plusOp, plusList)); //list.Add(new ObjectFormulaTree(new ElementaryRoot(), denomList)); list.Add(new ObjectFormulaTree(plusOp, plusList)); return(new ObjectFormulaTree(ElementaryFraction.Object, list)); }
internal static ObjectFormulaTree MultMultReverse(ObjectFormulaTree tree) { Double a = 0; List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); IObjectOperation op = tree.Operation; PolyMult pm = null; if (op is PolyMult) { pm = op as PolyMult; } for (int i = 0; i < tree.Count; i++) { l.Add(MultMultReverse(tree[i])); } if (pm == null) { return(new ObjectFormulaTree(op, l)); } if (l.Count == 1) { return(l[0]); } PolyMult p = new PolyMult(); if (l.Count == 0) { ElementaryRealConstant rc = new ElementaryRealConstant(0); return(new ObjectFormulaTree(rc, new List <ObjectFormulaTree>())); } ObjectFormulaTree left = l[0]; l.RemoveAt(0); p.l = l; ObjectFormulaTree right = MultMultReverse(new ObjectFormulaTree(p, l)); List <ObjectFormulaTree> lll = new List <ObjectFormulaTree>(); lll.Add(left); lll.Add(right); ElementaryBinaryOperation bo = new ElementaryBinaryOperation('*', new object[] { a, a }); return(new ObjectFormulaTree(bo, lll)); }
/// <summary> /// Integral of tree /// </summary> /// <param name="tree">The tree</param> /// <returns>The integral</returns> public static double Integral(ObjectFormulaTree tree) { IObjectOperation op = tree.Operation; if (op is IDistribution) { IDistribution df = op as IDistribution; return(df.Integral); } if (op is ElementaryBinaryOperation) { ElementaryBinaryOperation ebo = op as ElementaryBinaryOperation; char c = ebo.Symbol; if (c == '+') { return(getSum(tree)); } if (c == '-') { return(getDiff(tree)); } if (c == '*') { return(getMult(tree)); } } if (op is ElementaryFunctionOperation) { ElementaryFunctionOperation efo = op as ElementaryFunctionOperation; char c = efo.Symbol; double a = Integral(tree[0]); if (c == '?') { return(a); } if (c == '-') { return(-a); } } return(0); }
/// <summary> /// Accepts operation /// </summary> /// <param name="type">Argument type</param> /// <returns>The operation</returns> public IObjectOperation Accept(object type) { if (!ElementaryBinaryOperation.IsNumber(type)) { if (!addAcceptors.ContainsKey(type)) { return(null); } List <IOperationAcceptor> l = addAcceptors[type]; foreach (IOperationAcceptor acc in l) { IObjectOperation op = acc.Accept(type); if (op != null) { return(op); } } return(null); } return(new ElementaryIntegerOperation(symbol, type)); }
/// <summary> /// Acceptor of binary operation /// </summary> /// <param name="typeA">Type of left part</param> /// <param name="typeB">Type of right part</param> /// <returns>Accepted operation</returns> public IObjectOperation Accept(object typeA, object typeB) { IObjectOperation op = DateTimeMoreComparator.Object.Accept(typeA, typeB); if (op != null) { if (symbol == '>') { return(DateTimeMoreComparator.Object); } if (symbol == '<') { return(DateTimeLessCompatrator.Object); } } if (!ElementaryBinaryOperation.IsNumber(typeA) | !ElementaryBinaryOperation.IsNumber(typeB)) { return(null); } return(this); }
/// <summary> /// Acceptor of binary operation /// </summary> /// <param name="typeA">Type of left part</param> /// <param name="typeB">Type of right part</param> /// <returns>Accepted operation</returns> public IObjectOperation Accept(object typeA, object typeB) { if (!ElementaryBinaryOperation.IsInteger(typeA)) { throw new Exception("Illegal integer argument"); } if ((symbol == '\u2266') | (symbol == '\u2267')) { if (!ElementaryBinaryOperation.IsNumber(typeB)) { throw new Exception("Illegal integer argument"); } type = typeA; return(this); } if (!typeA.Equals(typeB)) { throw new Exception("Different types of integer"); } type = typeA; return(this); }
private static ObjectFormulaTree reduce(ObjectFormulaTree tree) { bool mult = false; if (tree.Operation is ElementaryBinaryOperation) { ElementaryBinaryOperation op = tree.Operation as ElementaryBinaryOperation; if (op.Symbol == '*') { mult = true; } } if (mult) { PolyMult pm = new PolyMult(); for (int i = 0; i < tree.Count; i++) { pm.add(tree); } pm.repeatReduce(); List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(pm.l); pm.l.Clear(); foreach (ObjectFormulaTree t in list) { ObjectFormulaTree r = reduce(t); list.Add(r); pm.add(r); } return(new ObjectFormulaTree(pm, list)); } List <ObjectFormulaTree> listr = new List <ObjectFormulaTree>(); for (int i = 0; i < tree.Count; i++) { listr.Add(reduce(tree[i])); } return(new ObjectFormulaTree(tree.Operation, listr)); }
internal static ObjectFormulaTree MultMult(ObjectFormulaTree tree) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); for (int i = 0; i < tree.Count; i++) { ObjectFormulaTree tr = tree[i]; // tr = ElementaryFormulaSimplification.Object.Simplify(tr); l.Add(MultMult(tr)); } IObjectOperation op = tree.Operation; if (op is ElementaryBinaryOperation) { ElementaryBinaryOperation bo = op as ElementaryBinaryOperation; if (bo.Symbol == '*') { List <ObjectFormulaTree> ll = new List <ObjectFormulaTree>(); PolyMult pm = new PolyMult(); foreach (ObjectFormulaTree t in l) { if (!(t.Operation is PolyMult)) { pm.add(t); ll.Add(t); continue; } for (int i = 0; i < t.Count; i++) { pm.add(t[i]); ll.Add(t[i]); } } return(new ObjectFormulaTree(pm, ll)); } } return(new ObjectFormulaTree(op, l)); }
/// <summary> /// Checks whether tree contains distributions /// </summary> /// <param name="tree">The tree</param> /// <returns>True if contains and false otherwise</returns> static bool CheckDelta(ObjectFormulaTree tree) { int count = 0; if (tree == null) { return(false); } if (tree.Operation is IDistribution) { return(true); } bool b = false; for (int i = 0; i < tree.Count; i++) { ObjectFormulaTree t = tree[i]; if (t == null) { continue; } b |= CheckDelta(t); if (t.Operation is IDistribution) { ++count; } } IObjectOperation op = tree.Operation; if (b) { if (op.InputTypes.Length == 2) { if (op is ElementaryBinaryOperation) { ElementaryBinaryOperation bop = op as ElementaryBinaryOperation; char s = bop.Symbol; if (s != '+' & s != '-' & s != '*') { throwError(); } if (count > 1 & s == '*') { throwError(); } } else if (op is ElementaryFunctionOperation) { ElementaryFunctionOperation eop = op as ElementaryFunctionOperation; char c = eop.Symbol; if (c != '!' & c != '-') { throwError(); } } else { throwError(); } } } return(b | count > 0); }
/// <summary> /// Calculates derivation /// </summary> /// <param name="tree">The function for derivation calculation</param> /// <param name="variableName">Name of variable</param> /// <returns>The derivation</returns> ObjectFormulaTree IDerivationOperation.Derivation(ObjectFormulaTree tree, string variableName) { bool[] b = new bool[] { false, false }; if ((symbol == '+') | (symbol == '-')) // "+" or "-" operation { IObjectOperation op = new ElementaryBinaryOperation(symbol, new object[] { tree[0].ReturnType, tree[1].ReturnType }); List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); for (int i = 0; i < tree.Count; i++) { ObjectFormulaTree t = tree[i].Derivation(variableName); b[i] = ZeroPerformer.IsZero(t); l.Add(t); } if (b[0]) { if (b[1]) { return(ElementaryRealConstant.RealZero); } if (symbol == '+') { return(l[1]); } List <ObjectFormulaTree> ll = new List <ObjectFormulaTree>(); ll.Add(l[1]); return(new ObjectFormulaTree(new ElementaryFunctionOperation('-'), ll)); } if (b[1]) { return(l[0]); } return(new ObjectFormulaTree(op, l)); } ObjectFormulaTree[] der = new ObjectFormulaTree[2]; for (int i = 0; i < 2; i++) { der[i] = tree[i].Derivation(variableName); b[i] = ZeroPerformer.IsZero(der[i]); } if (symbol == '*') // "*" - operation { List <ObjectFormulaTree> list = new List <ObjectFormulaTree>(); for (int i = 0; i < 2; i++) { List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); l.Add(tree[i]); l.Add(der[1 - i]); ElementaryBinaryOperation o = new ElementaryBinaryOperation('*', new object[] { l[0].ReturnType, l[1].ReturnType }); list.Add(new ObjectFormulaTree(o, l)); } if (b[0] & b[1]) { return(ElementaryRealConstant.RealZero); } for (int i = 0; i < b.Length; i++) { if (b[i]) { return(list[i]); } } ElementaryBinaryOperation op = new ElementaryBinaryOperation('+', new object[] { list[0].ReturnType, list[1].ReturnType }); return(new ObjectFormulaTree(op, list)); } return(null); }
/// <summary> /// Calculates result of this operation /// </summary> public object this[object[] x] { get { int i = 0; if (!ElementaryBinaryOperation.IsNegative(x[0]) & ElementaryBinaryOperation.IsNegative(x[1])) { i = 1; } else if (ElementaryBinaryOperation.IsNegative(x[0]) & !ElementaryBinaryOperation.IsNegative(x[1])) { i = -1; } if (!ElementaryBinaryOperation.IsInteger64(x[0]) | !ElementaryBinaryOperation.IsInteger64(x[0])) { double a = Converter.ToDouble(x[0]); double b = Converter.ToDouble(x[1]); if (a > b) { i = 1; } if (a < b) { i = -1; } } else { long a = Converter.ToInt64(x[0]); long b = Converter.ToInt64(x[1]); if (a > b) { i = 1; } if (a < b) { i = -1; } } if (symbol == '>') { return(i == 1); } if (symbol == '<') { return(i == -1); } if (symbol == '\u2260') { return(i != 0); } if (symbol == '\u2264') { return(i != 1); } if (symbol == '\u2265') { return(i != -1); } return(false); } }
/// <summary> /// Calculates derivation /// </summary> /// <param name="tree">The function for derivation calculation</param> /// <param name="variableName">Name of variable</param> /// <returns>The derivation</returns> public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName) { Double a = 0; ObjectFormulaTree[] fc = new ObjectFormulaTree[2]; ObjectFormulaTree[] fd = new ObjectFormulaTree[2]; bool[] b = new bool[] { false, false }; for (int i = 0; i < 2; i++) { fc[i] = tree[i];//.Clone() as ObjectFormulaTree; fd[i] = fc[i].Derivation(variableName); bool bb = ZeroPerformer.IsZero(fd[i]); b[i] = bb; if (!bb) { // glo = true; } } if (b[1]) { double rs = (double)fc[1].Result; if (rs == 1) { return(fd[0]); } } List <ObjectFormulaTree> mainList = new List <ObjectFormulaTree>(); IObjectOperation mainOperation = new ElementaryBinaryOperation('+', new object[] { a, a }); List <ObjectFormulaTree> firstList = new List <ObjectFormulaTree>(); IObjectOperation firstOperation = new ElementaryBinaryOperation('*', new object[] { a, a }); List <ObjectFormulaTree> secondList = new List <ObjectFormulaTree>(); IObjectOperation secondOperation = new ElementaryBinaryOperation('*', new object[] { a, a }); List <ObjectFormulaTree> firstFirstList = new List <ObjectFormulaTree>(); firstFirstList.Add(fc[1]); IObjectOperation firstFirstOperation = new ElementaryBinaryOperation('*', new object[] { a, a }); IObjectOperation firstFirstSecondOperation = new ElementaryPowerOperation(valType, powType); List <ObjectFormulaTree> firstFirstSecondList = new List <ObjectFormulaTree>(); firstFirstSecondList.Add(fc[0]); List <ObjectFormulaTree> firstFirstSecondSecondList = new List <ObjectFormulaTree>(); IObjectOperation firstFirstSecondSecondOperation = new ElementaryBinaryOperation('-', new object[] { a, a }); ObjectFormulaTree fcd = fd[1]; firstFirstSecondSecondList.Add(fc[1]); IObjectOperation firstFirstSecondSecondSecondOperation = new ElementaryRealConstant(1); ObjectFormulaTree firstFirstSecondSecondSecondTree = new ObjectFormulaTree(firstFirstSecondSecondSecondOperation, new List <ObjectFormulaTree>()); firstFirstSecondSecondList.Add(firstFirstSecondSecondSecondTree); ObjectFormulaTree firstFirstSecondSecondTree = null; bool unityDeg = false; if (ZeroPerformer.IsZero(fd[1])) { double f2d = (double)tree[1].Result - 1; if (f2d == 1) { unityDeg = true; } ElementaryRealConstant erc = new ElementaryRealConstant(f2d); firstFirstSecondSecondTree = new ObjectFormulaTree(erc, new List <ObjectFormulaTree>()); } else { firstFirstSecondSecondTree = new ObjectFormulaTree(firstFirstSecondSecondOperation, firstFirstSecondSecondList); } firstFirstSecondList.Add(firstFirstSecondSecondTree); ObjectFormulaTree firstFirstSecondTree = null; if (unityDeg) { firstFirstSecondTree = fc[0]; } else { firstFirstSecondTree = new ObjectFormulaTree(firstFirstSecondOperation, firstFirstSecondList); } firstFirstList.Add(firstFirstSecondTree); ObjectFormulaTree firstFirstTree = new ObjectFormulaTree(firstFirstOperation, firstFirstList); firstList.Add(firstFirstTree); firstList.Add(fd[0]); ObjectFormulaTree firstTree = new ObjectFormulaTree(firstOperation, firstList); mainList.Add(firstTree); // Second part IObjectOperation secondFirstOperation = new ElementaryBinaryOperation('*', new object[] { a, a }); List <ObjectFormulaTree> secondFirstList = new List <ObjectFormulaTree>(); IObjectOperation secondFirstFirstOperation = new ElementaryFunctionOperation('l'); List <ObjectFormulaTree> secondFirstFirstList = new List <ObjectFormulaTree>(); secondFirstFirstList.Add(fc[0]);//.Clone() as ObjectFormulaTree); ObjectFormulaTree secondFirstFirstTree = new ObjectFormulaTree(secondFirstFirstOperation, secondFirstFirstList); secondFirstList.Add(secondFirstFirstTree); secondFirstList.Add(tree);//.Clone() as ObjectFormulaTree); ObjectFormulaTree secondFirstTree = new ObjectFormulaTree(secondFirstOperation, secondFirstList); secondList.Add(secondFirstTree); secondList.Add(fd[1]); ObjectFormulaTree secondTree = new ObjectFormulaTree(secondOperation, secondList); mainList.Add(secondTree); if (b[0] & b[1]) { return(ElementaryRealConstant.RealZero); } for (int i = 0; i < 2; i++) { if (b[i]) { return(mainList[1 - i]); } } return(new ObjectFormulaTree(mainOperation, mainList)); }
private static ObjectFormulaTree sumSumInverse(PolySum ps) { Dictionary <ObjectFormulaTree, bool> d = new Dictionary <ObjectFormulaTree, bool>(ps.summands); ObjectFormulaTree first = null; ObjectFormulaTree second = null; bool bf = true; foreach (ObjectFormulaTree t in d.Keys) { if (ElementaryFormulaSimplification.IsConst(t)) { first = t; } } if (first == null) { if (d.Count > 0) { foreach (ObjectFormulaTree t in d.Keys) { first = t; bf = d[t]; break; } } } if (first == null) { ElementaryRealConstant er = new ElementaryRealConstant(0); return(new ObjectFormulaTree(er, new List <ObjectFormulaTree>())); } d.Remove(first); first = sumSumInverse(first); if (!bf) { ElementaryFunctionOperation ef = new ElementaryFunctionOperation('-'); List <ObjectFormulaTree> l = new List <ObjectFormulaTree>(); l.Add(first); first = new ObjectFormulaTree(ef, l); } if (d.Count == 0) { return(first); } ObjectFormulaTree sec = null; foreach (ObjectFormulaTree t in d.Keys) { sec = t; } bool kb = d[sec]; PolySum pp = new PolySum(true); Dictionary <ObjectFormulaTree, bool> dd = pp.summands; foreach (ObjectFormulaTree t in d.Keys) { if (PolyMult.IsZero(t)) { continue; } bool bl = d[t]; if (!kb) { bl = !bl; } dd[t] = bl; } second = sumSumInverse(pp); List <ObjectFormulaTree> lr = new List <ObjectFormulaTree>(); lr.Add(first); lr.Add(second); char c = kb ? '+' : '-'; if (PolyMult.IsZero(second)) { return(first); } Double type = 0; ElementaryBinaryOperation eop = new ElementaryBinaryOperation(c, new object[] { type, type }); return(new ObjectFormulaTree(eop, lr)); }