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