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));
}
