public IEnumerable <IShape> GenerateIllustrationForCurrentStep(IEnumerable <double> actualPoints, IDifferentiableTwice analyzedFunction, int iterationNumber) { if (!actualPoints.IsEnoughOfParams(4)) { MethodsHelper.ThrowGreedlyException(actualPoints, 4); } var lastPoints = actualPoints.GetLastN(4); var x1 = lastPoints[0]; var x2 = lastPoints[1]; var x3 = lastPoints[2]; var y1 = analyzedFunction.Compute(lastPoints[0]); var y2 = analyzedFunction.Compute(lastPoints[1]); var y3 = analyzedFunction.Compute(lastPoints[2]); double B1; double C1; var A1 = ParabolaCoeffs(x1, x2, x3, y2, y1, y3, out B1, out C1); yield return(new ShapeKeeper <IFunction>(new SimpleFunctionKeeper(x => x * x * A1 + x * B1 + C1), new UsualExpandingDomain().Update(lastPoints[0]).Update(lastPoints[1]).Update(lastPoints[2]).Update(lastPoints[3]), string.Format("Parabola on {0}x*x+{1}*x+{2} N{3}", A1, B1, C1, iterationNumber) )); var rightRoot = (-B1 + Sign * Math.Sqrt(B1 * B1 - 4 * A1 * C1)) / (2 * A1); yield return(new VerticalSegment(0, analyzedFunction.Compute(rightRoot), rightRoot, string.Format("Parabola step N{0}", iterationNumber))); }
public IEnumerable <IShape> GenerateIllustrationForCurrentStep(IEnumerable <double> actualPoints, IFunction analyzedFunction, int iterationNumber) { if (!actualPoints.IsEnoughOfParams(3)) { MethodsHelper.ThrowGreedlyException(actualPoints, 3); } var start = actualPoints.First(); var lastPoints = actualPoints.GetLastN(2); yield return(new LineShape(new UsualExpandingDomain().Update(start).Update(lastPoints[0]).Update(lastPoints[1]), new Point2D { X = start, Y = analyzedFunction.Compute(start) }, new Point2D() { X = lastPoints[0], Y = analyzedFunction.Compute(lastPoints[0]) }, string.Format("Chord of {0} step", iterationNumber) )); yield return(new VerticalSegment(0, analyzedFunction.Compute(lastPoints[1]), lastPoints[1], string.Format("Chord step N{0}", iterationNumber))); }
public IEnumerable <IShape> GenerateIllustrationForCurrentStep(IEnumerable <double> actualPoints, IDifferentiableTwice analyzedFunction, int iterationNumber) { if (!actualPoints.IsEnoughOfParams(4)) { MethodsHelper.ThrowGreedlyException(actualPoints, 4); } var lastPoints = actualPoints.GetLastN(4); var x1 = lastPoints[0]; var x2 = lastPoints[1]; var x3 = lastPoints[2]; var y1 = analyzedFunction.Compute(lastPoints[0]); var y2 = analyzedFunction.Compute(lastPoints[1]); var y3 = analyzedFunction.Compute(lastPoints[2]); var denom = (x1 - x2) * (x1 - x3) * (x2 - x3); var A1 = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom; var B1 = (Math.Pow(x3, 2) * (y1 - y2) + Math.Pow(x2, 2) * (y3 - y1) + Math.Pow(x1, 2) * (y2 - y3)) / denom; var C1 = (x2 * x3 * (x2 - x3) * y1 + x3 * x1 * (x3 - x1) * y2 + x1 * x2 * (x1 - x2) * y3) / denom; yield return(new ShapeKeeper <IFunction>(new SimpleFunctionKeeper(x => analyzedFunction.Compute(x3) + analyzedFunction.FirstDerivative.Compute(x3) * (x - x3) - MaximumOfDoubleDiff * Math.Pow(x - x3, 2) / 2), new UsualExpandingDomain().Update(lastPoints[0]).Update(lastPoints[1]).Update(lastPoints[2]).Update(lastPoints[3]), string.Format("Porabola on {0}x*x+{1}*x+{2} N{3}", A1, B1, C1, iterationNumber) )); yield return(new VerticalSegment(0, analyzedFunction.Compute(lastPoints[3]), lastPoints[3], string.Format("Mullers step N{0}", iterationNumber))); }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IFunction analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(2)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 2); } yield return(MethodStep(previuosPoints.First(), previuosPoints.Last(), analyzedFunction.Compute)); }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IFunction analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(2)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 2); } var lastPoints = previuosPoints.GetLastN(2); yield return(MethodStep(lastPoints[0], lastPoints[1], analyzedFunction.Compute)); }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IDifferentiableTwice analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(3)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 3); } var lastPoints = previuosPoints.GetLastN(3); var differed = analyzedFunction.FirstDerivative.Compute(lastPoints[2]); var deltaXi = (-differed + Sign * Math.Sqrt(differed * differed + 2 * MaximumOfDoubleDiff * (analyzedFunction.Compute(lastPoints[2])))) / (-MaximumOfDoubleDiff); yield return(deltaXi + lastPoints[2]); }
public IEnumerable <IShape> GenerateIllustrationForCurrentStep(IEnumerable <double> actualPoints, IFunction analyzedFunction, int iterationNumber) { if (!actualPoints.IsEnoughOfParams(2)) { MethodsHelper.ThrowGreedlyException(actualPoints, 2); } var lastPoints = actualPoints.GetLastN(2); for (var i = 0; i < 2; i++) { var onLinePoint = analyzedFunction.Compute(lastPoints[i]); yield return(new VerticalSegment(onLinePoint + 1, onLinePoint - 1, lastPoints[i], String.Format("Bound({0}) N{1}", lastPoints[i], iterationNumber))); } }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IDifferentiableOnce analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(1)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 1); } var prevPoint = previuosPoints.Last(); if (prevPoint < 0) { throw new Exception("Метод Ньютона - тыква. Касательная ушла не туда. Надо попробовать начать метод с другой стороны от корня."); } var inPoint = analyzedFunction.Compute(prevPoint); var inPointDerivative = analyzedFunction.FirstDerivative.Compute(prevPoint); yield return(prevPoint - inPoint / inPointDerivative); }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IFunction analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(2)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 2); } var lastPoints = previuosPoints.GetLastN(2); var bisect = lastPoints.Average(); if (Math.Abs(analyzedFunction.Compute(bisect)) < double.Epsilon) { return(Enumerable.Empty <double>()); } var firstSegment = analyzedFunction.Compute(lastPoints[0]) * analyzedFunction.Compute(bisect); if (firstSegment < 0) { return new[] { lastPoints[0], bisect } } ; var seconsSegment = analyzedFunction.Compute(bisect) * analyzedFunction.Compute(lastPoints[1]); if (seconsSegment < 0) { return new[] { bisect, lastPoints[1] } } ; throw new Exception(string.Format("Метод деления пополам сломался. Выбран отрезок с концами одного знака(f({0}) = {1},f({2}) = {3})", lastPoints[0], analyzedFunction.Compute(lastPoints[0]), lastPoints[1], analyzedFunction.Compute(lastPoints[1]))); }
public IEnumerable <IShape> GenerateIllustrationForCurrentStep(IEnumerable <double> actualPoints, IDifferentiableOnce analyzedFunction, int iterationNumber) { if (!actualPoints.IsEnoughOfParams(2)) { MethodsHelper.ThrowGreedlyException(actualPoints, 2); } var lastPoints = actualPoints.GetLastN(2); yield return(new LineShape(new UsualExpandingDomain().Update(lastPoints[0]).Update(lastPoints[1]), new Point2D { X = lastPoints[0], Y = analyzedFunction.Compute(lastPoints[0]) }, new Point2D { X = lastPoints[1], Y = 0 }, string.Format("Secant N{0}", iterationNumber))); yield return(new VerticalSegment(0, analyzedFunction.Compute(lastPoints[1]), lastPoints[1], string.Format("Newton step N{0}", iterationNumber))); }
public IEnumerable <double> ComputeNext(IEnumerable <double> previuosPoints, IDifferentiableTwice analyzedFunction) { if (!previuosPoints.IsEnoughOfParams(3)) { MethodsHelper.ThrowGreedlyException(previuosPoints, 3); } var lastPoints = previuosPoints.GetLastN(3).ToList(); lastPoints.Sort(); var x1 = lastPoints[0]; var x2 = lastPoints[1]; var x3 = lastPoints[2]; var y1 = analyzedFunction.Compute(lastPoints[0]); var y2 = analyzedFunction.Compute(lastPoints[1]); var y3 = analyzedFunction.Compute(lastPoints[2]); double B1; double C1; var A1 = ParabolaCoeffs(x1, x2, x3, y2, y1, y3, out B1, out C1); var root = (-B1 + Sign * Math.Sqrt(B1 * B1 - 4 * A1 * C1)) / (2 * A1); if (x1 < root && root < x2) { return new List <double> { x1, root, x2 } } ; if (x2 < root && root < x3) { return new List <double> { x2, root, x3 } } ; root = (-B1 - Sign * Math.Sqrt(B1 * B1 - 4 * A1 * C1)) / (2 * A1); if (x1 < root && root < x2) { return new List <double> { x1, root, x2 } } ; if (x2 < root && root < x3) { return new List <double> { x2, root, x3 } } ; return(new List <double> { x2, root, x3 }); throw new Exception(); }