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);
}
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 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 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 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 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);
}
public AddToTreeTreeLinkList CopyLinkList()
{
AddToTreeTreeLinkList t = new AddToTreeTreeLinkList();
t.LinkListInizialize();
t.Node = this.CopyLinkListAction(this.Node);
t.Node.ThreadAccess = null;
t.CurrentSizeAccess = this.CurrentSizeAccess;
try
{
t.Node.CurrentAccess = this.Node.CurrentAccess.CopyNewTree(this.Node.CurrentAccess);
}
catch (NullReferenceException k) { ExceptionClass.ExceptionClassMethod(k); }
return(t);
}
private static AddToTree.Tree ConverSetToAddTreeActionFx(Set Dummy)
{
if (Dummy == null)
{
return(null);
}
AddToTree.Tree TreeDummy = new AddToTree.Tree(null, false);
try
{
TreeDummy.SampleAccess = Dummy.StringSampleAccess;
TreeDummy.LeftSideAccess.ThreadAccess = TreeDummy;
TreeDummy.RightSideAccess.ThreadAccess = TreeDummy;
}
catch (NullReferenceException T) { ExceptionClass.ExceptionClassMethod(T); }
TreeDummy.SetLefTandRightCommonlySide(ConvertClass.ConverSetToAddTreeActionFx(Dummy.LeftSideAccess), ConvertClass.ConverSetToAddTreeActionFx(Dummy.RightSideAccess));
return(TreeDummy);
}
public AddToTree.Tree DELETEFromTreeFindedNode(AddToTree.Tree DummyToDeleted)
{
AddToTree.Tree RETURN = null;
if (Node != null)
{
if (!ISEmpty())
{
try
{
LinkListNodeClass Dummy = Node;
while ((Dummy != null) && (!(EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Dummy.CurrentAccess, DummyToDeleted))))
{
Dummy = Dummy.NextAccess;
}
if (Dummy != null)
{
if (Dummy.NextAccess != null)
{
Dummy.NextAccess.ThreadAccess = Dummy.ThreadAccess;
}
Dummy = Dummy.NextAccess;
}
SetNode(Dummy);
CurrentSize--;
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
// System.Windows.Forms.MessageBox.Show("Invalide Deletion Finded Node.");
}
}
}
else
{
CurrentSize = -1;
}
return(RETURN);
}
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 public AddToTreeTreeLinkList RecursionAndOptimizingLinkListFx(AddToTreeTreeLinkList Dummy)
{
if (Dummy.CurrentSizeAccess > -1)
{
Formulas.StackTree Stack = new StackTree((Dummy.CurrentSizeAccess) + 1);
// System.Windows.Forms.MessageBox.Show("2.4.1-The Stsck newed.");
AddToTree.Tree DummyTree = null;
while (!(Dummy.ISEmpty()))
{
DummyTree = new AddToTree.Tree(null, false);
DummyTree = Dummy.DELETEFromTreeFirstNode();
try
{
if (DummyTree.SampleAccess == null)
{
continue;
}
else
{
Stack.Push(DummyTree);
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); continue; }
}
// System.Windows.Forms.MessageBox.Show("2.4.2.Stack pushed.");
while (!(Stack.IsEmpty()))
{
Dummy.ADDToTree(Stack.Pop());
}
// System.Windows.Forms.MessageBox.Show("2.4.3.End Of Recursion.");
}
return(Dummy);
}
public AddToTree.Tree DELETEFromTreeFirstNode()
{
AddToTree.Tree RETURN = new AddToTree.Tree(null, false);
if (Node != null)
{
if (!ISEmpty())
{
try
{
LinkListNodeClass Dummy = Node;
while (Dummy.NextAccess != null)
{
Dummy = Dummy.NextAccess;
}
RETURN = Dummy.CurrentAccess;
Dummy = Dummy.ThreadAccess;
if (Dummy != null)
{
Dummy.NextAccess = null;
}
CurrentSize--;
SetNode(Dummy);
}
catch (NullReferenceException t)
{
ExceptionClass.ExceptionClassMethod(t);
// System.Windows.Forms.MessageBox.Show("Invalide Deletion First Node.");
}
}
}
else
{
CurrentSize = -1;
}
return(RETURN);
}