/// <summary>
        /// Is used to build solution
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        private double PartialSolution(Point x)
        {
            DoubleCore <Point> core = new DoubleCore <Point>(RightPartCore);

            core.Prepare(x);
            return(-Integral.CalculateWithTrapeziumMethod(core, PointsNumber));
        }
        private double DirectProblemRightPartFunction(double tParam)
        {
            DoubleCore <double> core = new DoubleCore <double>((t, tau) => {
                Point pointX = new Point(InnerCurve.GetX(t), InnerCurve.GetY(t));
                return(RightPartCore(pointX, tau));
            });

            core.Prepare(tParam);
            return(2.0 * Integral.CalculateWithTrapeziumMethod(core, PointsNumber) + 2.0 * OnCrackValueFunction(tParam));
        }
        public double BuildSolution(double[] density, Point toFindSolutionOn)
        {
            Func <double, double> coreFunction = (tau) =>
            {
                Point yPoint = new Point(InnerCurve.GetX(tau), InnerCurve.GetY(tau));
                return(SolutionBuilderCoreFunction(toFindSolutionOn, yPoint));
            };

            return(Integral.CalculateWithTrapeziumMethod(density, coreFunction) / 2.0
                   + PartialSolution(toFindSolutionOn));
        }
        private double LinDataEquationRightPartFucntion(double t)
        {
            var core = new DoubleCore <Point>(DataEquationOperatorCore);

            core.Prepare(new Point(
                             OuterCurve.GetX(t),
                             OuterCurve.GetY(t)));

            var result = -Integral.CalculateWithTrapeziumMethod(Density, core)
                         - Omega1(t);

            return(result);
        }
        public double[] BuildSolutionDerivativeOnOuterCurve(double[] density)
        {
            var descretePoints     = IntegralEquationDiscretezer.GetDiscretePoints(PointsNumber);
            var solutionDerivative = new double[descretePoints.Length];

            for (int i = 0; i < descretePoints.Length; i++)
            {
                var core = new DoubleCore <Point>(DataEquationOperatorCore);
                core.Prepare(new Point(
                                 OuterCurve.GetX(descretePoints[i]),
                                 OuterCurve.GetY(descretePoints[i])));

                solutionDerivative[i] = Integral.CalculateWithTrapeziumMethod(density, core)
                                        + Omega1(descretePoints[i]);
            }

            return(solutionDerivative);
        }