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);
}
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);
}
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 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);
}
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 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 IsEqualWithThreadConsiderationCommonly(AddToTree.Tree T1, AddToTree.Tree T2)
{
bool Is = false;
if ((T1 == null) && (T2 == null))
{
return(true);
}
else
if (!(((T1 != null) && (T2 != null))))
{
return(false);
}
try
{
//if ((T1.SampleAccess == T2.SampleAccess)&&(T1.NodeNumberAccess==T2.NodeNumberAccess))
if (T1.SampleAccess == T2.SampleAccess)
{
if ((T1.ThreadAccess == null) && (T2.ThreadAccess == null))
{
Is = true;
}
else
if (!(((T1.ThreadAccess != null) && (T2.ThreadAccess != null))))
{
Is = false;
}
else
if (T1.ThreadAccess.SampleAccess == T2.ThreadAccess.SampleAccess)
{
Is = true;
}
}
else
{
Is = false;
}
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
}
if (!Is)
{
return(Is);
}
Is = Is && EqualToObject.IsEqualWithThreadConsiderationCommonly(T1.LeftSideAccess, T2.LeftSideAccess);
Is = Is && EqualToObject.IsEqualWithThreadConsiderationCommonly(T1.RightSideAccess, T2.RightSideAccess);
return(Is);
}
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 AddToTree.Tree ArrangmentNumberAndX(AddToTree.Tree Dummy)
{
if (Dummy == null)
{
return(Dummy);
}
if (Dummy.LeftSideAccess != null)
{
if (Dummy.RightSideAccess != null)
{
if ((Dummy.SampleAccess == "*") || (Dummy.SampleAccess == "+"))
{
if (Dummy.ThreadAccess != null)
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.LeftSideAccess, Dummy))
{
//if (IS.ISindependenceVaribaleOrNumber(Dummy.LeftSideAccess.SampleAccess))
//if (!IS.IsOperator(Dummy.LeftSideAccess.SampleAccess))
if (IS.IsDiv(Dummy.RightSideAccess.SampleAccess))
{
Dummy.SetLefTandRightCommonlySide(Dummy.RightSideAccess, Dummy.LeftSideAccess);
}
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy))
{
//if (IS.ISindependenceVaribaleOrNumber(Dummy.RightSideAccess.SampleAccess))
//if(!IS.IsOperator(Dummy.RightSideAccess.SampleAccess))
if (IS.IsDiv(Dummy.LeftSideAccess.SampleAccess))
{
Dummy.SetLefTandRightCommonlySide(Dummy.RightSideAccess, Dummy.LeftSideAccess);
}
}
}
/*
* if (IS.ISindependenceVaribaleOrNumber(Dummy.LeftSideAccess.SampleAccess))
* Dummy.SetLefTandRightCommonlySide(Dummy.RightSideAccess, Dummy.LeftSideAccess);
*/
}
}
}
MulDivisionSorter.ArrangmentNumberAndX(Dummy.LeftSideAccess);
MulDivisionSorter.ArrangmentNumberAndX(Dummy.RightSideAccess);
return(Dummy);
}
static AddToTree.Tree CommonFactorCalcultor(AddToTree.Tree Dummy1, AddToTree.Tree Dummy2)
{
AddToTree.Tree Dummy = new AddToTree.Tree("*", false);
Dummy1.ThreadAccess = null;
Dummy2.ThreadAccess = null;
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy1, Dummy2))
{
Dummy = Dummy1;
}
else
{
Dummy.SetLefTandRightCommonlySide(Dummy1, Dummy2);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy;
}
return(Dummy);
}
static public bool IsEqualWithOutThreadConsiderationCommonly(AddToTree.Tree T1, AddToTree.Tree T2)
{
bool Is = false;
if ((T1 == null) && (T2 == null))
{
return(true);
}
else
if (!(((T1 != null) && (T2 != null))))
{
return(false);
}
try
{
//if ((T1.SampleAccess == T2.SampleAccess)&&(T1.NodeNumberAccess==T2.NodeNumberAccess))
if (T1.SampleAccess == T2.SampleAccess)
{
Is = true;
}
else
if (IS.IsNumber(T1.SampleAccess) && IS.IsNumber(T2.SampleAccess) && (System.Math.Abs(System.Convert.ToDouble(T1.SampleAccess) - System.Convert.ToDouble(T2.SampleAccess)) < 0.001))
{
Is = true;
}
else
{
Is = false;
}
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
}
Is = Is && EqualToObject.IsEqualWithThreadConsiderationCommonly(T1.LeftSideAccess, T2.LeftSideAccess);
Is = Is && EqualToObject.IsEqualWithThreadConsiderationCommonly(T1.RightSideAccess, T2.RightSideAccess);
return(Is);
}
static private AddToTree.Tree FindAndIndicatingRecursiveIntegralsFxLinrearFx(AddToTree.Tree Node, AddToTree.Tree MULTOW, out bool IntegralA, out float Queficient)
{
if (MULTOW.SampleAccess == "*")
{
//if (INTEGRALS.FINDTreeWithThreadConsideration(MULTOW.LeftSideAccess))
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(MULTOW.LeftSideAccess, Node))
{
Queficient = (float)System.Convert.ToDouble(MULTOW.RightSideAccess.SampleAccess);
Queficient = Queficient * (-1);
MULTOW = MULTOW.LeftSideAccess;
MULTOW.ThreadAccess = null;
IntegralA = true;
}
else
//if (INTEGRALS.FINDTreeWithThreadConsideration(MULTOW.RightSideAccess))
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(MULTOW.RightSideAccess, Node))
{
Queficient = (float)System.Convert.ToDouble(MULTOW.LeftSideAccess.SampleAccess);
Queficient = Queficient * (-1);
MULTOW = MULTOW.RightSideAccess;
MULTOW.ThreadAccess = null;
IntegralA = true;
}
else
{
IntegralA = false;
Queficient = 0;
}
}
else
{
IntegralA = false;
Queficient = 0;
}
return(MULTOW);
}
static AddToTree.Tree FactorActivationDivActionFx(AddToTree.Tree Dummy, AddToTree.Tree Factor, ref bool Action, ref bool Mul, AddToTreeTreeLinkList CopyOfFactors)
{
if (Dummy == null)
{
return(Dummy);
}
bool Current = false;
try
{
if (Mul && Action && (IS.IsMinusAndPluseFirstNode(Dummy.ThreadAccess) && (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy))))
{
Action = false;
Mul = false;
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
if ((IS.IsMinusAndPluseFirstNode(Dummy)) && (!Mul) && ((Factor != null)))
{
AddToTree.Tree Copy = new AddToTree.Tree("*", false);
Copy.SetLefTandRightCommonlySide(Factor.CopyNewTree(Factor), Dummy.CopyNewTree(Dummy));
Copy.LeftSideAccess.ThreadAccess = Copy;
Copy.RightSideAccess.ThreadAccess = Copy;
Copy.ThreadAccess = Dummy.ThreadAccess;
Dummy = Copy;
Mul = true;
Current = true;
}
else//CAUSEDERROR2983747 :This Section because of Loss Factors not is not become one extra factors.
{
Dummy = FactorActivation.ConvertExtraFactorsTooneFx(Dummy, Factor, ref Action, Current);
}
if (Current)
{
Dummy = Dummy.RightSideAccess;
//Dummy = Dummy.RightSideAccess;
Current = false;
}
Dummy.LeftSideAccess = FactorActivation.FactorActivationDivActionFx(Dummy.LeftSideAccess, Factor, ref Action, ref Mul, CopyOfFactors);
Dummy.RightSideAccess = FactorActivation.FactorActivationDivActionFx(Dummy.RightSideAccess, Factor, ref Action, ref Mul, CopyOfFactors);
return(Dummy);
}
static AddToTree.Tree SuitableToSimplifierLocalThatDivIsLocatedAtUp(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool MulTrueDivFalse, ref bool SimplifiedTrueOtherWiseFalse, ref float Num, ref bool RETURNED)
{
if (Dummy == null)
{
return(Dummy);
}
if (RETURNED)
{
return(Dummy);
}
try
{
if (IS.IsMul(Dummy.SampleAccess))
{
//if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified))
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified.RightSideAccess))
{
if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
{
Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess);
try
{
if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
{
RETURNED = true;
SimplifiedTrueOtherWiseFalse = true;
MulTrueDivFalse = true;
Dummy.SetLefTandRightCommonlySide(null, null);
Dummy.SampleAccess = "1";
Suitable = true;
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
}
/*else
* { //ERRORCORECTION13175402 :Considerable.
* RETURNED = true;
* SimplifiedTrueOtherWiseFalse = true;
* MulTrueDivFalse = true;
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = "1";
* Suitable = true;
* Num = 1;
* return Dummy;
* }
*/
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified.RightSideAccess))
{
if (IS.IsNumber(Dummy.RightSideAccess.SampleAccess))
{
Num = (float)System.Convert.ToDouble(Dummy.RightSideAccess.SampleAccess);
try
{
if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "/") && (Dummy.ThreadAccess.SampleAccess == "*"))
{
RETURNED = true;
SimplifiedTrueOtherWiseFalse = true;
MulTrueDivFalse = true;
Dummy.SetLefTandRightCommonlySide(null, null);
Dummy.SampleAccess = "1";
Suitable = true;
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
}
/*else
* {//ERRORCORECTION13175402 :Considerable.
* SimplifiedTrueOtherWiseFalse = true;
* MulTrueDivFalse = true;
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = "1";
* Suitable = true;
* Num = 1;
* return Dummy;
* }*/
}
}
else
{
RETURNED = true;
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtUp(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtUp(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
return(Dummy);
}
static AddToTree.Tree SuitableToSimplifierLocalThatDivIsLocatedAtDown(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool MulTrueDivFalse, ref bool SimplifiedTrueOtherWiseFalse, ref float Num, ref bool RETURNED)
{
if (Dummy == null)
{
return(Dummy);
}
if (RETURNED)
{
return(Dummy);
}
try
{
if (IS.IsMul(Dummy.SampleAccess))
{
}
else
if (IS.IsDiv(Dummy.SampleAccess))
{
if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified.RightSideAccess)) && (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess)))
{
Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.SampleAccess);
try
{
if ((ToSimplified.ThreadAccess.ThreadAccess.SampleAccess == "*") && (Dummy.SampleAccess == "/"))
{
RETURNED = true;
SimplifiedTrueOtherWiseFalse = true;
MulTrueDivFalse = false;
Dummy.SetLefTandRightCommonlySide(null, null);
Dummy.SampleAccess = "1";
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
Suitable = true;
}
else
if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess.LeftSideAccess, ToSimplified.RightSideAccess)) && (IS.IsMul(Dummy.RightSideAccess.SampleAccess) && (Dummy.SampleAccess == "/")))
{ //ERRORCORECTION9812737 Private state for Page 292.
try
{
if ((ToSimplified.ThreadAccess.SampleAccess == "*"))
{
RETURNED = true;
SimplifiedTrueOtherWiseFalse = true;
MulTrueDivFalse = false;
Dummy.RightSideAccess.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.LeftSideAccess.SampleAccess = "1";
Num = 1;
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
}
else
{
Suitable = false;
return(Dummy);
}
}
else
{
RETURNED = true;
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtDown(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
LocalSearchMulDivionWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatDivIsLocatedAtDown(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref MulTrueDivFalse, ref SimplifiedTrueOtherWiseFalse, ref Num, ref RETURNED);
return(Dummy);
}
static AddToTree.Tree RepeatedlyDeletedAction(AddToTree.Tree Dummy)
{
if (Dummy == null)
{
return(Dummy);
}
DeleteingMinusPluseTree.RepeatedlyDeletedAction(Dummy.LeftSideAccess);
DeleteingMinusPluseTree.RepeatedlyDeletedAction(Dummy.RightSideAccess);
AddToTree.Tree Current = Dummy;
AddToTree.Tree CurrentTow = Dummy.LeftSideAccess;
if (CurrentTow != null)
{
while (IS.IsMinuseOrPluse(Dummy.SampleAccess))
{
if (CurrentTow != null)
{
while (IS.IsMinuseOrPluse(CurrentTow.SampleAccess))
{
if (((Dummy.SampleAccess == "+") && (CurrentTow.SampleAccess == "-"))
||
((Dummy.SampleAccess == "-") && (CurrentTow.SampleAccess == "+")))
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, CurrentTow.RightSideAccess))
{
//Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy,Dummy);
String A = Dummy.SampleAccess;
if (Dummy != null)
{
if (Dummy.ThreadAccess == null)
{
Dummy = Dummy.LeftSideAccess;
Dummy.ThreadAccess = null;
}
else
{
Dummy.ThreadAccess.LeftSideAccess = Dummy.LeftSideAccess;
Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
}
}
if (A == "+")
{
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, CurrentTow.RightSideAccess)) && (Dummy.SampleAccess != "-"))
{
Dummy = Dummy.LeftSideAccess;
}
}
if (A == "-")
{
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, CurrentTow.RightSideAccess)) && (Dummy.SampleAccess != "+"))
{
Dummy = Dummy.LeftSideAccess;
}
}
//Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
if (Dummy.ThreadAccess == null)
{
Dummy = Dummy.LeftSideAccess;
Dummy.ThreadAccess = null;
}
else
{
Dummy.ThreadAccess.LeftSideAccess = Dummy.LeftSideAccess;
Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
}
//if (Dummy.ThreadAccess != null)
//Dummy.ThreadAccess.LeftSideAccess = Dummy.LeftSideAccess;
//Dummy = AddToTree.Tree.DeleteTree(Dummy, CurrentTow);
CurrentTow = Dummy.LeftSideAccess;
}
}
CurrentTow = CurrentTow.LeftSideAccess;
}
}
Dummy = Dummy.LeftSideAccess;
CurrentTow = Dummy.LeftSideAccess;
}
}
//Dummy= Dummy;
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current)) && (Dummy.ThreadAccess != null))
{
Dummy = Dummy.ThreadAccess;
}
CurrentTow = Dummy.RightSideAccess;
if (CurrentTow != null)
{
while (IS.IsMinuseOrPluse(Dummy.SampleAccess))
{
if (CurrentTow != null)
{
while (IS.IsMinuseOrPluse(CurrentTow.SampleAccess))
{
if (((Dummy.SampleAccess == "+") && (CurrentTow.SampleAccess == "-"))
||
((Dummy.SampleAccess == "-") && (CurrentTow.SampleAccess == "+")))
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, CurrentTow.LeftSideAccess))
{
//Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, Dummy);
String A = Dummy.SampleAccess;
if (Dummy.ThreadAccess == null)
{
Dummy = Dummy.RightSideAccess;
Dummy.ThreadAccess = null;
}
else
{
Dummy.ThreadAccess.RightSideAccess = Dummy.RightSideAccess;
Dummy.RightSideAccess.ThreadAccess = Dummy.ThreadAccess;
}
if (A == "+")
{
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, CurrentTow.LeftSideAccess)) && (Dummy.SampleAccess != "-"))
{
Dummy = Dummy.RightSideAccess;
}
}
if (A == "-")
{
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, CurrentTow.RightSideAccess)) && (Dummy.SampleAccess != "+"))
{
Dummy = Dummy.RightSideAccess;
}
}
if (Dummy.ThreadAccess == null)
{
Dummy = Dummy.RightSideAccess;
Dummy.ThreadAccess = null;
}
else
{
Dummy.ThreadAccess.RightSideAccess = Dummy.RightSideAccess;
Dummy.RightSideAccess.ThreadAccess = Dummy.ThreadAccess;
}
}
}
CurrentTow = CurrentTow.RightSideAccess;
}
}
Dummy = Dummy.RightSideAccess;
CurrentTow = Dummy.RightSideAccess;
}
}
return(Dummy);
}
static AddToTree.Tree SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, out bool Suitable, out bool MinuseTruePlusFalse, out bool SimplifiedTrueOtherWiseFalse)
{
if (Dummy == null)
{
Suitable = false;
MinuseTruePlusFalse = false;
SimplifiedTrueOtherWiseFalse = false;
return(Dummy);
}
try
{
if (IS.IsMinuseOrPluse(Dummy.SampleAccess))
{
if (Dummy.FINDTreeWithThreadConsideration(ToSimplified, Dummy.LeftSideAccess) == null)
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, ToSimplified))
{
try
{
if ((ToSimplified.ThreadAccess.SampleAccess == "+") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
//LOCATION81726487 :refer to page 265.
AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
Dummy = Dummy.ThreadAccess;
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
{
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
{
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
}
}
else
if ((ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.ThreadAccess.SampleAccess == "+"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = false;
//LOCATION81987526487 :refer to page 265.
AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
Dummy = Dummy.ThreadAccess;
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
{
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
{
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
}
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
}
else
if (Dummy.FINDTreeWithThreadConsideration(ToSimplified, Dummy.RightSideAccess) == null)
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, ToSimplified))
{
try
{
if ((ToSimplified.ThreadAccess.SampleAccess == "+") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
//LOCATION81726487 :refer to page 265.
AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
Dummy = Dummy.ThreadAccess;
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
{
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
{
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
}
}
else
if ((ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.SampleAccess == "+"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = false;
//LOCATION81987526487 :refer to page 265.
AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
Dummy = Dummy.ThreadAccess;
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
{
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
{
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
}
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
}
}
}
Suitable = true;
}
else
{
Suitable = false;
MinuseTruePlusFalse = false;
SimplifiedTrueOtherWiseFalse = false;
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
LocalSearchMinusPlusEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy.LeftSideAccess, ToSimplified, out Suitable, out MinuseTruePlusFalse, out SimplifiedTrueOtherWiseFalse);
LocalSearchMinusPlusEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtRight(Dummy.RightSideAccess, ToSimplified, out Suitable, out MinuseTruePlusFalse, out SimplifiedTrueOtherWiseFalse);
return(Dummy);
}
static AddToTree.Tree AddingSameUnderElementsActionReciverFx(AddToTree.Tree Node, AddToTree.Tree Dummy, AddToTree.Tree DummySender, ref bool CllingRightTrueLeftFalse, ref UknownIntegralSolver UIS)
{
if (Dummy == null)
{
return(Dummy);
}
try
{
if ((IS.IsPluSinNode(Dummy)))
{
CllingRightTrueLeftFalse = false;
Dummy.LeftSideAccess = AddingSameUnderElements.AddingSameUnderElementsActionReciverFx(Node, Dummy.LeftSideAccess, DummySender, ref CllingRightTrueLeftFalse, ref UIS);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
try
{
if ((IS.IsPluSinNode(Dummy)))
{
CllingRightTrueLeftFalse = true;
Dummy.RightSideAccess = AddingSameUnderElements.AddingSameUnderElementsActionReciverFx(Node, Dummy.RightSideAccess, DummySender, ref CllingRightTrueLeftFalse, ref UIS);
}
} catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
bool CurrentSimplification = false;
AddToTree.Tree Befor = Dummy.CopyNewTree(Dummy);
int INCREASE = 2147483647 / 3;
try
{
UIS.SetProgressValue(UIS.progressBar16, 0);
if (((Dummy.ThreadAccess == null) || (Dummy.ThreadAccess.SampleAccess == "+")) && (((Dummy.SampleAccess == "/"))) && ((EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.RightSideAccess, DummySender.RightSideAccess))) && ((!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, DummySender)))))
{
AddToTree.Tree ADD = new AddToTree.Tree("+", false);
AddToTree.Tree Div = new AddToTree.Tree("/", false);
ADD.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess), DummySender.CopyNewTree(DummySender.LeftSideAccess));
ADD.LeftSideAccess.ThreadAccess = ADD;
ADD.RightSideAccess.ThreadAccess = ADD;
Div.SetLefTandRightCommonlySide(ADD, Dummy.CopyNewTree(Dummy.RightSideAccess));
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy))
{
Dummy = Dummy.ThreadAccess;
Div.ThreadAccess = Dummy;
Dummy.RightSideAccess = Div;
}
else
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.LeftSideAccess, Dummy))
{
Dummy = Dummy.ThreadAccess;
Div.ThreadAccess = Dummy;
Dummy.LeftSideAccess = Div;
}
//AddToTree.Tree HOLDER = Dummy.CopyReferenclyTree(Dummy);
AddToTree.Tree HOLDER = Dummy.CopyReferenclyTree(Dummy);
UIS.SetProgressValue(UIS.progressBar16, INCREASE + UIS.progressBar16.Value);
Node = Dummy.CopyReferenclyTree(Dummy);
while (Node.ThreadAccess != null)
{
Node = Node.ThreadAccess;
}
Dummy = Dummy.FINDTreeWithOutThreadConsideration(Node, DummySender);
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.RightSideAccess, Dummy))
{
Dummy = Dummy.ThreadAccess;
Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
Dummy = Dummy.LeftSideAccess;
}
else
if (Dummy.ThreadAccess.LeftSideAccess != null && EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.ThreadAccess.LeftSideAccess, Dummy))
{
Dummy = Dummy.ThreadAccess;
Dummy.RightSideAccess.ThreadAccess = Dummy.ThreadAccess;
Dummy = Dummy.RightSideAccess;
}
//Node = AddingSameUnderElements.OptimizeNode(Dummy);
UIS.SetProgressValue(UIS.progressBar16, INCREASE + UIS.progressBar16.Value);
Node = Dummy.CopyReferenclyTree(Dummy);
while (Node.ThreadAccess != null)
{
Node = Node.ThreadAccess;
}
if (!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Node)))
{
Dummy = Dummy.FINDTreeWithOutThreadConsideration(HOLDER, Node);
}
CurrentSimplification = true;
}
else
{
UIS.SetProgressValue(UIS.progressBar16, 2147483647);
//if(!CurrentSimplification)
// Dummy = Dummy.FINDTreeWithThreadConsideration(Befor,Dummy);
return(Dummy);
}
if (CurrentSimplification)
{
Dummy = SimplifierCommonSubFactor.SimplifierCommonSubFactorFx(Dummy, ref UIS);
Dummy = LocalSimplifier.LocalSimplifierFx(Dummy, ref UIS);
}
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Befor))
{
UIS.SetProgressValue(UIS.progressBar16, 2147483647);
return(Dummy);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
UIS.SetProgressValue(UIS.progressBar16, 2147483647);
return(Dummy);
}
static AddToTree.Tree SpliterCalculator(AddToTree.Tree Dummy, ref bool Again, ref UknownIntegralSolver UIS)
{
if (Dummy == null)
{
return(Dummy);
}
Dummy.LeftSideAccess = Spliter.SpliterCalculator(Dummy.LeftSideAccess, ref Again, ref UIS);
try
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.LeftSideAccess;
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
Dummy.RightSideAccess = Spliter.SpliterCalculator(Dummy.RightSideAccess, ref Again, ref UIS);
try
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.LeftSideAccess;
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
//ERROR091409214 :The some needed spliation dose not acts.
//if (Dummy.SampleAccess == "/")
//ERRORCORECTION98242184 :Corrected as below.
int INCREASE = 2147483647 / 4;
UIS.SetProgressValue(UIS.progressBar11, 0);
try
{
if (Dummy.SampleAccess == "/")
{
if (((Dummy.LeftSideAccess.SampleAccess == "+") || (Dummy.LeftSideAccess.SampleAccess == "-")) && (AllowToMulMinusePluse.AllowToMulMinusePluseFx(Dummy, ref UIS)) && (Dummy.SplitableAccess))
{
UIS.SetProgressValue(UIS.progressBar11, INCREASE + UIS.progressBar11.Value);
Again = true;
AddToTree.Tree Div1 = Dummy.CopyNewTree(Dummy.RightSideAccess);
AddToTree.Tree Div2 = Dummy.CopyNewTree(Dummy.RightSideAccess);
UIS.SetProgressValue(UIS.progressBar11, INCREASE + UIS.progressBar11.Value);
//Dummy = Dummy.LeftSideAccess;
AddToTree.Tree DummyLeft = new AddToTree.Tree("/", false);
DummyLeft.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess.LeftSideAccess), Div1);
DummyLeft.LeftSideAccess.ThreadAccess = DummyLeft;
DummyLeft.RightSideAccess.ThreadAccess = DummyLeft;
UIS.SetProgressValue(UIS.progressBar11, INCREASE + UIS.progressBar11.Value);
Dummy.LeftSideAccess.LeftSideAccess = DummyLeft;
Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.LeftSideAccess;
AddToTree.Tree DummyRight = new AddToTree.Tree("/", false);
//ERROR37492387 :Refe to page 261.
DummyRight.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess.RightSideAccess), Div2);
DummyRight.LeftSideAccess.ThreadAccess = DummyRight;
DummyRight.RightSideAccess.ThreadAccess = DummyRight;
UIS.SetProgressValue(UIS.progressBar11, INCREASE + UIS.progressBar11.Value);
Dummy.LeftSideAccess.RightSideAccess = DummyRight;
Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;
Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
Dummy = Dummy.LeftSideAccess;
UIS.SetProgressValue(UIS.progressBar11, 2147483647);
}
// :The error is at here.refre to page 287.
//ADDDED73562150 :The added is here :Refer to page 331.
/*if ((Dummy.RightSideAccess.SampleAccess == "+") || (Dummy.RightSideAccess.SampleAccess == "-"))
* {
* Again = true;
* AddToTree.Tree Div1 = Dummy.CopyNewTree(Dummy.LeftSideAccess);
* AddToTree.Tree Div2 = Dummy.CopyNewTree(Dummy.LeftSideAccess);
*
* Dummy = Dummy.RightSideAccess;
*
* AddToTree.Tree DummyRight=new AddToTree.Tree("/",false);
*
* DummyRight.SetLefTandRightCommonlySide(Div1,Dummy.CopyNewTree(Dummy.RightSideAccess));
* DummyRight.LeftSideAccess.ThreadAccess = DummyRight;
* DummyRight.RightSideAccess.ThreadAccess = DummyRight;
*
* DummyRight.RightSideAccess=DummyRight;
* Dummy.RightSideAccess.ThreadAccess=Dummy;
*
* AddToTree.Tree DummyLeft=new AddToTree.Tree("/",false);
*
* DummyLeft.SetLefTandRightCommonlySide(Div2, Dummy.CopyNewTree(Dummy.RightSideAccess));
* DummyLeft.LeftSideAccess.ThreadAccess = DummyLeft;
* DummyLeft.RightSideAccess.ThreadAccess = DummyLeft;
*
* DummyLeft.RightSideAccess=DummyLeft;
* Dummy.LeftSideAccess.ThreadAccess=Dummy;
*
* Dummy=Dummy.ThreadAccess;
*
* Dummy.RightSideAccess.ThreadAccess=Dummy.ThreadAccess;
* Dummy=Dummy.RightSideAccess;
*
* }
*/
/*if (IS.IsOperator(Dummy.SampleAccess))
* if (!IS.IsPower(Dummy.SampleAccess))
* if (!IS.IsFunction(Dummy.SampleAccess))
* {
* AddToTree.Tree Div= Spliter.TheRightSideOperandOfDivision(Dummy)
* if (!SPLITED.FINDTreeWithThreadConsideration(Dummy.LeftSideAccess))
* {
* Dummy.LeftSideAccess = Spliter.DivisionSpliter(Dummy.LeftSideAccess,Div, 0);
* Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.LeftSideAccess;
* Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;
* }
* if (!SPLITED.FINDTreeWithThreadConsideration(Dummy.RightSideAccess))
* {
* Dummy.RightSideAccess = Spliter.DivisionSpliter(Dummy.RightSideAccess,Div, 0);
* Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess;
* Dummy.RightSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess;
* }
*
* SPLITED.ADDToTree(Dummy);
* //Dummy.LeftSideAccess.ThreadAccess = Dummy;
* //if (Dummy.ThreadAccess == null)
* // Dummy.LeftSideAccess.ThreadAccess = null;
* //Dummy = Dummy.LeftSideAccess;
*
*
* }
*/
}
else
{ //ERRORCORECTION981278 :Correction of ERRORCAUSE713040 .refer to page 182.
//ERROR30405031v :Refer to page 207.
/*if (!SPLITED.ISEmpty())
* {
* if (Dummy.ThreadAccess == null)
* Dummy.LeftSideAccess.ThreadAccess = null;
* Dummy = Dummy.LeftSideAccess;
* }
*/
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
/*
* if (Again)
* {
* Again = false;
* Spliter.SpliterCalculator(Dummy);
*
* }*/
return(Dummy);
}
static AddToTree.Tree SuitableToSimplifierLocalThatToSimplifiedLocatedAtLeft(AddToTree.Tree Dummy, AddToTree.Tree ToSimplified, ref bool Suitable, ref bool MinuseTruePlusFalse, ref bool SimplifiedTrueOtherWiseFalse, ref float Num)
{
if (Dummy == null)
{
return(Dummy);
}
AddToTree.Tree HOLDERCATCH = Dummy;
try
{
if (IS.IsMinuseOrPluse(Dummy.SampleAccess))
{
if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess.RightSideAccess, ToSimplified.RightSideAccess)) && (IS.IsNumber(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess)))
{
try
{
Num = (float)System.Convert.ToDouble(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess);
//Dummy = Dummy.LeftSideAccess.RightSideAccess;
if ((ToSimplified.ThreadAccess == null) && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
//LOCATION81726487 :refer to page 265.
AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
/*Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* // Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy;
* // Dummy.LeftSideAccess = Dummy.LeftSideAccess.RightSideAccess;
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Suitable = true;
return(Dummy);
}
else
if ((ToSimplified.ThreadAccess != null) && (Dummy.SampleAccess == "-"))
{
if ((ToSimplified.ThreadAccess.SampleAccess == "+") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
//LOCATION81987526487 :refer to page 265.
/* AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Suitable = true;
return(Dummy);
}
else
if ((ToSimplified.ThreadAccess != null) && (Dummy.SampleAccess == "+"))
{
if ((ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.SampleAccess == "+"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = false;
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
//LOCATION81987526487 :refer to page 265.
/*AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Suitable = true;
return(Dummy);
}
else
if ((ToSimplified.ThreadAccess != null) && (Dummy.SampleAccess == "-"))
{
if ((ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.LeftSideAccess.SampleAccess = null;
//LOCATION81987526487 :refer to page 265.
/* AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Suitable = true;
return(Dummy);
}
}
}
}
}
/*if (SimplifiedTrueOtherWiseFalse)
* Dummy = Dummy.ThreadAccess;
* else
* Dummy = Dummy.ThreadAccess.ThreadAccess;
* }
*/
catch (NullReferenceException t) { Dummy = HOLDERCATCH;
ExceptionClass.ExceptionClassMethod(t); }
}
else
if ((EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess.RightSideAccess, ToSimplified.RightSideAccess)) & (IS.IsNumber(Dummy.RightSideAccess.LeftSideAccess.SampleAccess)))
{
//Dummy.RightSideAccess.SampleAccess = null;
try
{
Num = (float)System.Convert.ToDouble(Dummy.RightSideAccess.LeftSideAccess.SampleAccess);
//Dummy = Dummy.RightSideAccess.RightSideAccess;
if ((ToSimplified.ThreadAccess == null) && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
//LOCATION81726487 :refer to page 265.
/*AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Suitable = true;
return(Dummy);
}
else
if ((((ToSimplified.ThreadAccess != null))) && (ToSimplified.ThreadAccess.SampleAccess == "+") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
//LOCATION81987526487 :refer to page 265.
/* AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy;
* Dummy.RightSideAccess = Dummy.RightSideAccess.LeftSideAccess;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
Suitable = true;
return(Dummy);
}
else
if ((((ToSimplified.ThreadAccess != null))) && (ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.SampleAccess == "+"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = false;
//LOCATION81987526487 :refer to page 265.
/* AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
Suitable = true;
return(Dummy);
}
else
if ((((ToSimplified.ThreadAccess != null))) && (ToSimplified.ThreadAccess.SampleAccess == "-") && (Dummy.SampleAccess == "-"))
{
SimplifiedTrueOtherWiseFalse = true;
MinuseTruePlusFalse = true;
//LOCATION81987526487 :refer to page 265.
/*AddToTree.Tree HOLDER = Dummy.CopyNewTree(Dummy);
* Dummy = Dummy.ThreadAccess;
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, HOLDER))
* {
* Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.RightSideAccess.SampleAccess = null;
* }
* else
* if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, HOLDER))
* {
* Dummy.LeftSideAccess.SetLefTandRightCommonlySide(null, null);
* Dummy.LeftSideAccess.SampleAccess = null;
* }
*/
Dummy.RightSideAccess.SetLefTandRightCommonlySide(null, null);
Dummy.RightSideAccess.SampleAccess = null;
Suitable = true;
return(Dummy);
}
/*if (SimplifiedTrueOtherWiseFalse)
* Dummy = Dummy.ThreadAccess;
* else
* Dummy = Dummy.ThreadAccess.ThreadAccess;
*/
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
Dummy = HOLDERCATCH;
}
}
}
else
{
return(Dummy);
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
LocalSearchMinusPlusWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtLeft(Dummy.LeftSideAccess, ToSimplified, ref Suitable, ref MinuseTruePlusFalse, ref SimplifiedTrueOtherWiseFalse, ref Num);
LocalSearchMinusPlusWithNumberMulatedEqualSimplifier.SuitableToSimplifierLocalThatToSimplifiedLocatedAtLeft(Dummy.RightSideAccess, ToSimplified, ref Suitable, ref MinuseTruePlusFalse, ref SimplifiedTrueOtherWiseFalse, ref Num);
return(Dummy);
}
static AddToTree.Tree MulDivisionSorterFxAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS, ref bool CONTINUE)
{
if (Dummy == null)
{
return(Dummy);
}
AddToTree.Tree Holder = Dummy;
Dummy.LeftSideAccess = MulDivisionSorter.MulDivisionSorterFxAction(Dummy.LeftSideAccess, ref UIS, ref CONTINUE);
try
{
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.LeftSideAccess;
}
else
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.RightSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.RightSideAccess;
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
Dummy.RightSideAccess = MulDivisionSorter.MulDivisionSorterFxAction(Dummy.RightSideAccess, ref UIS, ref CONTINUE);
try
{
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.LeftSideAccess;
}
else
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.RightSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.RightSideAccess;
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
int INCREASE = 2147483647 / 12;
UIS.SetProgressValue(UIS.progressBar13, 0);
AddToTree.Tree Current = new AddToTree.Tree(null, false);
bool BREAK = false;
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
while ((Dummy != null) && (Dummy.RightSideAccess != null))
{
AddToTree.Tree HolderCurrent = Dummy;
if (MULATED.FINDTreeWithThreadConsideration(Dummy))
{
break;
}
if (IS.IsFunction(Dummy.SampleAccess))
{
break;
}
Current = Dummy.RightSideAccess;
if (!IS.IsDiv(Current.SampleAccess))
{
break;
}
if (IS.IsOperator(Dummy.SampleAccess) && (!((Dummy.SampleAccess == "*") || (Dummy.SampleAccess == "/"))))
{
BREAK = true;
}
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
if (!BREAK)
{
while ((Current != null) && (Current.RightSideAccess != null))
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current))
{
break;
}
if (IS.IsFunction(Current.SampleAccess))
{
break;
}
//ERRORCORECTION1982748234 :Refer to page 249.
if (!((Dummy.SampleAccess == "*") && (Current.SampleAccess == "/")))
{
break;
}
if (MULATED.FINDTreeWithThreadConsideration(Current))
{
break;
}
if (MULATED.FINDTreeWithThreadConsideration(Dummy))
{
break;
}
if (IS.IsOperator(Dummy.SampleAccess) && (!((Dummy.SampleAccess == "*") || (Dummy.SampleAccess == "/"))))
{
BREAK = true;//LOCATION98174723742 :Rfer to page 249.
}
//ERROR1892386124 :The Same node of Current and Dummy node.refer to page 238.
if (!BREAK)//ERRORCORECTION897123 :The ERROR31704152 corrected.
{
if ((Current.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
{
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
if (Dummy.FINDTreeWithThreadConsideration(Current, Dummy) != null)
{
break;
}
CONTINUE = true;
AddToTree.Tree LOCAL = Dummy;
//ERROR1928749712 :The *** Mraked edited.refer to page 256.
AddToTree.Tree MUL = new AddToTree.Tree("*", false);
MUL.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.LeftSideAccess), Current.CopyNewTree(Current.LeftSideAccess));
MUL.ThreadAccess = null;
MUL.LeftSideAccess.ThreadAccess = MUL;
MUL.RightSideAccess.ThreadAccess = MUL;
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
AddToTree.Tree Contained = Dummy;
while (!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Current, Dummy)))
{
Dummy = Dummy.RightSideAccess;
}
//====
//LOCATION30415071.refer to page 256.
//ERRORCORECTION9318279 :The invalid leftside assignment.refer to page 218.
Dummy = Dummy.ThreadAccess;
//ERROR92834876 :The Division node is located at left side of Mul and in othere is located at right side.refer to page 336.
/*Dummy.RightSideAccess.LeftSideAccess = MUL;
* Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess;
* Dummy.RightSideAccess.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
* Dummy.RightSideAccess.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
*/
//ERRORCORECTION19208734 :The Above Error.(ERROR92834876)refer to page 336.
Dummy.RightSideAccess.LeftSideAccess = MUL;
Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess;
Dummy.RightSideAccess.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
Dummy.RightSideAccess.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
//while ((Dummy.ThreadAccess != null) && (!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy,LOCAL))))
// Dummy = Dummy.ThreadAccess;
//LOCATION30415071.refer to page 256.
//ERRORCORECTION9318279 :The invalid leftside assignment.refer to page 218.
if (Dummy.ThreadAccess != null)
{
//Dummy = Dummy.ThreadAccess;
//Dummy.RightSideAccess = Dummy.LeftSideAccess.LeftSideAccess;
//ERRORCUASED817263 :Refer to page 244.
//Dummy.ThreadAccess = A;
//Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy.ThreadAccess;
Dummy = Dummy.RightSideAccess;
}
else
{
Dummy = Dummy.RightSideAccess;
Dummy.ThreadAccess = null;
}
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
MULATED.ADDToTree(Dummy);
MULATED.ADDToTree(Current);
//Holder = Dummy;
// while ((Dummy != null) && (!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy,LOCAL)))
// Dummy = Dummy.RightSideAccess;
break;
}
}
Current = Current.RightSideAccess;
}
}
if (BREAK)
{
break;
}
if (!CONTINUE)
{
if (Dummy.RightSideAccess != null)
{
Dummy = Dummy.RightSideAccess;
}
}
else
{
break;
}
// if (Dummy.RightSideAccess != null)
// Current = Dummy.RightSideAccess;
}
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
//while ((Dummy.ThreadAccess != null) && (!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Holder)))
// Dummy = Dummy.ThreadAccess;
Current = Dummy.LeftSideAccess;
while ((Dummy != null) && (Dummy.LeftSideAccess != null))
{
if (MULATED.FINDTreeWithThreadConsideration(Dummy))
{
break;
}
if (IS.IsFunction(Dummy.SampleAccess))
{
break;
}
Current = Dummy.LeftSideAccess;
if (!IS.IsDiv(Current.SampleAccess))
{
break;
}
AddToTree.Tree HolderCurrent = Dummy;
if (IS.IsOperator(Dummy.SampleAccess) && (!((Dummy.SampleAccess == "*") || (Dummy.SampleAccess == "/"))))
{
BREAK = true;
}
if (!BREAK)
{
while ((Current != null) && (Current.LeftSideAccess != null))
{
if (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current))
{
break;
}
if (MULATED.FINDTreeWithThreadConsideration(Current))
{
break;
}
//ERRORCORECTINO1782647 :On four Section of while added thwe non function condition.refre to page 226.
if (IS.IsFunction(Current.SampleAccess))
{
break;
}
if (MULATED.FINDTreeWithThreadConsideration(Dummy))
{
break;
}
if (IS.IsOperator(Dummy.SampleAccess) && (!((Dummy.SampleAccess == "*") || (Dummy.SampleAccess == "/"))))
{
BREAK = true;
}
//ERRORCORECTION1982748234 :Refer to page 249.
if (!((Dummy.SampleAccess == "*") && (Current.SampleAccess == "/")))
{
break; //LOCATION98174723741 :Refer to page 249
}
if (!BREAK) //ERRORCORECTION897123 :The ERROR31704152 corrected.
{
if ((Current.SampleAccess == "/") && (Dummy.SampleAccess == "*"))
{
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
if (Dummy.FINDTreeWithThreadConsideration(Current, Dummy) != null)
{
break;
}
CONTINUE = true;
AddToTree.Tree LOCAL = Dummy;
AddToTree.Tree MUL = new AddToTree.Tree("*", false);
MUL.SetLefTandRightCommonlySide(Dummy.CopyNewTree(Dummy.RightSideAccess), Current.CopyNewTree(Current.LeftSideAccess));
MUL.ThreadAccess = null;
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
MUL.LeftSideAccess.ThreadAccess = MUL;
MUL.RightSideAccess.ThreadAccess = MUL;
AddToTree.Tree Contained = Dummy;
while (!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Current, Dummy)))
{
Dummy = Dummy.LeftSideAccess;
}
//ERRRORCORECTION1297192 :Replacement mul on non-proper location.reer to page 218.
//Dummy = Dummy.LeftSideAccess;
// Dummy.LeftSideAccess = MUL;
// Dummy.LeftSideAccess.ThreadAccess = Dummy;
// Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.LeftSideAccess;
// Dummy.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess;
Dummy = Dummy.ThreadAccess;
//ERROR92834876 :The Division node is located at left side of Mul and in othere is located at right side.refer to page 336.
/*Dummy.RightSideAccess.LeftSideAccess = MUL;
* Dummy.RightSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess;
* Dummy.RightSideAccess.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
* Dummy.RightSideAccess.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.RightSideAccess.LeftSideAccess;
*/
//ERRORCORECTION19208734 :The Above Error.(ERROR92834876)refer to page 336.
Dummy.LeftSideAccess.LeftSideAccess = MUL;
Dummy.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.RightSideAccess;
Dummy.LeftSideAccess.LeftSideAccess.LeftSideAccess.ThreadAccess = Dummy.LeftSideAccess.LeftSideAccess;
Dummy.LeftSideAccess.LeftSideAccess.RightSideAccess.ThreadAccess = Dummy.LeftSideAccess.LeftSideAccess;
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
//while ((Dummy.ThreadAccess != null) && (!(EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy,LOCAL))))
// Dummy = Dummy.ThreadAccess;
//LOCATION30415071.refer to page 256.
//ERRORCORECTION9318279 :The invalid leftside assignment.refer to page 218.
if (Dummy.ThreadAccess != null)
{
//Dummy = Dummy.ThreadAccess;
//Dummy.RightSideAccess = Dummy.LeftSideAccess.LeftSideAccess;
//ERRORCUASED817263 :Refer to page 244.
//Dummy.ThreadAccess = A;
//Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.LeftSideAccess.ThreadAccess = Dummy.ThreadAccess;
Dummy = Dummy.LeftSideAccess;
}
else
{
Dummy = Dummy.LeftSideAccess;
Dummy.ThreadAccess = null;
}
UIS.SetProgressValue(UIS.progressBar13, INCREASE + UIS.progressBar13.Value);
MULATED.ADDToTree(Dummy);
MULATED.ADDToTree(Current);
//Holder = Dummy;
//while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy,Contained))
// Dummy = Dummy.ThreadAccess;
break;
}
}
Current = Current.LeftSideAccess;
}
}
if (BREAK)
{
break;
}
if (!CONTINUE)
{
if (Dummy.LeftSideAccess != null)
{
Dummy = Dummy.LeftSideAccess;
}
}
else
{
break;
}
//
//if (Dummy.LeftSideAccess != null)
// Current = Dummy.LeftSideAccess;
}
//while ((Dummy.ThreadAccess != null) && (!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Holder)))
// Dummy = Dummy.ThreadAccess;
//ERROCORECTION198274896 :The Thread become null and the extra mulated nodes dose not removed.refer to page 336.
try
{
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.LeftSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.LeftSideAccess;
}
else
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.RightSideAccess.ThreadAccess, Dummy.ThreadAccess))
{
Dummy = Dummy.RightSideAccess;
}
}
catch (NullReferenceException t)
{ ExceptionClass.ExceptionClassMethod(t); }
UIS.SetProgressValue(UIS.progressBar13, 2147483647);
return(Dummy);
}
static private AddToTree.Tree TrasmisionActionHole(AddToTree.Tree Dummy)
{
//ERROR13107142 :This code cuased to an infinite loop.refer to page 182.
if (Dummy == null)
{
return(Dummy);
}
TransmisionToDeleteingMinusPluse.TrasmisionActionHole(Dummy.LeftSideAccess);
TransmisionToDeleteingMinusPluse.TrasmisionActionHole(Dummy.RightSideAccess);
try
{
bool ABLE = false;
AddToTree.Tree CurrentObject = Dummy;
AddToTree.Tree NODE = Dummy;
AddToTree.Tree FIRST = Dummy;
while ((IS.IsOperator(FIRST.SampleAccess)) && (FIRST.SampleAccess != "/") && (FIRST.SampleAccess != "^") && (FIRST.ThreadAccess != null))
{
FIRST = FIRST.ThreadAccess;
}
int DeepLeft = 0;
while ((NODE.LeftSideAccess != null) && (IS.IsOperator(NODE.SampleAccess)) && (NODE.SampleAccess != "/") && (NODE.SampleAccess != "^"))
{
NODE = NODE.LeftSideAccess;
DeepLeft++;
}
//ERRORCORECTION9872423784 :The ERRORCUASE713040 Correction.refer to page 182.
if (NODE.LeftSideAccess != null)
{
if (NODE.LeftSideAccess.LeftSideAccess != null)
{
ABLE = true;
}
}
if (ABLE)
{
if (DeepLeft > 1)
{
AddToTree.Tree Last = NODE.CopyNewTree(NODE.ThreadAccess);
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, FIRST);
AddToTree.Tree Holder = Dummy.RightSideAccess;
Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, Last.LeftSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy;
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.LeftSideAccess, Last))
{
Dummy = Dummy.LeftSideAccess;
}
Dummy.LeftSideAccess = Holder;
Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy;
while ((Dummy.ThreadAccess != null) && (!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, CurrentObject)))
{
Dummy = Dummy.ThreadAccess;
}
}
}
ABLE = false;
NODE = Dummy;
FIRST = Dummy;
while ((IS.IsOperator(FIRST.SampleAccess)) && (FIRST.SampleAccess != "^") && (FIRST.SampleAccess != "/") && (FIRST.ThreadAccess != null))
{
FIRST = FIRST.ThreadAccess;
}
int DeepRight = 0;
while ((NODE.RightSideAccess != null) && (IS.IsOperator(NODE.SampleAccess)) && (NODE.SampleAccess != "/") && (NODE.SampleAccess != "^"))
{
NODE = NODE.RightSideAccess;
DeepRight++;
}
//ERRORCORECTION9872423784 :The ERRORCUASE713040 Correction.refer to page 182.
if (NODE.RightSideAccess != null)
{
if (NODE.RightSideAccess.RightSideAccess != null)
{
ABLE = false;
}
}
if (ABLE)
{
if (DeepRight > 1)
{
AddToTree.Tree Last = NODE.CopyNewTree(NODE.ThreadAccess);
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, FIRST);
AddToTree.Tree Holder = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(Last.RightSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy;
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy.RightSideAccess, Last))
{
Dummy = Dummy.RightSideAccess;
}
Dummy.RightSideAccess = Holder;
Dummy.LeftSideAccess.ThreadAccess = Dummy;
Dummy.RightSideAccess.ThreadAccess = Dummy;
while ((Dummy.ThreadAccess != null) && (!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, CurrentObject)))
{
Dummy = Dummy.ThreadAccess;
}
}
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
return(Dummy);
}
static AddToTree.Tree RepeatedlyDeletedAction(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
{
if (Dummy == null)
{
return(Dummy);
}
DeletingMultaplification.RepeatedlyDeletedAction(Dummy.LeftSideAccess, ref UIS);
DeletingMultaplification.RepeatedlyDeletedAction(Dummy.RightSideAccess, ref UIS);
AddToTree.Tree Current = Dummy;
AddToTree.Tree CurrentTow = Dummy.LeftSideAccess;
//int INCREASE = 2147483647 / 9;
try
{
UIS.SetProgressValue(UIS.progressBar14, 0);
if (CurrentTow != null)
{
if (Dummy != null)
{
while ((IS.IsMul(Dummy.SampleAccess)))
{
if (!DELETED.FINDTreeWithThreadConsideration(Dummy))
{
if (!EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow, Dummy))
{
if (CurrentTow != null)
{
while ((IS.IsMul(CurrentTow.SampleAccess)) && (CurrentTow != null))
{
if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
///bool LeftTrueRightFalse = false;
///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
///LeftTrueRightFalse = true;
///else
//if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
// LeftTrueRightFalse = false;
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.RightSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, DummyCurrentTow);
Dummy.RightSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
DELETED.ADDToTree(Dummy);
}
}
if (IS.ISindependenceVaribale(Dummy.LeftSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
if ((IS.IsPower(CurrentTow.RightSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
{
if ((IS.ISindependenceVaribale(CurrentTow.RightSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
{
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = CurrentTow;
Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
{
Dummy = Dummy.LeftSideAccess;
}
DELETED.ADDToTree(Dummy);
}
}
}
}
if (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
if ((IS.IsPower(Dummy.LeftSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
{
if ((IS.ISindependenceVaribale(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
{
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = CurrentTow;
Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
{
Dummy = Dummy.LeftSideAccess;
}
DELETED.ADDToTree(Dummy);
}
}
}
}
CurrentTow = CurrentTow.LeftSideAccess;
}
}
}
}
if (Dummy.LeftSideAccess == null)
{
break;
}
Dummy = Dummy.LeftSideAccess;
CurrentTow = Dummy.LeftSideAccess;
}
}
}
//Dummy= Dummy;
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current)) && (Dummy.ThreadAccess != null))
{
Dummy = Dummy.ThreadAccess;
}
CurrentTow = Dummy.RightSideAccess;
UIS.SetProgressValue(UIS.progressBar14, 2147483647 / 2);
if (CurrentTow != null)
{
while (IS.IsMul(Dummy.SampleAccess))
{
if (CurrentTow != null)
{
while (IS.IsMul(CurrentTow.SampleAccess) && (CurrentTow != null))
{
if (IS.IsNumber(Dummy.LeftSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
///bool LeftTrueRightFalse = false;
///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
///LeftTrueRightFalse = true;
///else
//if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
// LeftTrueRightFalse = false;
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.RightSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
Dummy.SetLefTandRightCommonlySide(Dummy.LeftSideAccess, DummyCurrentTow);
Dummy.RightSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
DELETED.ADDToTree(Dummy);
}
}
if (IS.ISindependenceVaribale(Dummy.LeftSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
if ((IS.IsPower(CurrentTow.RightSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
{
if ((IS.ISindependenceVaribale(CurrentTow.RightSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
{
///bool LeftTrueRightFalse = false;
///if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.LeftSideAccess, CurrentTow))
///LeftTrueRightFalse = true;
///else
//if (EqualToObject.IsEqualWithThreadConsiderationCommonly(CurrentTow.ThreadAccess.RightSideAccess, CurrentTow))
// LeftTrueRightFalse = false;
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
//Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, CurrentTow);
Dummy = CurrentTow;
Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
//Dummy = Dummy.FINDTreeWithThreadConsideration(Dummy, HOLDE);
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
{
Dummy = Dummy.RightSideAccess;
}
DELETED.ADDToTree(Dummy);
}
}
}
}
if (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess))
{
if (IS.IsNumber(CurrentTow.LeftSideAccess.SampleAccess))
{
if ((IS.IsPower(Dummy.LeftSideAccess.SampleAccess)) || (IS.ISindependenceVaribale(CurrentTow.RightSideAccess.SampleAccess)))
{
if ((IS.ISindependenceVaribale(Dummy.LeftSideAccess.LeftSideAccess.SampleAccess)) || (IS.IsNumber(CurrentTow.RightSideAccess.RightSideAccess.SampleAccess)))
{
AddToTree.Tree HOLDE = Dummy;
AddToTree.Tree DummyCurrentTow = Dummy.LeftSideAccess;
Dummy.SetLefTandRightCommonlySide(CurrentTow.LeftSideAccess, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
Dummy = CurrentTow;
Dummy.SetLefTandRightCommonlySide(DummyCurrentTow, Dummy.RightSideAccess);
Dummy.LeftSideAccess.ThreadAccess = Dummy;
while (Dummy.ThreadAccess != null)
{
Dummy = Dummy.ThreadAccess;
}
while (EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, HOLDE))
{
Dummy = Dummy.LeftSideAccess;
}
DELETED.ADDToTree(Dummy);
}
}
}
}
CurrentTow = CurrentTow.RightSideAccess;
}
}
if (Dummy.RightSideAccess == null)
{
break;
}
Dummy = Dummy.RightSideAccess;
CurrentTow = Dummy.RightSideAccess;
}
}
while ((!EqualToObject.IsEqualWithThreadConsiderationCommonly(Dummy, Current)) && (Dummy.ThreadAccess != null))
{
Dummy = Dummy.ThreadAccess;
}
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
}
UIS.SetProgressValue(UIS.progressBar14, 2147483647);
return(Dummy);
}
