public bool FINDTreeWithThreadConsiderationOfIntegrals(AddToTree.Tree Dummy, out float Quefiicent) { LinkListNodeClass Tracer = Node; bool Is = false; Quefiicent = 1; while (Tracer != null) { if (Tracer.CurrentAccess != null) { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, Tracer.CurrentAccess)) { Is = true; //break; Quefiicent = (float)System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess); } } if (Tracer.CurrentAccess != null) { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, Tracer.CurrentAccess)) { Is = true; Quefiicent = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess); break; } } Tracer = Tracer.NextAccess; } return(Is); }
public bool FINDTreeWithThreadConsideration(AddToTree.Tree Dummy) { LinkListNodeClass Tracer = Node; try { } catch (NullReferenceException k) { ExceptionClass.ExceptionClassMethod(k); } bool Is = false; while (Tracer != null) { if (Tracer.CurrentAccess != null) { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Tracer.CurrentAccess)) { Is = true; break; } } Tracer = Tracer.NextAccess; } return(Is); }
static public bool IsEqualWithOutThreadConsiderationByDivision(AddToTree.Tree T1, AddToTree.Tree T2, ref UknownIntegralSolver UIS) { bool Is = false; AddToTree.Tree Code = new AddToTree.Tree("/", false); Code.SetLefTandRightCommonlySide(T1.CopyNewTree(T1), T2.CopyNewTree(T2)); try { Code.LeftSideAccess.ThreadAccess = Code; } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } try { Code.RightSideAccess.ThreadAccess = Code; } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } Code = Simplifier.SimplifierFx(Code, ref UIS); if ((Code.SampleAccess == "1") && (Code.LeftSideAccess == null) && (Code.RightSideAccess == null)) { Is = true; } return(Is); }
static public AddToTree.Tree SpliterFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { try { Dummy.ThreadAccess = null; Dummy = Simplifier.ArrangmentForSpliter(Dummy); Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); //ERRORCORECTION198234871648 :The condition of splitation added.refer to page 339. Dummy = SplitationAllowed.SplitationAllowedFx(Dummy, ref UIS); bool CONTINUSE = false; do { CONTINUSE = false; if (Spliter.ISAtLeastOneDivisionAtNode(Dummy)) { Dummy = Spliter.SpliterCalculator(Dummy, ref CONTINUSE, ref UIS); } }while (CONTINUSE); } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } return(Dummy); }
static AddToTree.Tree FactorActivationFirstMinuseOrPluseFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } if ((FactorActivation.SuitableForFactorActivation(Dummy.CopyNewTree(Dummy))) && ((Dummy.SampleAccess == "+") || (Dummy.SampleAccess == "-"))) { FactorActivation.FactorActivationOnlyMuLnodesListedFx(Dummy.CopyNewTree(Dummy)); Dummy = FactorActivation.FactorActivationActionFx(Dummy, ref UIS); } while (!(NotAbledFactors.ISEmpty())) { NotAbledFactors.DELETEFromTreeFirstNode(); } while (!(AbledFactors.ISEmpty())) { AbledFactors.DELETEFromTreeFirstNode(); } while (!(ONLYMULnODE.ISEmpty())) { ONLYMULnODE.DELETEFromTreeFirstNode(); } while (!(MULATEDELEMENTS.ISEmpty())) { MULATEDELEMENTS.DELETEFromTreeFirstNode(); } Dummy.LeftSideAccess = FactorActivation.FactorActivationFirstMinuseOrPluseFx(Dummy.LeftSideAccess, ref UIS); Dummy.RightSideAccess = FactorActivation.FactorActivationFirstMinuseOrPluseFx(Dummy.RightSideAccess, ref UIS); return(Dummy); }
static private bool MulAndDivisionOnlySimplifierFindDivisionOperandIfIsDelettingFx(AddToTree.Tree Dummy, AddToTree.Tree NodeDeleted) { bool Is = false; if (Dummy == null) { return(Is); } if (MulAndDivisionOnlySimplifier.IsCurrentNodeMulOrDivisionOnly(Dummy)) { if (!Is) { if (Dummy.SampleAccess == "/") { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, NodeDeleted)) { AddToTree.Tree Num = new AddToTree.Tree("1", false); Dummy.RightSideAccess = Num; Dummy.RightSideAccess.LeftSideAccess = Dummy.RightSideAccess; Dummy.RightSideAccess.RightSideAccess = Dummy.RightSideAccess; Is = true; } } } } Is = Is || MulAndDivisionOnlySimplifier.MulAndDivisionOnlySimplifierFindDivisionOperandIfIsDelettingFx(Dummy.LeftSideAccess, NodeDeleted); Is = Is || MulAndDivisionOnlySimplifier.MulAndDivisionOnlySimplifierFindDivisionOperandIfIsDelettingFx(Dummy.RightSideAccess, NodeDeleted); return(Is); }
static AddToTree.Tree AddingSameUnderElementsSenderActionFx(AddToTree.Tree Node, AddToTree.Tree Dummy, ref bool CllingRightTrueLeftFalse, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } try { if ((IS.IsPluSinNode(Dummy))) { CllingRightTrueLeftFalse = false; Dummy.LeftSideAccess = AddingSameUnderElements.AddingSameUnderElementsSenderActionFx(Node, Dummy.LeftSideAccess, ref CllingRightTrueLeftFalse, ref UIS); if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess)) { Dummy = Dummy.LeftSideAccess; } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } try { if ((IS.IsPluSinNode(Dummy))) { CllingRightTrueLeftFalse = true; Dummy.RightSideAccess = AddingSameUnderElements.AddingSameUnderElementsSenderActionFx(Node, Dummy.RightSideAccess, ref CllingRightTrueLeftFalse, ref UIS); //ERRORCORECTION6654444:The Deleting Unregular Plus Operator From Sin(x)^2 Integral:1394/4/6 if (Dummy.RightSideAccess.ThreadAccess != null && EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess.ThreadAccess, Dummy.ThreadAccess)) { Dummy = Dummy.RightSideAccess; } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } if (Dummy.ThreadAccess != null) { if (!(((IS.IsMinuseOrPluse(Dummy.ThreadAccess.SampleAccess))))) { return(Dummy); } } try { if ((Dummy.ThreadAccess == null) || (Dummy.ThreadAccess.SampleAccess == "+")) { if (Dummy.SampleAccess == "/") { /* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy)) * Dummy.ThreadAccess.LeftSideAccess = AddingSameUnderElements.AddingSameUnderElementsActionReciverFx(Node, Dummy.ThreadAccess.LeftSideAccess, Dummy,ref CllingRightTrueLeftFalse); * else * if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.LeftSideAccess, Dummy)) * Dummy.ThreadAccess.RightSideAccess = AddingSameUnderElements.AddingSameUnderElementsActionReciverFx(Node, Dummy.ThreadAccess.RightSideAccess, Dummy,ref CllingRightTrueLeftFalse); */ Dummy.ThreadAccess = AddingSameUnderElements.AddingSameUnderElementsActionReciverFx(Node, Dummy.ThreadAccess, Dummy, ref CllingRightTrueLeftFalse, ref UIS); } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } return(Dummy); }
public static int MaxFractionalDesimal(AddToTree.Tree T) { int A = 0; if (T == null) { return(A); } if (IS.IsNumber(T.SampleAccess) && T.SampleAccess.IndexOf(".") != -1) { String S = T.SampleAccess.Substring(T.SampleAccess.IndexOf("."), T.SampleAccess.Length - T.SampleAccess.IndexOf(".")); if (A < S.Length) { A = S.Length; } } int S1 = MaxFractionalDesimal(T.LeftSideAccess); int S2 = MaxFractionalDesimal(T.RightSideAccess); if (S1 > A) { A = S1; } if (S2 > A) { A = S2; } return(A); }
//static SenderSample Sender = new SenderSample(new Equation()); static public AddToTree.Tree DerivasionOfFX(AddToTree.Tree Node, ref UknownIntegralSolver UIS) { AddToTree.Tree Dummy = new AddToTree.Tree(null, false); Dummy = Derivasion.DerivasionCalculator(Node, Dummy, ref UIS); Dummy = Simplifier.SimplifierFx(Dummy, ref UIS); return(Dummy); }
static AddToTree.Tree LocalSearchMulDivisionEqualSimplifierActionFx(AddToTree.Tree Dummy, ref bool MULDIVISIONEQUAL, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } bool SimplifiedTrueOtherWiseFalse = false; bool Suitable = false; bool DivTrueMulFalse = false; LocalSearchMulDivisionEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtLeft(Dummy.RightSideAccess, Dummy.LeftSideAccess, ref Suitable, ref DivTrueMulFalse, ref SimplifiedTrueOtherWiseFalse); if (SimplifiedTrueOtherWiseFalse) { Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.LeftSideAccess.SampleAccess = "1"; MULDIVISIONEQUAL = true; } SimplifiedTrueOtherWiseFalse = false; Suitable = false; DivTrueMulFalse = false; LocalSearchMulDivisionEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy.LeftSideAccess, Dummy.RightSideAccess, ref Suitable, ref DivTrueMulFalse, ref SimplifiedTrueOtherWiseFalse); if (SimplifiedTrueOtherWiseFalse) { Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.RightSideAccess.SampleAccess = "1"; MULDIVISIONEQUAL = true; } Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); LocalSearchMulDivisionEqualSimplifier.LocalSearchMulDivisionEqualSimplifierActionFx(Dummy.LeftSideAccess, ref MULDIVISIONEQUAL, ref UIS); LocalSearchMulDivisionEqualSimplifier.LocalSearchMulDivisionEqualSimplifierActionFx(Dummy.RightSideAccess, ref MULDIVISIONEQUAL, ref UIS); return(Dummy); }
static AddToTree.Tree ReplaceXToFX(AddToTree.Tree Dummy, AddToTree.Tree FX) { if (Dummy.LeftSideAccess != null) { if (Dummy.LeftSideAccess.SampleAccess == "x") { Dummy.SetLefTandRightCommonlySide(FX, Dummy.RightSideAccess); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; return(Dummy); } } else { return(Dummy); } if (Dummy.RightSideAccess != null) { if (Dummy.RightSideAccess.SampleAccess == "x") { Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, FX); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; return(Dummy); } } else { return(Dummy); } Derivasion.ReplaceXToFX(Dummy.LeftSideAccess, FX); Derivasion.ReplaceXToFX(Dummy.RightSideAccess, FX); return(Dummy); }
static public AddToTree.Tree MulAndDivisionOnlySimplifierFx(AddToTree.Tree Dummy) { // if (MulAndDivisionOnlySimplifier.IsCurrentNodeMulOrDivisionOnly(Dummy)) return(MulAndDivisionOnlySimplifier.MulAndDivisionOnlySimplifierFxAction(Dummy)); //else // return Dummy; }
static void FindSubFactorActionFx(AddToTree.Tree Dummy1, AddToTree.Tree Dummy2) { FindSubFactor.FindSubFactorCommonAddedToListFx(Dummy1); //ERRORCORECTION1287648764 :The condition caused to Non Requirment Supliments of data. //if(Dummy2.SampleAccess == "*") FindSubFactor.FindSubFactorCommonFinalizationFx(Dummy2); }
static AddToTree.Tree MinuseToPluSeconverterActionFx(AddToTree.Tree Dummy) { if (Dummy == null) { return(null); } try { if (Dummy.SampleAccess == "-") { if (Dummy.ThreadAccess.SampleAccess == "-") { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy)) { Dummy.ThreadAccess.SampleAccess = "+"; AddToTree.Tree CONVERT = new AddToTree.Tree("*", false); AddToTree.Tree Minuse = new AddToTree.Tree("-1", false); CONVERT.SetLefTandRightCommonlySide(Minuse, Dummy.CopyNewTree(Dummy.LeftSideAccess)); CONVERT.LeftSideAccess.ThreadAccess = CONVERT; CONVERT.RightSideAccess.ThreadAccess = CONVERT; CONVERT.ThreadAccess = Dummy; Dummy.LeftSideAccess = CONVERT; } } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } MinuseToPluSeconverter.MinuseToPluSeconverterActionFx(Dummy.LeftSideAccess); MinuseToPluSeconverter.MinuseToPluSeconverterActionFx(Dummy.RightSideAccess); return(Dummy); }
static public void IntegralAnswerGraphicallyWittenFx(AddToTree.Tree Dummy, UknownIntegralSolver UIS) { IntegralAnswerAdding.IntegralAnswerAddingFx(Dummy); //System.Windows.Forms.MessageBox.Show("2-The answer Added"); IntegralAnswerGraphicallyWitten.IntegralAnswerGraphicallyWittenActionFx(UIS); Written.ShowDialog(); }
static public AddToTree.Tree ConvertAllMinuseToPluseFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = ConvertAllMinuseToPluse.ConvertAllMinuseToPluseActionFx(Dummy, ref UIS); //ERROR31754015 :Refer to page 338. Dummy = NumberDivMul.NumberDivMulFx(Dummy, ref UIS); return(Dummy); }
static AddToTree.Tree SplitationAllowedCalculator(AddToTree.Tree Dummy, AddToTree.Tree UNDER, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } if ((Dummy.ThreadAccess.SampleAccess == "/") || (Dummy.ThreadAccess.SampleAccess == "*")) { AddToTreeTreeLinkList ELEMENTS = FactorActivation.GetBigestCommonFactor(UNDER.CopyNewTree(UNDER), ref UIS); AddToTree.Tree UNDERDummy = new AddToTree.Tree(null, false); while (!(ELEMENTS.ISEmpty())) { UNDERDummy = ELEMENTS.DELETEFromTreeFirstNode(); if ((Dummy.SampleAccess == "+") && (IS.IsPluSinNode(UNDERDummy)) && (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy, UNDERDummy))) { Dummy.SplitableAccess = false; } } } else { return(Dummy); } Dummy.LeftSideAccess = SplitationAllowed.SplitationAllowedCalculator(Dummy.LeftSideAccess, UNDER, ref UIS); Dummy.RightSideAccess = SplitationAllowed.SplitationAllowedCalculator(Dummy.RightSideAccess, UNDER, ref UIS); return(Dummy); }
static bool AllowToMulMinusePluseActionFx(AddToTree.Tree Dummy) { if (Dummy == null) { return(true); } bool Is = true; if (Dummy.SampleAccess == "/") { if (IS.IsMinuseOrPluse(Dummy.SampleAccess)) { AddToTreeTreeLinkList FACTOR = FindSubFactor.FindSubFactorFx(Dummy.LeftSideAccess, Dummy.RightSideAccess); if (!(FACTOR.ISEmpty())) { AddToTree.Tree FACT = new AddToTree.Tree(null, false); do { FACT = FACTOR.DELETEFromTreeFirstNode(); if (IS.IsMinuseOrPluse(FACT.SampleAccess)) { Is = false; } }while(!(FACTOR.ISEmpty())); } } } Is = Is && (AllowToMulMinusePluse.AllowToMulMinusePluseActionFx(Dummy.LeftSideAccess)); Is = Is && (AllowToMulMinusePluse.AllowToMulMinusePluseActionFx(Dummy.RightSideAccess)); return(Is); }
static public Tree DeleteTree(AddToTree.Tree Exsit, AddToTree.Tree Deleted) { if (Exsit == null) { return(null); } if (Deleted == null) { return(null); } AddToTree.Tree Current = new AddToTree.Tree(null, false); if (!Formulas.EqualToObject.IsEqualWithThreadConsiderationCommonly(Exsit, Deleted)) { try { Current.SampleAccess = Exsit.SampleAccess; Current.SetLefTandRightCommonlySide(AddToTree.Tree.DeleteTree(Exsit.LeftSideAccess, Deleted), AddToTree.Tree.DeleteTree(Exsit.RightSideAccess, Deleted)); //ERRORCORECTION091824098.refer to page 177. Current.LeftSideAccess.ThreadAccess = Exsit.LeftSideAccess.ThreadAccess; Current.RightSideAccess.ThreadAccess = Exsit.RightSideAccess.ThreadAccess; } catch (NullReferenceException t) { Formulas.ExceptionClass.ExceptionClassMethod(t); } } else { Tree.DeleteTree(Exsit.LeftSideAccess, Deleted.LeftSideAccess); Tree.DeleteTree(Exsit.RightSideAccess, Deleted.RightSideAccess); } return(Current); }
static AddToTree.Tree LocalSearchMinusPlusEqualSimplifierActionFx(AddToTree.Tree Dummy, ref bool MINUSEPLUSEEQUAL, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } bool SimplifiedTrueOtherWiseFalse = false; bool Suitable = false; bool MinuseTruePluseFalse = false; LocalSearchMinusPlusEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtLeft(Dummy, Dummy.LeftSideAccess, out Suitable, out MinuseTruePluseFalse, out SimplifiedTrueOtherWiseFalse); if (SimplifiedTrueOtherWiseFalse) { Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.LeftSideAccess.SampleAccess = null; MINUSEPLUSEEQUAL = true; } SimplifiedTrueOtherWiseFalse = false; Suitable = false; MinuseTruePluseFalse = false; LocalSearchMinusPlusEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy, Dummy.RightSideAccess, out Suitable, out MinuseTruePluseFalse, out SimplifiedTrueOtherWiseFalse); if (SimplifiedTrueOtherWiseFalse) { Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.RightSideAccess.SampleAccess = null; MINUSEPLUSEEQUAL = true; } LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierActionFx(Dummy.LeftSideAccess, ref MINUSEPLUSEEQUAL, ref UIS); LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierActionFx(Dummy.RightSideAccess, ref MINUSEPLUSEEQUAL, ref UIS); return(Dummy); }
public Tree FINDTreeWithOutThreadConsiderationWithMoreeficiency(AddToTree.Tree Base, AddToTree.Tree Holder) { DummyFind = null; Formulas.UknownIntegralSolver UIS = new Formulas.UknownIntegralSolver(); UIS.Hide(); DummyFind = this.FINDTreeWithOutThreadConsiderationActionWithMoreeficiency(Base, Holder, ref UIS); return(DummyFind); }
static AddToTree.Tree OptimizeNode(AddToTree.Tree Dummy) { while (Dummy.ThreadAccess != null) { Dummy = Dummy.ThreadAccess; } return(Dummy.CopyReferenclyTree(Dummy)); }
static public AddToTree.Tree SortForSplitationFx(AddToTree.Tree Dummy) { if (Dummy.SampleAccess == "/") { Dummy = SortForSplitation.SortForSplitationActionSenderFx(Dummy.LeftSideAccess, Dummy.RightSideAccess); } return(Dummy); }
static public bool AllowToMulMinusePluseFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy.LeftSideAccess = FactorActivation.FactorActivationFx(Dummy.LeftSideAccess, ref UIS); Dummy.RightSideAccess = FactorActivation.FactorActivationFx(Dummy.RightSideAccess, ref UIS); bool Is = AllowToMulMinusePluse.AllowToMulMinusePluseActionFx(Dummy); return(Is); }
static public AddToTree.Tree RecursiveIntegralAdditionFx(AddToTree.Tree Node, AddToTree.Tree Dummy, AddToTree.Tree MULTOW, float Queficient, AddToTreeTreeLinkList INTEGRALS, AddToTreeTreeLinkList ANSWER) { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(MULTOW, Node)) { Dummy = RecursiveIntegralAddition.RecursiveIntegralFxAdditionForLinearEquationOneDegrees(Node, Dummy, Queficient); } return(Dummy); }
static AddToTree.Tree FactorActivationActionFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { //ERROR932875987 : Refer to page 301 :If The Non Copy of Dummy Passes to method the result of dummy become invalid. //AddToTree.Tree Factor = FactorActivation.GetBigestCommonFactor(Dummy.CopyNewTree(Dummy)); AddToTreeTreeLinkList FactorLinkList = FactorActivation.GetBigestCommonFactor(Dummy.CopyNewTree(Dummy), ref UIS); bool Action = false; bool Mul = false; if (!(FactorLinkList.ISEmpty())) { AddToTree.Tree Factor = new AddToTree.Tree(null, false); //ERROR293846210394 :The effection of Thread is not act on thread. //AddToTree.Tree Holder = Dummy.CopyNewTree(Dummy.ThreadAccess); //ERROCORECTION91827831294 :The thread validation is corrected.refer to page 335. AddToTree.Tree Holder = Dummy.ThreadAccess; bool LeftTrueRightFalse = false; try { if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy)) { LeftTrueRightFalse = false; } else { LeftTrueRightFalse = true; } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } Dummy.ThreadAccess = null; while (!(FactorLinkList.ISEmpty())) { Factor = FactorLinkList.DELETEFromTreeFirstNode(); Dummy = FactorActivation.FactorActivationDivActionFx(Dummy.CopyNewTree(Dummy), Factor, ref Action, ref Mul, FactorLinkList.CopyLinkList()); } while (Dummy.ThreadAccess != null) { Dummy = Dummy.ThreadAccess; } Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); try { if (!LeftTrueRightFalse) { Holder.RightSideAccess = Dummy; } else { Holder.LeftSideAccess = Dummy; } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } Dummy.ThreadAccess = Holder; } return(Dummy); }
static public bool IntegralRecursiveMulatFGFx(AddToTreeTreeLinkList MulAtFG, AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { AddToTree.Tree HOLDER = MulAtFG.DELETEFromTreeFirstNode(); if (Dummy != null) { return(EqualToObject.IsEqualWithOutThreadConsiderationByDivision(HOLDER.CopyNewTree(HOLDER), Dummy.CopyNewTree(Dummy), ref UIS)); } return(false); }
static AddToTree.Tree SuitableStructureForLocalSimplifierFxAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = SuitableStructureForLocalSimplifier.SuitableStructureForLocalSimplifierFxNumberSorter(Dummy); //CORECTION1982798724 :Refer to page 289. bool CONVERSION = false; Dummy = SuitableStructureForLocalSimplifier.SuitableStructureForLocalSimplifierConverstionOfDivToMul(Dummy, ref CONVERSION, ref UIS); return(Dummy); }
static AddToTree.Tree LocalSearchMinusPlusNonEqualSimplifierActionFx(AddToTree.Tree Dummy) { if (Dummy == null) { return(Dummy); } LocalSearchMinusPlusNonEqualSimplifier.LocalSearchMinusPlusNonEqualSimplifierActionFx(Dummy.LeftSideAccess); LocalSearchMinusPlusNonEqualSimplifier.LocalSearchMinusPlusNonEqualSimplifierActionFx(Dummy.RightSideAccess); }
static public AddToTree.Tree DeleteingMinusPluseFx(AddToTree.Tree Dummy) { Dummy = DeleteingMinusPluseTree.ArrangmentToDeleteingMinusPluse(Dummy); Dummy = DeleteingMinusPluseTree.RepeatedlyDeletedAction(Dummy); while (Dummy.ThreadAccess != null) { Dummy = Dummy.ThreadAccess; } return(Dummy); }