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