Feedback

C# - Newtonsches Näherungsverfahren

Veröffentlicht von am 07.04.2013
(1 Bewertungen)
Das Newtonsche Näherungsverfahren wird immer dann verwendet, wenn es für eine Aufgabe, vom Wert A nach B zu kommen, zwar eine Formel gibt, aber nicht, um von B zurück auf A zu kommen.

Wenn man also von B auf A kommen möchte, muss man solange mit verschiedenen As probieren, bis man auf das erwartete B kommt.

Als Beispiel sei hier mal das Finden der Quadratwurzel gezeigt. Angenommen, man wüsste, das B = A * A ist, aber es gäbe keine adäquate Math.Sqrt()-Funktion, die einem aus einem Quadrat die Wurzel ziehen kann. Dann braucht man das Newtonsche Näherungsverfahren und muss solange verschiedene As quadrieren, bis das gesuchte B herauskommt.
using System;

namespace NewtonschesNaeherungsverfahren
{
    public static class SquareRoot
    {
        public static Decimal FindSquareRoot(UInt32 squareValue)
        {
            if (squareValue < 2)
            {
                Console.WriteLine("Iteration:\t\t\t 1");
                return (squareValue);
            }
            return (FindSquareRoot(squareValue, 0, squareValue, 1));
        }

        private static Decimal FindSquareRoot(UInt32 squareValue
            , Decimal lowerBound, Decimal upperBound, Int32 iteration)
        {
            Decimal testValue;
            Decimal result;

            testValue = ((upperBound - lowerBound) / 2) + lowerBound;
            if (iteration == 2500)
            {
                //abort here or risk stack overflow, for example sqrt(5)
                Console.WriteLine("Iteration:\t\t\t {0}", iteration);
                return (testValue);
            }
            result = CalculateSquare(testValue);
            result = Math.Round(result, 28, MidpointRounding.AwayFromZero);
            if (result == squareValue)
            {
                Console.WriteLine("Iteration:\t\t\t {0}", iteration);
                return (testValue);
            }
            else if (result > squareValue)
            {
                return (FindSquareRoot(squareValue, lowerBound, testValue
                    , ++iteration));
            }
            else
            {
                return (FindSquareRoot(squareValue, testValue, upperBound
                    , ++iteration));
            }
        }

        public static Decimal CalculateSquare(Decimal value)
        {
            return (value * value);
        }
    }

    public static class Program
    {
        public static void Main(String[] args)
        {
            UInt32 squareValue = 2;
            Decimal result;
            Double dotNetResult;

            if ((args != null) && (args.Length > 0))
            {
                UInt32 temp;

                if ((UInt32.TryParse(args[0], out temp)))
                {
                    squareValue = temp;
                }
            }
            Console.WriteLine("Square root of:\t\t\t {0}", squareValue);
            result = SquareRoot.FindSquareRoot(squareValue);
            Console.WriteLine("Square root:\t\t\t {0}", result);
            dotNetResult = Math.Sqrt((Double)squareValue);
            Console.WriteLine("Math.Sqrt():\t\t\t {0}", dotNetResult);
            result = SquareRoot.CalculateSquare(result);
            Console.WriteLine("Square of square root:\t\t {0}", result);
            result = SquareRoot.CalculateSquare((Decimal)dotNetResult);
            Console.WriteLine("Square of Math.Sqrt():\t\t {0}", result);
            Console.ReadLine();
        }
    }
}

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!