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]

ASP.NET 2.0 und 3.5

Dieser Kurs vermittelt Ihnen alle Erweiterungen von Microsoft ASP.NET 2.0. Zu diesen zählen u. a. Data Bindung, Master Pages, und Security.

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

Nach Teilnahme an dieser Schulung kennen Sie alle wesentlichen Funktionen des TFS für Entwickler. Sie setzen Software-Entwicklung mit dem Visual Studio Team Foundation Server erfolgreich um.

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!