Exemplo n.º 1
0
        public override Vector2 <decimal> EquatorialCoordinates(DateTime date)
        {
            var pos = EclipticEarth3D(date);
            var X = pos.X; var Y = pos.Y; var Z = pos.Z;
            var R         = DecimalMath.Sqrt(X * X + Y * Y + Z * Z);
            var lambda    = DecimalMath.Atan2(Y, X);
            var sinLambda = DecimalMath.Sin(lambda);
            var cosLambda = DecimalMath.Cos(lambda);
            var beta      = DecimalMath.Asin(Z / R);
            var tanBeta   = DecimalMath.Tan(beta);
            var sinBeta   = DecimalMath.Sin(beta);
            var cosBeta   = DecimalMath.Cos(beta);

            var tilt    = CommonCalculations.GetAxialTilt(date) * DecimalMath.DegToRad;
            var cosTilt = DecimalMath.Cos(tilt);
            var sinTilt = DecimalMath.Sin(tilt);
            var RA      = DecimalMath.Atan2(sinLambda * cosTilt - tanBeta * sinTilt, cosLambda) * DecimalMath.RadToDeg;
            var Dec     = DecimalMath.Asin(sinBeta * cosTilt + cosBeta * sinTilt * sinLambda) * DecimalMath.RadToDeg;

            RA = CommonCalculations.From0To360(RA);
#if DEBUG
            Console.WriteLine($"R = {R} lambda = {lambda}, beta = {beta}, tilt = {tilt}, RA = {RA}, dec = {Dec}");
#endif

            return(new Vector2 <decimal>(RA, Dec));
        }
Exemplo n.º 2
0
        public Vector2 <decimal> EquatorialCoordinates(DateTime date)
        {
            var DegToRad = DecimalMath.DegToRad;

            var d = JulianDateCalculator.ToJulianDaysJ2000(date);
            var L = FL(d); var Lrad = L * DegToRad;
            var M = FMMoon(d); var Mrad = M * DegToRad;
            var F = FF(d); var Frad = F * DegToRad;

            var lambda = (L + 6.289M * DecimalMath.Sin(Mrad)) * DegToRad;
            var beta   = (5.128m * DecimalMath.Sin(Frad)) * DegToRad;
            var tilt   = CommonCalculations.GetAxialTilt(date) * DegToRad;

            var sinLambda = DecimalMath.Sin(lambda);
            var cosLambda = DecimalMath.Cos(lambda);

            var sinBeta = DecimalMath.Sin(beta);
            var cosBeta = DecimalMath.Cos(beta);
            var tanBeta = DecimalMath.Tan(beta);

            var sinTilt = DecimalMath.Sin(tilt);
            var cosTilt = DecimalMath.Cos(tilt);

            var RA  = DecimalMath.Atan2(sinLambda * cosTilt - tanBeta * sinTilt, cosLambda) * DecimalMath.RadToDeg;
            var Dec = DecimalMath.Asin(sinBeta * cosTilt + cosBeta * sinTilt * sinLambda) * DecimalMath.RadToDeg;

            return(new Vector2 <decimal>(CommonCalculations.From0To360(RA), Dec));
        }
Exemplo n.º 3
0
        public override Vector2 <decimal> EquatorialCoordinates(DateTime date)
        {
            var pos = EclipticEarth3D(date);

#if DEBUG
            Console.WriteLine($"Sun ecliptic position: X={pos.X} Y={pos.Y} Z={pos.Z}");
#endif

            var tiltRad = CommonCalculations.GetAxialTilt(date) * DecimalMath.DegToRad;
            var Xe      = pos.X;
            var Ye      = pos.Y * DecimalMath.Cos(tiltRad);
            var Ze      = pos.Y * DecimalMath.Sin(tiltRad);

#if DEBUG
            Console.WriteLine($"Sun equatorial position: X={Xe} Y={Ye} Z={Ze} with tilt {tiltRad}");
#endif

            var RA  = DecimalMath.Atan2(Ye, Xe) * DecimalMath.RadToDeg;
            var Dec = DecimalMath.Atan2(Ze, DecimalMath.Sqrt(Xe * Xe + Ye * Ye)) * DecimalMath.RadToDeg;

#if DEBUG
            Console.WriteLine($"Sun RA = {RA} Dec={Dec}");
#endif
            return(new Vector2 <decimal>(CommonCalculations.From0To360(RA), Dec));
        }
Exemplo n.º 4
0
        public void CosNegative()
        {
            decimal expected = -1.0M;
            decimal actual   = DecimalMath.PI;

            actual = DecimalMath.Cos(actual);
            Assert.AreEqual <decimal>(expected, actual);
        }
Exemplo n.º 5
0
        public void CosZero()
        {
            decimal expected = 0.0M;
            decimal actual   = DecimalMath.PI / 2.0M;

            actual = DecimalMath.Cos(actual);
            Assert.AreEqual <decimal>(expected, actual);
        }
        public static decimal GetAscendant(double longi, double lat, DateTime dateTime, bool isVedic = true)
        {
            var Pi          = DecimalMath.Pi;
            var DegToRad    = Pi / 180;
            var longitude   = Convert.ToDecimal(-longi); // East should be positive, West negative
            var latitudeRad = Convert.ToDecimal(lat) * DegToRad;
            var tilt        = CommonCalculations.GetAxialTilt(dateTime);
            var tiltRad     = tilt * DegToRad;

#if DEBUG
            Console.WriteLine($"tilt: {tilt}");
#endif
            var siderealTime    = SiderealTime.Calculate(longitude, dateTime);
            var siderealTimeRad = siderealTime * DegToRad;
#if DEBUG
            Console.WriteLine($"sidereal Time: {siderealTime}");
#endif
            var y = -DecimalMath.Cos(siderealTimeRad);
#if DEBUG
            Console.WriteLine($"y :{y}");
            Console.WriteLine(
                $"sin(RAMC) = {DecimalMath.Sin(siderealTimeRad)}" +
                $"\ncos(TILT) = {DecimalMath.Cos(tiltRad)}" +
                $"\ntan(LAT) = {DecimalMath.Tan(latitudeRad)}" +
                $"\nsin(TILT) = {DecimalMath.Sin(tiltRad)}");
#endif
            var x = DecimalMath.Sin(siderealTimeRad) * DecimalMath.Cos(tiltRad)
                    + DecimalMath.Tan(latitudeRad) * DecimalMath.Sin(tiltRad);
#if DEBUG
            Console.WriteLine($"x :{x}");
            Console.WriteLine($"Decimal y/x: {y / x}");
            Console.WriteLine($"Atan(y/x): {DecimalMath.ATan(y / x)}");
#endif
            var output = DecimalMath.ATan(y / x) * 180 / Pi;

            if (output < 0)
            {
                output += 180;
            }
            if (siderealTimeRad > Pi / 2 && siderealTimeRad < 3 * Pi / 2)
            {
                output += 180;
                output %= 360;
            }
#if DEBUG
            Console.WriteLine($"output before applying sidereal diff{output}");
#endif
            return(output);
        }
Exemplo n.º 7
0
        private Vector3 <decimal> EclipticSunXYZ(DateTime date)
        {
            var days = JulianDateCalculator.ToJulianDaysJ2000(date);

            SetTrigonometry(days);
            var S      = FS(days);
            var P      = FP(days);
            var lonecl = 238.9508m + 0.00400703m * days
                         - 19.799m * sinP + 19.848m * cosP
                         + 0.897m * sin2P - 4.956m * cos2P
                         + 0.610m * sin3P + 1.211m * cos3P
                         - 0.341m * sin4P - 0.190m * cos4P
                         + 0.128m * sin5P - 0.034m * cos5P
                         - 0.038m * sin6P + 0.031m * cos6P
                         + 0.020m * sinS_P - 0.010m * cosS_P;

            var latecl = -3.9082m
                         - 5.453m * sinP - 14.975m * cosP
                         + 3.527m * sin2P + 1.673m * cos2P
                         - 1.051m * sin3P + 0.328m * cos3P
                         + 0.179m * sin4P - 0.292m * cos4P
                         + 0.019m * sin5P + 0.100m * cos5P
                         - 0.031m * sin6P - 0.026m * cos6P
                         + 0.011m * cosS_P;
            var r = 40.72m
                    + 6.68m * sinP + 6.90m * cosP
                    - 1.18m * sin2P - 0.03m * cos2P
                    + 0.15m * sin3P - 0.14m * cos3P;

#if DEBUG
            Console.WriteLine($"Pluto lonecl = {lonecl}, latecl = {latecl}, r = {r}");
#endif

            var sinlon = DecimalMath.Sin(lonecl * DecimalMath.DegToRad);
            var coslon = DecimalMath.Cos(lonecl * DecimalMath.DegToRad);
            var sinlat = DecimalMath.Sin(latecl * DecimalMath.DegToRad);
            var coslat = DecimalMath.Cos(latecl * DecimalMath.DegToRad);

            var xe = r * coslon * coslat;
            var ye = r * sinlon * coslat;
            var ze = r * sinlat;

#if DEBUG
            Console.WriteLine($"Pluto ecliptic Sun  Xe= {xe}, Ye = {ye}, Ze = {ze}");
#endif
            return(new Vector3 <decimal>(xe, ye, ze));
        }
Exemplo n.º 8
0
        private void SetTrigonometry(decimal days)
        {
            var S = FS(days) * DecimalMath.DegToRad;
            var P = FP(days) * DecimalMath.DegToRad;

            sinP   = DecimalMath.Sin(P);
            sin2P  = DecimalMath.Sin(2 * P);
            sin3P  = DecimalMath.Sin(3 * P);
            sin4P  = DecimalMath.Sin(4 * P);
            sin5P  = DecimalMath.Sin(5 * P);
            sin6P  = DecimalMath.Sin(6 * P);
            sinS_P = DecimalMath.Sin(S - P);

            cosP   = DecimalMath.Cos(P);
            cos2P  = DecimalMath.Cos(2 * P);
            cos3P  = DecimalMath.Cos(3 * P);
            cos4P  = DecimalMath.Cos(4 * P);
            cos5P  = DecimalMath.Cos(5 * P);
            cos6P  = DecimalMath.Cos(6 * P);
            cosS_P = DecimalMath.Cos(S - P);
        }
Exemplo n.º 9
0
        public Vector2 <decimal> EquatorialCoordinates(DateTime date)
        {
            var tilt    = CommonCalculations.GetAxialTilt(date) * DecimalMath.DegToRad;
            var sintilt = DecimalMath.Sin(tilt);
            var costilt = DecimalMath.Cos(tilt);

            var pos = EclipticEarthXYZ(date);
            var xe  = pos.X;
            var ye  = pos.Y * costilt - pos.Z * sintilt;
            var ze  = pos.Y * sintilt - pos.Z * costilt;

#if DEBUG
            Console.WriteLine($"Pluto equatorial X= {xe}, Y = {ye}, Z = {ze}");
#endif

            var RA  = DecimalMath.Atan2(ye, xe) * DecimalMath.RadToDeg;
            var Dec = DecimalMath.Atan2(ze, DecimalMath.Sqrt(xe * xe, ye * ye)) * DecimalMath.RadToDeg;

#if DEBUG
            Console.WriteLine($"Pluto Ra= {RA}, DEC = {Dec}");
#endif
            return(new Vector2 <decimal>(CommonCalculations.From0To360(RA), Dec));
        }
Exemplo n.º 10
0
        public override Vector3 <decimal> EclipticSun3D(DateTime date)
        {
            var degToRad = DecimalMath.Pi / 180;

            var days = JulianDateCalculator.ToJulianDaysJ2000(date);

            var M    = MeanAnomaly(days);
            var MRad = M * degToRad;
            var e    = Eccentricity(days);

#if DEBUG
            Console.WriteLine($"Days = {days} Mean Anomaly={M} Eccentricity = {e}");
#endif

            var sinM  = DecimalMath.Sin(MRad);
            var sin2M = DecimalMath.Sin(2 * MRad);
            var sin3M = DecimalMath.Sin(3 * MRad);
            var sin4M = DecimalMath.Sin(4 * MRad);
            var sin5M = DecimalMath.Sin(5 * MRad);
            var sin6M = DecimalMath.Sin(6 * MRad);
            var e2    = DecimalMath.Power(e, 2);
            var e3    = DecimalMath.Power(e, 3);
            var e4    = DecimalMath.Power(e, 4);
            var e5    = DecimalMath.Power(e, 5);
            var e6    = DecimalMath.Power(e, 6);

            var eccentricAnomalyRad =
                MRad
                + e * sinM
                + e2 * 0.5m * sin2M
                + e3 * (0.375m * sin3M - 0.125m * sinM)
                + e4 * (-(1m / 6m) * sin2M + (1m / 3m) * sin4M)
                + e5 * (-(27m / 128m) * sin3M + (1m / 192m) * sinM + (125m / 384m) * sin5M)
                + e6 * ((1m / 48m) * sin2M + (27 / 80) * sin6M - (4 / 15) * sin4M);

#if DEBUG
            Console.WriteLine($"Eccentric Anomaly {eccentricAnomalyRad * DecimalMath.RadToDeg}");
#endif

            // Calculate true anomaly
            var A  = SemimajorAxis(days);
            var Xv = A * (DecimalMath.Cos(eccentricAnomalyRad) - e);
            var Yv = A * DecimalMath.Sqrt(1.0m - e * e) * DecimalMath.Sin(eccentricAnomalyRad);

            var v = DecimalMath.Atan2(Yv, Xv);
            var r = DecimalMath.Sqrt(Xv * Xv + Yv * Yv);

            //Calculate Heliocentric coordinates
            var N     = LongAscedingNode(days) * degToRad;
            var cosN  = DecimalMath.Cos(N);
            var sinN  = DecimalMath.Sin(N);
            var i     = Inclination(days) * degToRad;
            var cosi  = DecimalMath.Cos(i);
            var sini  = DecimalMath.Sin(i);
            var w     = Peryhelion(days) * degToRad;
            var cosVW = DecimalMath.Cos(v + w);
            var sinVW = DecimalMath.Sin(v + w);

#if DEBUG
            Console.WriteLine($"LongAscNode : {LongAscedingNode(days)}, Inclination : {Inclination(days)}");
            Console.WriteLine($"Peryhelion: {Peryhelion(days)} true anomaly : {DecimalMath.Atan2(Yv, Xv) * DecimalMath.RadToDeg}");
#endif

            var Xh = r * (cosN * cosVW - sinN * sinVW * cosi);
            var Yh = r * (sinN * cosVW + cosN * sinVW * cosi);
            var Zh = r * (sinVW * sini);

#if DEBUG
            Console.WriteLine($"{Name} heliocentric coordinates {Xh} {Yh} {Zh}");
#endif

            return(new Vector3 <decimal>(Xh, Yh, Zh));
        }
Exemplo n.º 11
0
        public decimal calculate(Queue <string> polska, decimal x)
        {
            decimal answer = 0;

            Stack <decimal> opers = new Stack <decimal>();

            foreach (string s in polska)
            {
                if (standartOperators.Contains(s))
                {
                    decimal a;
                    decimal b;

                    switch (s)
                    {
                    case "+":
                        opers.Push(opers.Pop() + opers.Pop());
                        break;

                    case "-":
                        b = opers.Pop();
                        a = opers.Pop();
                        opers.Push(a - b);
                        break;

                    case "*":
                        opers.Push(opers.Pop() * opers.Pop());
                        break;

                    case "/":
                        b = opers.Pop();
                        a = opers.Pop();
                        opers.Push(a / b);
                        break;

                    case "^":
                        b = opers.Pop();
                        a = opers.Pop();
                        opers.Push(DecimalMath.Pow(a, b));
                        break;

                    case "%":
                        b = opers.Pop();
                        a = opers.Pop();
                        opers.Push(a % b);
                        break;

                    case "sqrt":
                        opers.Push(DecimalMath.Sqrt(opers.Pop()));
                        break;

                    case "sin":
                        opers.Push(DecimalMath.Sin(opers.Pop()));
                        break;

                    case "cos":
                        opers.Push(DecimalMath.Cos(opers.Pop()));
                        break;

                    case "tan":
                        opers.Push(DecimalMath.Tan(opers.Pop()));
                        break;

                    case "atan":
                        opers.Push(DecimalMath.Atan(opers.Pop()));
                        break;

                    case "acos":
                        opers.Push(DecimalMath.Acos(opers.Pop()));
                        break;

                    case "asin":
                        opers.Push(DecimalMath.Asin(opers.Pop()));
                        break;

                    case "acotan":
                        opers.Push(DecimalMath.Atan(1 / opers.Pop()));
                        break;

                    case "exp":
                        opers.Push(DecimalMath.Exp(opers.Pop()));
                        break;

                    case "log":
                        opers.Push(DecimalMath.Log(opers.Pop()));
                        break;

                    case "ln":
                        opers.Push(DecimalMath.Log10(opers.Pop()));
                        break;

                    case "sinh":
                        opers.Push(DecimalMath.Sinh(opers.Pop()));
                        break;

                    case "cosh":
                        opers.Push(DecimalMath.Cosh(opers.Pop()));
                        break;

                    case "tanh":
                        opers.Push(DecimalMath.Tanh(opers.Pop()));
                        break;

                    case "abs":
                        opers.Push(DecimalMath.Abs(opers.Pop()));
                        break;

                    case "ceil":
                        opers.Push(DecimalMath.Ceiling(opers.Pop()));
                        break;

                    case "floor":
                        opers.Push(DecimalMath.Floor(opers.Pop()));
                        break;

                    case "fac":
                        opers.Push(factorial(opers.Pop()));
                        break;

                    case "sfac":
                        opers.Push(semifactorial(opers.Pop()));
                        break;

                    case "round":
                        opers.Push(DecimalMath.Round(opers.Pop()));
                        break;

                    case "fpart":
                        a = opers.Pop();
                        opers.Push(a - DecimalMath.Truncate(a));
                        break;
                    }
                }
                else if (s == "x")
                {
                    opers.Push(x);
                }
                else
                {
                    opers.Push(decimal.Parse(s));
                }
            }

            answer = opers.Pop();
            return(answer);
        }