예제 #1
0
        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);
        }
예제 #2
0
        static public AddToTree.Tree SimplifierCommonSubFactorFx(AddToTree.Tree Dummy, ref UknownIntegralSolver UIS)
        {
            Dummy = Spliter.SpliterFx(Dummy, ref UIS);
            bool CONTINUE = false;

            //do
            //{
            //  CONTINUE = false;
            Dummy = NumberDivMul.NumberDivMulFx(Dummy, ref UIS);

            Dummy = SimplifierCommonSubFactor.SimplifierCommonSubFactorCalculatorFx(Dummy, ref CONTINUE, ref UIS);
            //} while (CONTINUE);
            return(Dummy);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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);
        }