예제 #1
0
        // MMath.CosToTan(double, EQuadrantList)
        /// <summary>
        /// Liefert den Tangenswert zum Kosinuswert und Quadranten.
        /// </summary>
        /// <param name="value">Kosinuswert.</param>
        /// <param name="quadrant">Quadrant.</param>
        /// <returns>Tangenswert zum Kosinuswert und Quadranten.</returns>
        public static double CosToTan(double value, EQuadrant quadrant)
        {
            // TODO: MMath.CosToTan(double, Quadrant): value != 0 sicherstellen.
            double rtn = MMath.Sqr(1.0 - value * value) / value;

            if (quadrant == EQuadrant.III || quadrant == EQuadrant.IV)
            {
                rtn = -rtn;
            }
            return(rtn);
        }
예제 #2
0
        // MMath.ToQuadrant(double)
        /// <summary>
        /// Liefert den Quadranten zum Winkel.
        /// </summary>
        /// <param name="value">Winkel in Bogenmaß.</param>
        /// <returns>Quadrant zum Winkel.</returns>
        public static EQuadrant ToQuadrant(double value)
        {
            // Quadrant bestimmen und liefern
            double rtn = MMath.Mod(value, MMath.Pi2);

            if (MMath.Sgn(rtn) == -1.0)
            {
                rtn += MMath.Pi2;
            }
            return((EQuadrant)(int)MMath.Ceil(rtn / MMath.Rad090));
        }
예제 #3
0
        // MMath.ArcTan(double, double)
        /// <summary>
        /// Liefert den Winkel zum Tagensquotient in Bogenmaß.
        /// </summary>
        /// <param name="x">Zähler des Quotienten.</param>
        /// <param name="y">Nenner des Quotienten.</param>
        /// <returns>Winkel zum Tagensquotient in Bogenmaß.</returns>
        public static double ArcTan(double x, double y)
        {
            // TODO: MMath.ArcTan(double, double): Prüfen, ob Eigenimplemention erforderlich ist {Meeus Seite 9}.
            if (y == 0)
            {
                return(MMath.Sgn(x) * MMath.Rad090);
            }
            double l = MMath.ArcTan(x / y);

            if (MMath.Sgn(y) == -1.0)
            {
                l += MMath.Pi;
            }
            return(l);
        }
예제 #4
0
        // MMath.BesselInverse(ref double, double, double, double, double, double)
        /// <summary>
        /// Setzt den Interpolationsfaktor der Nullstelle für fünf Tabellenwerte und liefert TRUE, falls die Interpolation in weniger als 100 Schritten konvergiert.
        /// </summary>
        /// <param name="p">Interpolationfaktor der Nullstelle.</param>
        /// <param name="yM2">Funktionswert an der Stelle t-2.</param>
        /// <param name="yM1">Funktionswert an der Stelle t-1.</param>
        /// <param name="y0">Funktionswert an der Stelle t0.</param>
        /// <param name="yP1">Funktionswert an der Stelle t+1.</param>
        /// <param name="yP2">Funktionswert an der Stelle t+2.</param>
        /// <returns>TRUE, falls die Interpolation in weniger als 100 Schritten konvergiert.</returns>
        public static bool BesselInverse(ref double p, double yM2, double yM1, double y0, double yP1, double yP2)
        {
            // Lokale Felder einrichten
            double a = yM1 - yM2;
            double b = y0 - yM1;
            double c = yP1 - y0;
            double d = yP2 - yP1;
            double e = b - a;
            double f = c - b;
            double g = d - c;
            double h = f - e;
            double j = g - f;
            double k = j - h;

            // Lokale Hilfsfelder einrichten
            double h1 = k / 24.0;
            double h2 = (h + j) / 12.0;
            double h3 = f / 2.0 - h1;
            double h4 = (b + c) / 2.0 - h2;

            // Interpolation einrichten
            double n  = 0.0;
            double dN = -1.0 * MMath.Polynome(n, y0, h4, h3, h2, h1) / MMath.Polynome(n, h4, 2.0 * h3, 3.0 * h2, 4.0 * h1);
            int    i  = 0;

            // Interpolationsschleife
            while (MMath.Abs(dN) > 0.00005)
            {
                // Zähler inkrementieren und prüfen
                i++;
                if (i > 100)
                {
                    return(false);
                }

                // Nächsten Schritt vorbereiten
                n += dN;
                dN = -1.0 * MMath.Polynome(n, y0, h4, h3, h2, h1) / MMath.Polynome(n, h4, 2.0 * h3, 3.0 * h2, 4.0 * h1);
            }

            // Faktor anwenden
            p = n;
            return(true);
        }
예제 #5
0
        // MMath.ToLambda(double, double)
        /// <summary>
        /// Liefert die Längenkomponente des Polars zur X- und Y-Komponente des Vektors.
        /// </summary>
        /// <param name="x">X-Komponente.</param>
        /// <param name="y">Y-Komponente.</param>
        /// <returns>Längenkomponente des Polars zur X- und Y-Komponente des Vektors.</returns>
        public static double ToLambda(double x, double y)
        {
            // Ursprung verarbeiten
            if (x == 0.0 && y == 0.0)
            {
                return(0.0);
            }

            // Winkel berechnen
            double phi = 2.0 * MMath.ArcTan(y, MMath.Abs(x) + MMath.Sqr(x * x + y * y));

            if (x >= 0.0 && y >= 0.0)
            {
                return(phi);
            }
            if (y < 0.0)
            {
                return(MMath.Pi2 + phi);
            }
            return(MMath.Pi - phi);
        }
예제 #6
0
        // MMath.Bessel(double, double, double, double, double, double)
        /// <summary>
        /// Liefert den Funktionswert der Interpolation mit fünf Tabellenwerten.
        /// </summary>
        /// <param name="p">Interpolationsfaktor.</param>
        /// <param name="yM2">Funktionswert an der Stelle t-2.</param>
        /// <param name="yM1">Funktionswert an der Stelle t-1.</param>
        /// <param name="y0">Funktionswert an der Stelle t0.</param>
        /// <param name="yP1">Funktionswert an der Stelle t+1.</param>
        /// <param name="yP2">Funktionswert an der Stelle t+2.</param>
        /// <returns>Funktionswert der Interpolation mit fünf Tabellenwerten.</returns>
        public static double Bessel(double p, double yM2, double yM1, double y0, double yP1, double yP2)
        {
            // Lokale Felder einrichten
            double a = yM1 - yM2;
            double b = y0 - yM1;
            double c = yP1 - y0;
            double d = yP2 - yP1;
            double e = b - a;
            double f = c - b;
            double g = d - c;
            double h = f - e;
            double j = g - f;
            double k = j - h;

            // Hilfsfelder einrichten
            double h1 = k / 24.0;
            double h2 = (h + j) / 12.0;
            double h3 = f / 2.0 - h1;
            double h4 = (b + c) / 2.0 - h2;

            // Funktionswert berechnen
            return(MMath.Polynome(p, y0, h4, h3, h2, h1));
        }
예제 #7
0
 // MMath.Round(double)
 /// <summary>
 /// Rundet die Dezimalzahl zur nächsten Ganzzahl und liefert die resultierende Ganzzahl.
 /// </summary>
 /// <param name="value">Dezimalzahl.</param>
 /// <returns>Resultierende Ganzzahl.</returns>
 public static double Round(double value)
 {
     // Rückgabe
     return(MMath.Floor(value + 0.5));
 }
예제 #8
0
 // MMath.Mod(double, double)
 /// <summary>
 /// Liefert den ganzzahligen Restwert der Division.
 /// </summary>
 /// <param name="x">Dividend.</param>
 /// <param name="y">Divisor.</param>
 /// <returns>Ganzzahliger Restwert der Division.</returns>
 public static double Mod(double x, double y)
 {
     // Rückgabe
     return(x - y * MMath.Floor(x / y));
 }
예제 #9
0
 // MMath.Mod(int, int)
 /// <summary>
 /// Liefert den ganzzahligen Restwert der Division.
 /// </summary>
 /// <param name="x">Dividend.</param>
 /// <param name="y">Divisor.</param>
 /// <returns>Ganzzahliger Restwert der Division.</returns>
 public static int Mod(int x, int y)
 {
     // Rückgabe
     return((int)MMath.Mod((double)x, (double)y));
 }
예제 #10
0
 // MMath.Int(double)
 /// <summary>
 /// Liefert den ganzzahligen Teil der Dezimalzahl.
 /// </summary>
 /// <param name="value">Dezimalzahl</param>
 /// <returns>Ganzzahligen Teil der Dezimalzahl.</returns>
 public static double Int(double value)
 {
     // Rückgabe
     return(value - MMath.Div(value));
 }
예제 #11
0
 // MMath.Div(int, int)
 /// <summary>
 /// Liefert den Quotienten der Division.
 /// </summary>
 /// <param name="x">Dividend.</param>
 /// <param name="y">Divisior.</param>
 /// <returns>Quotienten der Division.</returns>
 public static int Div(int x, int y)
 {
     // Rückgabe
     return((int)MMath.Floor((double)x / (double)y));
 }
예제 #12
0
 // MMath.ToX(double, double, double)
 /// <summary>
 /// Liefert die X-Komponente des Vektors zur Längen-, Breiten- und Radiuskomponente des Polars.
 /// </summary>
 /// <param name="lambda">Längenkomponente.</param>
 /// <param name="beta">Breitenkomponente.</param>
 /// <param name="radius">Radiuskompomente.</param>
 /// <returns>X-Komponente des Vektors zur Längen-, Breiten- und Radiuskomponente des Polars.</returns>
 public static double ToX(double lambda, double beta, double radius)
 {
     // Rückgabe
     return(radius * MMath.Cos(beta) * MMath.Cos(lambda));
 }
예제 #13
0
 // MMath.ToRadius(CVector)
 /// <summary>
 /// Liefert den Radiuskomponente des Polars zum Vektor.
 /// </summary>
 /// <param name="item">Vektor.</param>
 /// <returns>Radiuskomponente des Polars zum Vektor.</returns>
 public static double ToRadius(CVector item)
 {
     // Rückgabe
     return(MMath.ToRadius(item.X, item.Y, item.Z));
 }
예제 #14
0
 // MMath.ToZ(double, double, double)
 /// <summary>
 /// Liefert die Z-Komponente des Vektors zur Längen-, Breiten- und Radiuskomponente des Polars.
 /// </summary>
 /// <param name="lambda">Längenkomponente.</param>
 /// <param name="beta">Breitenkomponente.</param>
 /// <param name="radius">Radiuskompomente.</param>
 /// <returns>Z-Komponente des Vektors zur Längen-, Breiten- und Radiuskomponente des Polars.</returns>
 public static double ToZ(double lambda, double beta, double radius)
 {
     // Rückgabe
     return(radius * MMath.Sin(beta));
 }
예제 #15
0
 // MMath.ToZ(double, double)
 /// <summary>
 /// Liefert die Z-Komponente des Vektors zur Längen- und Breitenkomponente des Polars.
 /// </summary>
 /// <param name="lambda">Längenkomponente.</param>
 /// <param name="beta">Breitenkomponente.</param>
 /// <returns>Z-Komponente des Vektors zur Längen- und Breiten-Komponente des Polars.</returns>
 public static double ToZ(double lambda, double beta)
 {
     // Rückgabe
     return(MMath.ToZ(lambda, beta, 1.0));
 }
예제 #16
0
 // MMath.ToZ(CPolar)
 /// <summary>
 /// Liefert die Z-Komponente des Vektors zum Polar.
 /// </summary>
 /// <param name="item">Polar.</param>
 /// <returns>Z-Komponente des Vektors zum Polar.</returns>
 public static double ToZ(CPolar item)
 {
     // Rückgabe
     return(MMath.ToZ(item.Longitude, item.Latitude, item.Radius));
 }
예제 #17
0
 // MMath.ToLambda(double, double, double)
 /// <summary>
 /// Liefert die Längenkomponente des Polars zur X-, Y- und Z-Komponente des Vektors.
 /// </summary>
 /// <param name="x">X-Komponente.</param>
 /// <param name="y">Y-Komponente.</param>
 /// <param name="z">Z-Komponente.</param>
 /// <returns>Längenkomponente des Polars zur X-, Y- und Z-Komponente des Vektors.</returns>
 public static double ToLambda(double x, double y, double z)
 {
     return(MMath.ToLambda(x, y));
 }
예제 #18
0
 // MMath.Div(double)
 /// <summary>
 /// Liefert den Dezimalteil der Dezimalzahl.
 /// </summary>
 /// <param name="value">Dezimalzahl</param>
 /// <returns>Dezimalteil der Dezimalzahl.</returns>
 public static double Div(double value)
 {
     // Rückgabe
     return(MMath.Mod(value, 1.0));
 }
예제 #19
0
 // MMath.ToLambda(CVector)
 /// <summary>
 /// Liefert die Längenkomponente des Polars zum Vektor.
 /// </summary>
 /// <param name="item">Vektor.</param>
 /// <returns>Längenkomponente des Polars zum Vektor.</returns>
 public static double ToLambda(CVector item)
 {
     return(MMath.ToLambda(item.X, item.Y));
 }
예제 #20
0
 // MMath.ToRadius(double, double, double)
 /// <summary>
 /// Liefert den Radiuskomponente des Polars zur X-, Y- und Z-Komponente des Vektors.
 /// </summary>
 /// <param name="x">X-Komponente.</param>
 /// <param name="y">Y-Komponente.</param>
 /// <param name="z">Y-Komponente.</param>
 /// <returns>Radiuskomponente des Polars zur X-, Y- und Z-Komponente des Vektors.</returns>
 public static double ToRadius(double x, double y, double z)
 {
     // Rückgabe
     return(MMath.Sqr(MMath.Square(x) + MMath.Square(y) + MMath.Square(z)));
 }