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> EclipticCoordinates(DateTime date)
        {
            var pos = EclipticEarth3D(date);
            var lon = DecimalMath.Atan2(pos.Y, pos.X) * DecimalMath.RadToDeg;
            var lat = DecimalMath.Asin(pos.Z / DecimalMath.Sqrt(pos.X * pos.X + pos.Y * pos.Y + pos.Z * pos.Z)) * DecimalMath.RadToDeg;

            return(new Vector2 <decimal>(CommonCalculations.From0To360(lon), lat));
        }
Exemplo n.º 4
0
        public override Vector2 <decimal> ApparentEclipticEarth(DateTime date)
        {
            var pos = ApparentEclipticEarth3D(date);
            var lon = DecimalMath.Atan2(pos.Y, pos.X) * DecimalMath.RadToDeg;
            var lat = DecimalMath.Asin(pos.Z / DecimalMath.Sqrt(pos.X * pos.X + pos.Y * pos.Y + pos.Z * pos.Z)) * DecimalMath.RadToDeg;

            lon = CommonCalculations.From0To360(lon);
            lat = CommonCalculations.From0To360(lat);
            return(new Vector2 <decimal>(lon, lat));
        }
Exemplo n.º 5
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);
        }