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.
GFU-Schulungen  [Anzeige]

XML und .NET Überblick

Um auf dem neuesten Wissensstand zu sein, sollten Sie unser aktuelles ASP .NET Komplett Seminar belegen.
Nach dem Seminar kennen Sie die wichtigsten Strömungen in der Software-Technologie

Visual Studio Team Foundation Server 2017/2015 (TFS) für Administratoren - Kompakt

Nach dieser Schulung beherrschen Sie die Grundlagen des TFS. Sie erledigen administrative Aufgaben schnell und sicher.

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!