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 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 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 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 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 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 AddToTree.Tree SplitationAllowedFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = FactorActivation.FactorActivationFx(Dummy, ref UIS); //bool CONTINUE=true; //while (CONTINUE) //{ // CONTINUE = false; // Dummy = SimplifierCommonSubFactor.SimplifierCommonSubFactorCalculatorFx(Dummy, ref CONTINUE, ref UIS); //} return(SplitationAllowed.SplitationAllowedAction(Dummy, ref UIS)); }
static public AddToTree.Tree MulDivisionSorterFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = MulDivisionSorter.ArrangmentNumberAndX(Dummy); bool CONTINUE = false; do { CONTINUE = false; Dummy = MulDivisionSorter.MulDivisionSorterFxAction(Dummy, ref UIS, ref CONTINUE); } while (CONTINUE); return(Dummy); }
static public AddToTree.Tree MinuseToPluSeconverterFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { AddToTree.Tree THREAD = Dummy.ThreadAccess; Dummy.ThreadAccess = null; Dummy = MinuseToPluSeconverter.MinuseToPluSeconverterActionFx(Dummy); Dummy.ThreadAccess = THREAD; Dummy = NumberDivMul.NumberDivMulFx(Dummy, ref UIS); return(Dummy); }
static AddToTree.Tree ConvertAllMinuseToPluseActionFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } int INCREASE = 2147483647 / 3; bool SecOND = true; try { UIS.SetProgressValue(UIS.progressBar5, 0); if ((Dummy.ThreadAccess.SampleAccess == "-") && (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy))) { AddToTree.Tree ONE = new AddToTree.Tree("-1", false); AddToTree.Tree ADD = new AddToTree.Tree("*", false); //Dummy = Dummy.LeftSideAccess; ADD.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess), ONE); ADD.LeftSideAccess.ThreadAccess = ADD; ADD.RightSideAccess.ThreadAccess = ADD; Dummy = Dummy.ThreadAccess; Dummy.SampleAccess = "+"; Dummy.LeftSideAccess = ADD; Dummy.LeftSideAccess.ThreadAccess = Dummy; SecOND = false; } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } UIS.SetProgressValue(UIS.progressBar5, INCREASE + UIS.progressBar5.Value); try { if ((Dummy.SampleAccess == "-") && (SecOND)) { AddToTree.Tree ONE = new AddToTree.Tree("-1", false); AddToTree.Tree ADD = new AddToTree.Tree("*", false); ADD.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.RightSideAccess), ONE); ADD.LeftSideAccess.ThreadAccess = ADD; ADD.RightSideAccess.ThreadAccess = ADD; Dummy.SampleAccess = "+"; Dummy.RightSideAccess = ADD; Dummy.RightSideAccess.ThreadAccess = Dummy; } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } UIS.SetProgressValue(UIS.progressBar5, 2147483647); Dummy.LeftSideAccess = ConvertAllMinuseToPluse.ConvertAllMinuseToPluseActionFx(Dummy.LeftSideAccess, ref UIS); Dummy.RightSideAccess = ConvertAllMinuseToPluse.ConvertAllMinuseToPluseActionFx(Dummy.RightSideAccess, ref UIS); return(Dummy); }
static public AddToTree.Tree DeleteingMulFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { try { Dummy = DeletingMultaplification.ArrangmentToDeleteingMul(Dummy); Dummy = DeletingMultaplification.RepeatedlyDeletedAction(Dummy, ref UIS); //Dummy = Simplifier.SimplifierFxSimpler(Dummy); while (Dummy.ThreadAccess != null) { Dummy = Dummy.ThreadAccess; } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } return(Dummy); }
static AddToTree.Tree SplitationAllowedAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } if (Dummy.SampleAccess == "/") { //ERRORCORECTION31754051.Refer to page 340. Dummy.LeftSideAccess = SplitationAllowed.SplitationAllowedCalculator(Dummy.LeftSideAccess, Dummy.RightSideAccess, ref UIS); } Dummy.LeftSideAccess = SplitationAllowed.SplitationAllowedAction(Dummy.LeftSideAccess, ref UIS); Dummy.RightSideAccess = SplitationAllowed.SplitationAllowedAction(Dummy.RightSideAccess, ref UIS); return(Dummy); }
static public AddToTree.Tree LocalSimplifierFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = SuitableStructureForLocalSimplifier.SuitableStructureForLocalSimplifierFx(Dummy, ref UIS); bool MINUSEPLUSEEQUAL = false; bool MULDIVISIONEQUAL = false; bool MINUSEPLUSWITHNUMBERMULATED = false; bool MULDIVISIONWITHNUMBERMULATED = false; int INCREASE = 2147483647 / 5; do { MINUSEPLUSEEQUAL = false; UIS.SetProgressValue(UIS.progressBar10, 0); Dummy = LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierFx(Dummy, ref MINUSEPLUSEEQUAL, ref UIS); //Dummy = LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierFx(Dummy); UIS.SetProgressValue(UIS.progressBar10, INCREASE + UIS.progressBar10.Value); MULDIVISIONEQUAL = false; //ERROR30174253 :the result is invalid.refer to page338. Dummy = LocalSearchMulDivisionEqualSimplifier.LocalSearchMulDivisionEqualSimplifierFx(Dummy, ref MULDIVISIONEQUAL, ref UIS); UIS.SetProgressValue(UIS.progressBar10, INCREASE + UIS.progressBar10.Value); MINUSEPLUSWITHNUMBERMULATED = false; Dummy = LocalSearchMinusPlusWithNumberMulatedEqualSimplifier.LocalSearchMinusPlusWithNumberMulatedEqualSimplifierFx(Dummy, ref MINUSEPLUSWITHNUMBERMULATED, ref UIS); UIS.SetProgressValue(UIS.progressBar10, INCREASE + UIS.progressBar10.Value); MULDIVISIONWITHNUMBERMULATED = false; //Dummy = LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierFx(Dummy); // Dummy = LocalSearchMinusPlusTowNumberSimplifier.LocalSearchMinusPlusTowNumberSimplifierFx(Dummy); UIS.SetProgressValue(UIS.progressBar10, INCREASE + UIS.progressBar10.Value); Dummy = LocalSearchMulDivionWithNumberMulatedEqualSimplifier.LocalSearchMulDivionWithNumberMulatedEqualSimplifierFx(Dummy, ref MULDIVISIONWITHNUMBERMULATED, ref UIS); // Dummy = Simplifier.SimplifierFxSimpler(Dummy); UIS.SetProgressValue(UIS.progressBar10, 2147483647); } while (MINUSEPLUSEEQUAL || MULDIVISIONEQUAL || MINUSEPLUSWITHNUMBERMULATED || MULDIVISIONWITHNUMBERMULATED); return(Dummy); }
static public AddToTree.Tree NumberDivMulFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { try { AddToTree.Tree THREAD = Dummy.CopyNewTree(Dummy.ThreadAccess); Dummy.ThreadAccess = null; Dummy = NumberDivMul.NumberDivMulFxAction(Dummy, ref UIS); while (Dummy.ThreadAccess != null) { Dummy = Dummy.ThreadAccess; } Dummy.ThreadAccess = THREAD; } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } return(Dummy); }
static public AddToTree.Tree FactorActivationFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { while (!(NotAbledFactors.ISEmpty())) { NotAbledFactors.DELETEFromTreeFirstNode(); } while (!(AbledFactors.ISEmpty())) { AbledFactors.DELETEFromTreeFirstNode(); } while (!(ONLYMULnODE.ISEmpty())) { ONLYMULnODE.DELETEFromTreeFirstNode(); } while (!(MULATEDELEMENTS.ISEmpty())) { MULATEDELEMENTS.DELETEFromTreeFirstNode(); } Dummy = FactorActivation.FactorActivationFirstMinuseOrPluseFx(Dummy, ref UIS); return(Dummy); }
static public AddToTreeTreeLinkList GetMultedElements(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { AddToTreeTreeLinkList HOLDER = new AddToTreeTreeLinkList(); try { if (Dummy.SampleAccess != "*") { HOLDER.ADDToTree(Dummy); } else//ERRORCORECTION912847 :refer to page 302. { while (!((Dummy.LeftSideAccess == null) && (Dummy.RightSideAccess == null))) { //ERROCORECTION172487 ;the non copy strategy cused to invalid result(effection of To be "1").refer to page 302. if (Dummy.LeftSideAccess.SampleAccess != "*") // if (!(HOLDER.FINDTreeWithOutThreadConsideration(Dummy.LeftSideAccess))) { HOLDER.ADDToTree(Dummy.CopyNewTree(Dummy.LeftSideAccess)); Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.LeftSideAccess.SampleAccess = "1"; } if (Dummy.RightSideAccess.SampleAccess != "*") // if (!(HOLDER.FINDTreeWithOutThreadConsideration(Dummy.RightSideAccess))) { HOLDER.ADDToTree(Dummy.CopyNewTree(Dummy.RightSideAccess)); Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.RightSideAccess.SampleAccess = "1"; } Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } return(HOLDER); }
static AddToTree.Tree MulTowDivisionCalculator(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } //int INCREASE = 2147483647; UIS.SetProgressValue(UIS.progressBar6, 0); if (IS.IsMul(Dummy.SampleAccess)) { if (IS.IsDiv(Dummy.LeftSideAccess.SampleAccess) && IS.IsDiv(Dummy.RightSideAccess.SampleAccess)) { AddToTree.Tree MUL = new AddToTree.Tree(null, false); MUL = Dummy.CopyNewTree(Dummy.LeftSideAccess.RightSideAccess); Dummy.LeftSideAccess.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess.LeftSideAccess), Dummy.CopyNewTree(Dummy.RightSideAccess.LeftSideAccess)); Dummy.LeftSideAccess.SampleAccess = "*"; Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.LeftSideAccess; Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess; Dummy.SampleAccess = "/"; Dummy.RightSideAccess.SetLefTandRightCommonlySide(MUL, Dummy.CopyNewTree(Dummy.RightSideAccess.RightSideAccess)); Dummy.RightSideAccess.SampleAccess = "*"; Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess; Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess; } UIS.SetProgressValue(UIS.progressBar6, 2147483647); /* else * if (IS.IsDiv(Dummy.LeftSideAccess.SampleAccess)) * { * AddToTree.Tree MUL = new AddToTree.Tree(null, false); * MUL = Dummy.CopyNewTree(Dummy.RightSideAccess); * Dummy.RightSideAccess = Dummy.LeftSideAccess.RightSideAccess; * Dummy.RightSideAccess.ThreadAccess = Dummy; * * Dummy.SampleAccess = "/"; * * Dummy.LeftSideAccess.RightSideAccess = MUL; * Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess; * Dummy.LeftSideAccess.SampleAccess = "*"; * * * } * else * if (IS.IsDiv(Dummy.RightSideAccess.SampleAccess)) * { * Dummy.SetLefTandRightCommonlySide(Dummy.RightSideAccess,Dummy.LeftSideAccess); * * AddToTree.Tree MUL = new AddToTree.Tree(null, false); * MUL = Dummy.CopyNewTree(Dummy.RightSideAccess); * Dummy.RightSideAccess = Dummy.LeftSideAccess.RightSideAccess; * Dummy.RightSideAccess.ThreadAccess = Dummy; * * Dummy.SampleAccess = "/"; * * Dummy.LeftSideAccess.RightSideAccess = MUL; * Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess; * Dummy.LeftSideAccess.SampleAccess = "*"; * * * } */ } MulTowDivision.MulTowDivisionCalculator(Dummy.LeftSideAccess, ref UIS); MulTowDivision.MulTowDivisionCalculator(Dummy.RightSideAccess, ref UIS); return(Dummy); }
static public AddToTree.Tree SimplifierCommonSubFactorCalculatorFx(AddToTree.Tree Dummy, ref bool CONTINUE, ref UknownIntegralSolver UIS) { if ((Dummy == null) || (!(IS.IsDivInNode(Dummy)))) { return(Dummy); } //ERRORCORECTION2189743 :the Second condition of above is added. int INCREASE = 2147483647 / 9; UIS.SetProgressValue(UIS.progressBar9, 0); if (Dummy.SampleAccess == "/") { UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); Dummy.LeftSideAccess = FactorActivation.FactorActivationFx(Dummy.LeftSideAccess, ref UIS); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); Dummy.RightSideAccess = FactorActivation.FactorActivationFx(Dummy.RightSideAccess, ref UIS); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); /* try * { * Dummy.LeftSideAccess.ThreadAccess = Dummy; * Dummy.RightSideAccess.ThreadAccess = Dummy; * } * catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } */ UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); Dummy = NumberDivMul.NumberDivMulFx(Dummy, ref UIS); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); AddToTreeTreeLinkList COMMONFACTOR = FindSubFactor.FindSubFactorFx(Dummy.LeftSideAccess, Dummy.RightSideAccess); bool ENDLEFT = false; bool ENDRIGHT = false; AddToTree.Tree COMMONSUBFACORT = new AddToTree.Tree(null, false); UIS.SetProgressValue(UIS.progressBar9, INCREASE + UIS.progressBar9.Value); while (!((COMMONFACTOR.ISEmpty())) && ((ENDLEFT && ENDRIGHT))) { CONTINUE = true; COMMONSUBFACORT = COMMONFACTOR.DELETEFromTreeFirstNode(); if (!ENDLEFT) { Dummy.LeftSideAccess = SimplifierCommonSubFactor.SimplifierCommonSubFactorActionLeftSideFx(Dummy.LeftSideAccess, COMMONSUBFACORT, ref ENDLEFT, FindSubFactor.FACTORLISTEDSAccess()); } if (!ENDRIGHT) { Dummy.RightSideAccess = SimplifierCommonSubFactor.SimplifierCommonSubFactorActionRightSideFx(Dummy.RightSideAccess, COMMONSUBFACORT, ref ENDRIGHT, FindSubFactor.NotExpectedAccess()); } Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); } UIS.SetProgressValue(UIS.progressBar9, 2147483647); if (!((IS.IsDivInNode(Dummy.LeftSideAccess)) || (IS.IsDivInNode(Dummy.RightSideAccess)))) { return(Dummy); } } if (Dummy.LeftSideAccess != null) { Dummy.LeftSideAccess = SimplifierCommonSubFactor.SimplifierCommonSubFactorCalculatorFx(Dummy.LeftSideAccess, ref CONTINUE, ref UIS); } if (Dummy.RightSideAccess != null) { Dummy.RightSideAccess = SimplifierCommonSubFactor.SimplifierCommonSubFactorCalculatorFx(Dummy.RightSideAccess, ref CONTINUE, ref UIS); } return(Dummy); }
static public AddToTree.Tree SimplifierCommonSubFactorFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = Spliter.SpliterFx(Dummy, ref UIS); bool CONTINUE = false; //do //{ // CONTINUE = false; Dummy = NumberDivMul.NumberDivMulFx(Dummy, ref UIS); Dummy = SimplifierCommonSubFactor.SimplifierCommonSubFactorCalculatorFx(Dummy, ref CONTINUE, ref UIS); //} while (CONTINUE); return(Dummy); }
static public AddToTree.Tree LocalSearchMinusPlusWithNumberMulatedEqualSimplifierFx(AddToTree.Tree Dummy, ref bool MINUSEPLUSWITHNUMBERMULATED, ref UknownIntegralSolver UIS) { Dummy = MinusPluseSorteStructure.MinusPluseSorteStructureFx(Dummy); return(LocalSearchMinusPlusWithNumberMulatedEqualSimplifier.LocalSearchMinusPlusWithNumberMulatedEqualSimplifierActionFx(Dummy, ref MINUSEPLUSWITHNUMBERMULATED)); }
static void IntegralAnswerGraphicallyWittenActionFx(UknownIntegralSolver UIS) { AddToTreeTreeLinkList DummyLinkList = IntegralAnswerAdding.AnswerAccess.CopyLinkList(); // System.Windows.Forms.MessageBox.Show("2.1-The answer Copied."); AddToTree.Tree Dummy = new AddToTree.Tree(null, false); // System.Windows.Forms.MessageBox.Show("2.2-The Dummy tree newed."); ArrtificialItelligenceForGraphicallyDrawing ArrtificialItelligenceForGraphicallyDrawingFx = UIS.EquationAccess.SenderSampleAccess.AutoSenderAccess.DrawingAccess.ArrtificialItelligenceForGraphicallyDrawingAccess; // System.Windows.Forms.MessageBox.Show("2.3-The Artificial class loaded."); Set DummySet = new Set(); int BigestX = 0, SmallestX = 1000000; // System.Windows.Forms.MessageBox.Show("2.4-The Varibles newed and assigened."); //DummyLinkList = RecursionAndOptimizingLinkList.RecursionAndOptimizingLinkListFx(DummyLinkList); // System.Windows.Forms.MessageBox.Show("3-The answer is recurved."); while (!(DummyLinkList.ISEmpty())) { Dummy = DummyLinkList.DELETEFromTreeFirstNode(); // System.Windows.Forms.MessageBox.Show("4-The answer is Loaded from link list."); if (Dummy != null) { // System.Windows.Forms.MessageBox.Show("5-The answer of link list is not null."); //DummySet = ArrtificialItelligenceForGraphicallyDrawingFx.CreateGraphicallyNodes(Dummy); ArrtificialItelligenceForGraphicallyDrawingFx.InizializingWhenNeedeForAnswerDrawn(Dummy, 40 + BigestX, 40); // System.Windows.Forms.MessageBox.Show("6-The answer is Converted to set and inzizialized."); //ArrtificialItelligenceForGraphicallyDrawingFx.CalculatingXAndYAndWhithAndHeight(DummySet, 40 + BigestX, 40, 15, 15,true); //System.Windows.Forms.MessageBox.Show("5-The answer is calculated."); UIS.EquationAccess.SenderAccess.AutoSenderAccess.DrawingAccess.DrawEachNodeOfArrtificialItelligenceForGraphicallyDrawing(ArrtificialItelligenceForGraphicallyDrawingFx, UIS.EquationAccess, UIS.EquationAccess.SenderAccess.AutoSenderAccess); //System.Windows.Forms.MessageBox.Show("7-The answer is drawned."); ArrtificialItelligenceForGraphicallyDrawingFx.TheBigestValueNodeXForcalculationMethode(DummySet, ref BigestX); ArrtificialItelligenceForGraphicallyDrawingFx.TheSmallestValue(DummySet, ref SmallestX); if (Dummy.Equals("+"))//ERRORCORECTION1245678:The Font Scale became smaller:1394/3/28 { Written.FiveBasicOprators(0); } else if (Dummy.Equals("-")) { Written.FiveBasicOprators(1); } else if (Dummy.Equals("*")) { Written.FiveBasicOprators(2); } else if (Dummy.Equals("/")) { Written.FiveBasicOprators(3); } else if (Dummy.Equals("^")) { Written.FiveBasicOprators(4); } else { Written.DrawNumberAndVaribale(Dummy.SampleAccess); } } } }
static public AddToTree.Tree LocalSearchMinusPlusEqualSimplifierFx(AddToTree.Tree Dummy, ref bool MINUSEPLUSEEQUAL, ref UknownIntegralSolver UIS) { return(LocalSearchMinusPlusEqualSimplifier.LocalSearchMinusPlusEqualSimplifierActionFx(Dummy, ref MINUSEPLUSEEQUAL, ref UIS)); }
static AddToTree.Tree LocalSearchMulDivionWithNumberMulatedEqualSimplifierActionFx(AddToTree.Tree Dummy, ref bool MULDIVISIONWITHNUMBERMULATED, ref UknownIntegralSolver UIS) { if (Dummy == null) { return(Dummy); } bool SimplifiedTrueOtherWiseFalse = false; bool Suitable = false; bool MulTrueDivFalse = false; bool RETURNED = false; float Num = 0; try { if (Dummy.RightSideAccess.SampleAccess == "/") {//ERRORCORECTION19862348761 :Refer to page 288. LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtUp(Dummy.LeftSideAccess, Dummy.RightSideAccess, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED); if (SimplifiedTrueOtherWiseFalse) { Dummy = Dummy.RightSideAccess; if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess)) { Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.RightSideAccess.SampleAccess = "1"; Num = Num * (float)(System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess)); if (Num == 0) { Dummy.LeftSideAccess.SampleAccess = null; } else { Dummy.LeftSideAccess.SampleAccess = Num.ToString(); } MULDIVISIONWITHNUMBERMULATED = true; } /*else * if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess)) * { * Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null); * Dummy.LeftSideAccess.SampleAccess = "1"; * Num = Num / (float)(System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess)); * if (Num == 0) * Dummy.RightSideAccess.SampleAccess = null; * else * Dummy.RightSideAccess.SampleAccess = Num.ToString(); * } * else * { * Dummy.SetLefTandRightCommonlySide(null, null); * if (Num == 0) * Dummy.SampleAccess = null; * else * Dummy.SampleAccess = Num.ToString(); * } */ } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } if (SimplifiedTrueOtherWiseFalse) { Dummy = Dummy.ThreadAccess; AddToTree.Tree HOLDERTHRED = Dummy.ThreadAccess; Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); Dummy.ThreadAccess = HOLDERTHRED; } SimplifiedTrueOtherWiseFalse = false; Suitable = false; MulTrueDivFalse = false; Num = 0; RETURNED = false; try { if (Dummy.LeftSideAccess.SampleAccess == "*") { LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtDown(Dummy.RightSideAccess, Dummy.LeftSideAccess, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED); if (SimplifiedTrueOtherWiseFalse) {//ERRORCORECTION1274 :Refer to page 292. Dummy = Dummy.LeftSideAccess; if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess)) { Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.LeftSideAccess.SampleAccess = "1"; Num = (float)(System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess)) / Num; if (Num == 0) { Dummy.RightSideAccess.SampleAccess = null; } else { Dummy.RightSideAccess.SampleAccess = Num.ToString(); } MULDIVISIONWITHNUMBERMULATED = true; } else if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess)) { Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null); Dummy.RightSideAccess.SampleAccess = "1"; Num = Num * (float)(System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess)); if (Num == 0) { Dummy.LeftSideAccess.SampleAccess = null; } else { Dummy.LeftSideAccess.SampleAccess = Num.ToString(); } MULDIVISIONWITHNUMBERMULATED = true; } else { Dummy.SetLefTandRightCommonlySide(null, null); if (Num == 0) { Dummy.SampleAccess = null; } else { Dummy.SampleAccess = Num.ToString(); } MULDIVISIONWITHNUMBERMULATED = true; } } } } catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); } if (SimplifiedTrueOtherWiseFalse) { Dummy = Dummy.ThreadAccess; AddToTree.Tree HOLDERTHRED = Dummy.ThreadAccess; Dummy = Simplifier.SimplifierFxSimpler(Dummy, ref UIS); Dummy.ThreadAccess = HOLDERTHRED; } LocalSearchMulDivionWithNumberMulatedEqualSimplifier.LocalSearchMulDivionWithNumberMulatedEqualSimplifierActionFx(Dummy.LeftSideAccess, ref MULDIVISIONWITHNUMBERMULATED, ref UIS); LocalSearchMulDivionWithNumberMulatedEqualSimplifier.LocalSearchMulDivionWithNumberMulatedEqualSimplifierActionFx(Dummy.RightSideAccess, ref MULDIVISIONWITHNUMBERMULATED, ref UIS); return(Dummy); }
static public AddToTree.Tree LocalSearchMulDivionWithNumberMulatedEqualSimplifierFx(AddToTree.Tree Dummy, ref bool MULDIVISIONWITHNUMBERMULATED, ref UknownIntegralSolver UIS) { //Dummy = MulDivioneSorteStructure.MulDivioneSorteStructureFx(Dummy); return(LocalSearchMulDivionWithNumberMulatedEqualSimplifier.LocalSearchMulDivionWithNumberMulatedEqualSimplifierActionFx(Dummy, ref MULDIVISIONWITHNUMBERMULATED, ref UIS)); }
static public AddToTree.Tree ChangeFunctionFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = ChangeFunction.ChangeFunctionFxAction(Dummy); return(Simplifier.SimplifierFx(Dummy, ref UIS)); }
private AddToTree.Tree Solver() { UknownIntegralSolver UNKNOWN = this; this.SetProgressValue(progressBar1, 0); int INCREASE = 2147483647 / 10; this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); //ERRORCUASE1715 :ERRROR cause of ERROR317142.the copy operation is not valid. //ERROR3175 :Error in data structure . //ERRORCAUSE0981243 ;The cause ERROR3175 of is at here.Error on copy tree.refer to page 177. if (Enterface.SenderAccess.AutoSenderAccess.NodeAccess.SampleAccess == null && Enterface.SenderAccess.AutoSenderAccess != null) { Enterface.SenderAccess.AutoSenderAccess.NodeAccess = new AddToTree.Tree(Enterface.SenderAccess.AutoSenderAccess.CurrentStirngAccess, false); } AddToTree.Tree Copy = Enterface.SenderAccess.AutoSenderAccess.NodeAccess.CopyNewTree(Enterface.SenderAccess.AutoSenderAccess.NodeAccess); //Copy = TransmisionToDeleteingMinusPluse.TrasmisionToDeleteingMinusPluseFx(Copy); //ERROR918243 :The error at splitation.refer to page 176. //Copy = TransmisionToDeleteingMinusPluse.TrasmisionToDeleteingMinusPluseFx(Copy); AddToTree.Tree CopyNode = null; CopyNode = Copy.CopyNewTree(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); Copy = DeleteingMinusPluseTree.DeleteingMinusPluseFx(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); Copy = Spliter.SpliterFx(Copy, ref UNKNOWN); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); Copy = Simplifier.ArrangmentForSpliter(Copy); //ERROR30175541 :SIMPLIFIER HAS CUASED TO SOME ERRRO.refer to page 176. //ERROR312317 & ERRROR317140 :Error in simplification.refer to page 182. this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); //Copy = Simplifier.SimplifierFx(Copy,ref UNKNOWN); //ERROR30174213 :The Simplified is invalid here.refer to page 180. //Copy = Derivasion.DerivasionOfFX(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); Copy = Integral.IntegralOfFX(Copy, ref UNKNOWN); /*int i = 0; * while (true)new AddToTree.Tree(null, false); * { * //Copy = Integral.DervisionI(i, Copy); * //ERROR981273987 :The error at derivation.refer to page 205. * Copy = Derivasion.DerivasionOfFX(Copy); * //ERROR3017181920 :refer to page 188. * * Copy=Simplifier.SimplifierFx(Copy); * i++; * } */ //LOCATION13174253. refer to page 208. //ERROR3070405060 :The error is here.refer to page 220. //int NUM1 = Integral.NumberOfElements(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); int NUM1 = Integral.NumberOfElements(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); Copy = Simplifier.SimplifierFx(Copy, ref UNKNOWN); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); int NUM2 = Integral.NumberOfElements(Copy); this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); //Copy = RoundTree.RoundTreeMethod(Copy,0); Copy.ThreadAccess = null; Thread t = new Thread(new ThreadStart(Verifing)); t.Start(); //ERRORCORECTION6646464654643211:The Verification Return Valid result:1394/4/9 if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Simplifier.SimplifierFx(RoundTree.RoundTreeMethod(ChangeFunction.ChangeFunctionFx(Derivasion.DerivasionOfFX(Copy.CopyNewTree(Copy), ref UNKNOWN), ref UNKNOWN), RoundTree.MaxFractionalDesimal(CopyNode)), ref UNKNOWN), CopyNode)) { t.Abort(); SetLableValue(label17, "Verifing finished.Integral Answer Calculated is :"); MessageBox.Show("Verify OK"); } else { t.Abort(); SetLableValue(label17, "Verifing finished.Integral Answer Calculated is :"); MessageBox.Show("Verify Failed."); } return(Copy); //this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE); }
static public AddToTree.Tree MulTowDivisionFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = MulTowDivision.MulTowDivisionCalculator(Dummy, ref UIS); return(Dummy); }
static AddToTree.Tree DerivasionCalculator(AddToTree.Tree Node, AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { if (Node == null) { return(Dummy); } if (Node.SampleAccess == "x") { Dummy.SampleAccess = "1"; return(Dummy); } //ERROR317142 :The structure is ok.refer to page 155. //ERRORCORECTION30704012 :The error correced.refer to page 155. if (Node.LeftSideAccess != null) { if (Node.LeftSideAccess.LeftSideAccess == null) { if (Node.LeftSideAccess.RightSideAccess == null) { if (IS.IsFunction(Node.SampleAccess)) { Dummy = Derivasion.ConsTantFuctionDerivasion(Node); return(Dummy); } else if (IS.IsNumber(Dummy.SampleAccess)) { Dummy = null; return(Dummy); } } } } if (Node.SampleAccess == "/") { AddToTree.Tree Minuse = new AddToTree.Tree("-", false); AddToTree.Tree MulL = new AddToTree.Tree("*", false); AddToTree.Tree MulR = new AddToTree.Tree("*", false); AddToTree.Tree Power = new AddToTree.Tree("^", false); AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); AddToTree.Tree NRMulL = new AddToTree.Tree(null, false); AddToTree.Tree NRMulR = new AddToTree.Tree(null, false); AddToTree.Tree GX = Node.CopyNewTree(Node.RightSideAccess); AddToTree.Tree IND = new AddToTree.Tree("2", false); DFX = Derivasion.DerivasionOfFX(Node.LeftSideAccess, ref UIS); NRMulL = Node.RightSideAccess; MulL.SetLefTandRightCommonlySide(DFX, NRMulL); MulL.LeftSideAccess.ThreadAccess = MulL; MulL.RightSideAccess.ThreadAccess = MulL; DGX = Derivasion.DerivasionOfFX(Node.RightSideAccess, ref UIS); NRMulR = Node.LeftSideAccess; MulR.SetLefTandRightCommonlySide(DGX, NRMulR); MulR.LeftSideAccess.ThreadAccess = MulR; MulR.RightSideAccess.ThreadAccess = MulR; Minuse.SetLefTandRightCommonlySide(MulL, MulR); Minuse.LeftSideAccess.ThreadAccess = Minuse; Minuse.RightSideAccess.ThreadAccess = Minuse; Power.SetLefTandRightCommonlySide(GX, IND); Power.LeftSideAccess.ThreadAccess = Power; Power.RightSideAccess.ThreadAccess = Power; Dummy.SampleAccess = "/"; Dummy.SetLefTandRightCommonlySide(Minuse, Power); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } else if (Node.SampleAccess == "*") { AddToTree.Tree MulL = new AddToTree.Tree("*", false); AddToTree.Tree MulR = new AddToTree.Tree("*", false); AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); AddToTree.Tree NRMulL = new AddToTree.Tree(null, false); AddToTree.Tree NRMulR = new AddToTree.Tree(null, false); DFX = Derivasion.DerivasionOfFX(Node.LeftSideAccess, ref UIS); DGX = Derivasion.DerivasionOfFX(Node.RightSideAccess, ref UIS); NRMulL = Node.LeftSideAccess; NRMulR = Node.RightSideAccess; MulL.SetLefTandRightCommonlySide(DFX, NRMulR); MulL.LeftSideAccess.ThreadAccess = MulL; if (NRMulR.SampleAccess != null) { MulL.RightSideAccess.ThreadAccess = MulL; } MulR.SetLefTandRightCommonlySide(Node.LeftSideAccess, DGX); MulR.LeftSideAccess.ThreadAccess = MulR; if (DGX.SampleAccess != null) { MulR.RightSideAccess.ThreadAccess = MulR; } Dummy.SampleAccess = "+"; Dummy.SetLefTandRightCommonlySide(MulL, MulR); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } else if (Node.SampleAccess == "-") { AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); DFX = Derivasion.DerivasionOfFX(Node.LeftSideAccess, ref UIS); DGX = Derivasion.DerivasionOfFX(Node.RightSideAccess, ref UIS); Dummy.SampleAccess = "-"; Dummy.SetLefTandRightCommonlySide(DFX, DGX); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } else if (Node.SampleAccess == "+") { AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); DFX = Derivasion.DerivasionOfFX(Node.LeftSideAccess, ref UIS); DGX = Derivasion.DerivasionOfFX(Node.RightSideAccess, ref UIS); Dummy.SampleAccess = "+"; Dummy.SetLefTandRightCommonlySide(DFX, DGX); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } else if (Node.SampleAccess == "^") { AddToTree.Tree ADD = new AddToTree.Tree("+", false); AddToTree.Tree Copy = Node.CopyNewTree(Node); AddToTree.Tree LnFX = new AddToTree.Tree("Ln", false); AddToTree.Tree FXONE = Node.CopyNewTree(Node.LeftSideAccess); AddToTree.Tree FXTOW = Node.CopyNewTree(Node.LeftSideAccess); AddToTree.Tree GX = Node.CopyNewTree(Node.RightSideAccess); AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); AddToTree.Tree MulLevelTowL = new AddToTree.Tree("*", false); AddToTree.Tree MulLevelTowR = new AddToTree.Tree("*", false); AddToTree.Tree DIVThree = new AddToTree.Tree("/", false); FXONE.ThreadAccess = null; DFX = Derivasion.DerivasionOfFX(FXONE, ref UIS); GX.ThreadAccess = null; DGX = Derivasion.DerivasionOfFX(GX, ref UIS); DIVThree.SetLefTandRightCommonlySide(DFX, FXONE); DIVThree.LeftSideAccess.ThreadAccess = DIVThree; DIVThree.RightSideAccess.ThreadAccess = DIVThree; MulLevelTowR.SetLefTandRightCommonlySide(GX, DIVThree); MulLevelTowR.LeftSideAccess.ThreadAccess = MulLevelTowR; MulLevelTowR.RightSideAccess.ThreadAccess = MulLevelTowR; LnFX.SetLefTandRightCommonlySide(FXTOW, null); LnFX.LeftSideAccess.ThreadAccess = LnFX; LnFX.RightSideAccess = null; MulLevelTowL.SetLefTandRightCommonlySide(DGX, LnFX); MulLevelTowL.LeftSideAccess.ThreadAccess = MulLevelTowL; MulLevelTowL.RightSideAccess.ThreadAccess = MulLevelTowL; ADD.SetLefTandRightCommonlySide(MulLevelTowL, MulLevelTowR); ADD.LeftSideAccess.ThreadAccess = ADD; ADD.RightSideAccess.ThreadAccess = ADD; Dummy.SampleAccess = "*"; Dummy.SetLefTandRightCommonlySide(Copy, ADD); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } else if (IS.IsFunction(Node.SampleAccess)) { AddToTree.Tree DFoGX = Node.CopyNewTree(Node); AddToTree.Tree FX = (Node); AddToTree.Tree GX = Node.RightSideAccess; AddToTree.Tree DFX = new AddToTree.Tree(null, false); AddToTree.Tree DGX = new AddToTree.Tree(null, false); FX.LeftSideAccess.SetLefTandRightCommonlySide(null, null); FX.LeftSideAccess.SampleAccess = "x"; DFX = Derivasion.DerivasionOfFX(FX, ref UIS); DGX = Derivasion.DerivasionOfFX(Node.LeftSideAccess, ref UIS); /*DFoGX.SetLefTandRightCommonlySide(DFX,null); * DFoGX.SampleAccess = DFX.SampleAccess; * DFoGX.LeftSideAccess.ThreadAccess = DFoGX; * if(DFoGX.RightSideAccess!=null) * DFoGX.RightSideAccess.ThreadAccess = DFoGX; */ DFoGX = Derivasion.ReplaceXToFX(DFX, Node.RightSideAccess); Dummy.SampleAccess = "*"; Dummy.SetLefTandRightCommonlySide(DGX, DFoGX); Dummy.LeftSideAccess.ThreadAccess = Dummy; Dummy.RightSideAccess.ThreadAccess = Dummy; } return(Dummy); }
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); }
static public AddToTree.Tree BesidesAverageFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS) { Dummy = AddingDivisionToThreeDivStructure.AddingDivisionToThreeDivStructureFx(Dummy); return(BesidesAverage.BesidesAverageActionFx(Dummy, ref UIS)); }