//static SenderSample Sender = new SenderSample(new Equation());
static public AddToTree.Tree DerivasionOfFX(AddToTree.Tree Node, ref UknownIntegralSolver UIS)
{
AddToTree.Tree Dummy = new AddToTree.Tree(null, false);
Dummy = Derivasion.DerivasionCalculator(Node, Dummy, ref UIS);
Dummy = Simplifier.SimplifierFx(Dummy, ref UIS);
return(Dummy);
}
static public 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 ChangeFunctionFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
{
Dummy = ChangeFunction.ChangeFunctionFxAction(Dummy);
return(Simplifier.SimplifierFx(Dummy, ref UIS));
}
private AddToTree.Tree Solver()
{
UknownIntegralSolver UNKNOWN = this;
this.SetProgressValue(progressBar1, 0);
int INCREASE = 2147483647 / 10;
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
//ERRORCUASE1715 :ERRROR cause of ERROR317142.the copy operation is not valid.
//ERROR3175 :Error in data structure .
//ERRORCAUSE0981243 ;The cause ERROR3175 of is at here.Error on copy tree.refer to page 177.
if (Enterface.SenderAccess.AutoSenderAccess.NodeAccess.SampleAccess == null && Enterface.SenderAccess.AutoSenderAccess != null)
{
Enterface.SenderAccess.AutoSenderAccess.NodeAccess = new AddToTree.Tree(Enterface.SenderAccess.AutoSenderAccess.CurrentStirngAccess, false);
}
AddToTree.Tree Copy = Enterface.SenderAccess.AutoSenderAccess.NodeAccess.CopyNewTree(Enterface.SenderAccess.AutoSenderAccess.NodeAccess);
//Copy = TransmisionToDeleteingMinusPluse.TrasmisionToDeleteingMinusPluseFx(Copy);
//ERROR918243 :The error at splitation.refer to page 176.
//Copy = TransmisionToDeleteingMinusPluse.TrasmisionToDeleteingMinusPluseFx(Copy);
AddToTree.Tree CopyNode = null;
CopyNode = Copy.CopyNewTree(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
Copy = DeleteingMinusPluseTree.DeleteingMinusPluseFx(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
Copy = Spliter.SpliterFx(Copy, ref UNKNOWN);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
Copy = Simplifier.ArrangmentForSpliter(Copy);
//ERROR30175541 :SIMPLIFIER HAS CUASED TO SOME ERRRO.refer to page 176.
//ERROR312317 & ERRROR317140 :Error in simplification.refer to page 182.
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
//Copy = Simplifier.SimplifierFx(Copy,ref UNKNOWN);
//ERROR30174213 :The Simplified is invalid here.refer to page 180.
//Copy = Derivasion.DerivasionOfFX(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
Copy = Integral.IntegralOfFX(Copy, ref UNKNOWN);
/*int i = 0;
* while (true)new AddToTree.Tree(null, false);
* {
* //Copy = Integral.DervisionI(i, Copy);
* //ERROR981273987 :The error at derivation.refer to page 205.
* Copy = Derivasion.DerivasionOfFX(Copy);
* //ERROR3017181920 :refer to page 188.
*
* Copy=Simplifier.SimplifierFx(Copy);
* i++;
* }
*/
//LOCATION13174253. refer to page 208.
//ERROR3070405060 :The error is here.refer to page 220.
//int NUM1 = Integral.NumberOfElements(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
int NUM1 = Integral.NumberOfElements(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
Copy = Simplifier.SimplifierFx(Copy, ref UNKNOWN);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
int NUM2 = Integral.NumberOfElements(Copy);
this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
//Copy = RoundTree.RoundTreeMethod(Copy,0);
Copy.ThreadAccess = null;
Thread t = new Thread(new ThreadStart(Verifing));
t.Start();
//ERRORCORECTION6646464654643211:The Verification Return Valid result:1394/4/9
if (EqualToObject.IsEqualWithOutThreadConsiderationCommonly(Simplifier.SimplifierFx(RoundTree.RoundTreeMethod(ChangeFunction.ChangeFunctionFx(Derivasion.DerivasionOfFX(Copy.CopyNewTree(Copy), ref UNKNOWN), ref UNKNOWN), RoundTree.MaxFractionalDesimal(CopyNode)), ref UNKNOWN), CopyNode))
{
t.Abort();
SetLableValue(label17, "Verifing finished.Integral Answer Calculated is :");
MessageBox.Show("Verify OK");
}
else
{
t.Abort();
SetLableValue(label17, "Verifing finished.Integral Answer Calculated is :");
MessageBox.Show("Verify Failed.");
}
return(Copy);
//this.SetProgressValue(progressBar1, this.progressBar1.Value + INCREASE);
}
static public bool IsEqualWithOutThreadConsiderationByDivision(AddToTree.Tree T1, AddToTree.Tree T2, ref UknownIntegralSolver UIS, ref float Quficient)
{
bool Is = false;
try
{
AddToTree.Tree Code = new AddToTree.Tree("/", false);
T2 = Simplifier.SimplifierFx(T2, ref UIS);
Answer1 = new AddToTreeTreeLinkList();
Answer2 = new AddToTreeTreeLinkList();
Answer1.CreateLinkListFromTree1(T2);
Answer2.CreateLinkListFromTree1(T1);
// Answer1Recrve.CreateLinkListFromTree2(T2);
// Answer2Recrve.CreateLinkListFromTree2(UIS.Enterface.SenderAccess.AutoSenderAccess.NodeAccess.CopyNewTree(UIS.Enterface.SenderAccess.AutoSenderAccess.NodeAccess));
if (Answer2.Node.EqualLinkList(Answer1.Node))//ERRORCORECTION6465464654:The Sigle Statment Recursive Integral Solved:1394/1/31
{
if (IS.IsNumber(T2.LeftSideAccess.SampleAccess) && IS.IsNumber(T1.LeftSideAccess.SampleAccess))
{
if (Integral.IntegralSignPositive)
{
Quficient = (float)(System.Convert.ToDouble(T1.CopyNewTree(T1).SampleAccess) - Quficient * System.Convert.ToDouble(T2.LeftSideAccess.SampleAccess));
}
else
{
Quficient = (float)(System.Convert.ToDouble(T1.CopyNewTree(T1).SampleAccess) + Quficient * System.Convert.ToDouble(T2.LeftSideAccess.SampleAccess));
}
Is = true;
}
else
if (IS.IsNumber(T2.LeftSideAccess.SampleAccess))
{
if (Integral.IntegralSignPositive)
{
Quficient = (float)(1.0 - Quficient * System.Convert.ToDouble(T2.LeftSideAccess.SampleAccess));
}
else
{
Quficient = (float)(1.0 + Quficient * System.Convert.ToDouble(T2.LeftSideAccess.SampleAccess));
}
Is = true;
}
}
if (!Is)
{
if (Answer2.Node.EqualLinkList2(Answer1.Node))//ERRORCORECTION6465464654:The Sigle Statment Recursive Integral Solved:1394/1/31
{
if (IS.IsNumber(T2.SampleAccess) && IS.IsNumber(T1.LeftSideAccess.SampleAccess))
{
if (Integral.IntegralSignPositive)
{
Quficient = (float)(System.Convert.ToDouble(T1.CopyNewTree(T1).SampleAccess) - Quficient * System.Convert.ToDouble(T2.SampleAccess));
}
else
{
Quficient = (float)(System.Convert.ToDouble(T1.CopyNewTree(T1).SampleAccess) + Quficient * System.Convert.ToDouble(T2.SampleAccess));
}
Is = true;
}
else
if (!IS.IsNumber(T2.SampleAccess))
{
if (Integral.IntegralSignPositive)
{
Quficient = (float)(1.0 - Quficient);
}
else
{
Quficient = (float)(1.0 + Quficient);
}
Is = true;
}
}
}
}
catch (NullReferenceException t) { ExceptionClass.ExceptionClassMethod(t); }
return(Is);
}
static public AddToTree.Tree ReplacementXFx(AddToTree.Tree Dummy, AddToTree.Tree U, ref UknownIntegralSolver UIS)
{
Dummy = Simplifier.SimplifierFx(Dummy, ref UIS);
return(ReplacementX.ReplacementXActionFx(Dummy, U));
}