/// <inheritdoc/> public bool TryCompile(IReadOnlyList <MathExpression> arguments, ICompilationContext <object?> context, ITypeHintHandler typeHintHandler, [MaybeNullWhen(false)] out Expression expr) { if (arguments.Count != 1) { expr = null; return(false); } var argExpr = context.Transform(arguments.First()); if (argExpr.Type == typeof(float) || argExpr.Type == typeof(double)) { // if this is a floating point var method = Helpers.GetMethod <Action <double> >(d => Math.Log(d)) !; expr = Expression.Call(method, CompilerHelpers.ConvertToType(argExpr, typeof(double))); return(true); } else if (CompilerHelpers.IsFloating(argExpr.Type) || CompilerHelpers.IsIntegral(argExpr.Type)) { // if this is a built-in integer or decimal var method = Helpers.GetMethod <Action <decimal> >(d => DecimalMath.Ln(d)) !; expr = Expression.Call(method, CompilerHelpers.ConvertToType(argExpr, typeof(decimal))); return(true); } expr = null; return(false); }
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)); }
public void PowNegativeDecimal() { const decimal expected = 0.5380018430410047863745228634M; decimal actual = DecimalMath.Pow(1.2M, -3.4M); Assert.AreEqual <decimal>(expected, actual); }
public void FloatingPower(decimal bas, decimal exp, decimal expect, decimal error) { var actual = DecimalMath.Pow(bas, exp); var actualError = Math.Abs(expect - actual); Assert.True(error >= actualError, $"Error of {actualError}, expected no more than error of {error}"); }
public void PowDecimal() { const decimal expected = 1.8587296919794811670420219951M; decimal actual = DecimalMath.Pow(1.2M, 3.4M); Assert.AreEqual <decimal>(expected, actual); }
public void NaturalLog(decimal arg, decimal expect, decimal error) { var actual = DecimalMath.Ln(arg); var actualError = Math.Abs(expect - actual); Assert.True(error >= actualError, $"Error of {actualError}, expected no more than error of {error}"); }
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)); }
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)); }
public void CosZero() { decimal expected = 0.0M; decimal actual = DecimalMath.PI / 2.0M; actual = DecimalMath.Cos(actual); Assert.AreEqual <decimal>(expected, actual); }
public void Root() { const decimal expected = 100.0M; decimal actual = expected * expected * expected; actual = DecimalMath.Root(actual, 3); Assert.AreEqual <decimal>(expected, actual); }
public void Sqrt() { const decimal expected = 9.0M; decimal actual = 81.0M; actual = DecimalMath.Sqrt(actual); Assert.AreEqual <decimal>(expected, actual); }
public void PowNegativeInt() { const decimal expected = 0.012345679012345679012345679M; decimal actual = 9.0M; actual = DecimalMath.Pow(actual, -2); Assert.AreEqual <decimal>(expected, actual); }
public void PowInt() { const decimal expected = 81.0M; decimal actual = 9.0M; actual = DecimalMath.Pow(actual, 2); Assert.AreEqual <decimal>(expected, actual); }
public void SinZero() { decimal expected = 0.0M; decimal actual = DecimalMath.PI; actual = DecimalMath.Sin(actual); Assert.AreEqual <decimal>(expected, actual); }
public void SinOne() { decimal expected = 1.0M; decimal actual = DecimalMath.PI / 2.0M; actual = DecimalMath.Sin(actual); Assert.AreEqual <decimal>(expected, actual); }
public void CosNegative() { decimal expected = -1.0M; decimal actual = DecimalMath.PI; actual = DecimalMath.Cos(actual); Assert.AreEqual <decimal>(expected, actual); }
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)); }
public decimal GetValue(decimal from0To1) { if (from0To1 < eps) { return(0m); } return(DecimalMath.Sqrt(from0To1)); }
// Wolfram command // plot 23.439291111111 - 0.0130041666667*t - 1.63888888889e-07*t^2 + 5.959274797e-09*t^3 t from -1 to 1 // where t is fraction of Julian Century passed from J2000 /// <summary> /// Get current axial tilt (epsilon) based on date. /// Value of 23.4 degrees is slowly decreasing. /// </summary> /// <param name="dateTime"></param> /// <returns></returns> public static decimal GetAxialTilt(DateTime dateTime) { var julianCenturies = JulianDateCalculator.ToJulianCenturiesJ2000(dateTime); return(t0 + t1 * julianCenturies + t2 * DecimalMath.Power(julianCenturies, 2) + t3 * DecimalMath.Power(julianCenturies, 3)); }
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)); }
public void TanSqrt3() { const decimal THREE = 3.0M; decimal expected = DecimalMath.Sqrt(THREE); decimal actual = DecimalMath.PI / THREE; actual = DecimalMath.Tan(actual); expected = Math.Round(expected, 22); //1.7320508075688772935274463415 actual = Math.Round(actual, 22); //1.7320508075688772935274463414 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); }
/// <summary> /// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>). /// </summary> /// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param> /// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param> /// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns> public CalculationResult CalculateDepreciation(CalculationData data, int period) { if (period < 1 || period > data.DepreciationRange) { throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange."); } var factor = CalculateFactor(data); var factorForOldValue = DecimalMath.Pow(factor, period - 1); var oldValue = data.AcquisitionValue * factorForOldValue; var remainingValue = factor * oldValue; var depreciation = oldValue - remainingValue; return(new CalculationResult(period, depreciation, remainingValue)); }
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)); }
public void OrbitalElemets_Success(DateTime date, string planetName, OrbitalElements expected) { var epsilon = 2m; // arrange & act var actual = PlanetManager.GetInstance().GetPlanet(planetName).GetOrbitalElements(date); // assert string output = string.Empty; output += !DecimalMath.IsClose(actual.LongAscedingNode, expected.LongAscedingNode, epsilon) ? $"\nLongAscendingNode\texpected : {expected.LongAscedingNode} actual {actual.LongAscedingNode}" : string.Empty; output += !DecimalMath.IsClose(actual.Inclination, expected.Inclination, epsilon) ? $"\nInclination\t\texpected : {expected.Inclination} actual {actual.Inclination}" : string.Empty; output += !DecimalMath.IsClose(actual.Peryhelion, expected.Peryhelion, epsilon) ? $"\nPeryhelion\t\texpected : {expected.Peryhelion} actual {actual.Peryhelion}" : string.Empty; output += !DecimalMath.IsClose(actual.Eccentricity, expected.Eccentricity, epsilon) ? $"\nEccentricity\t\texpected : {expected.Eccentricity} actual {actual.Eccentricity}" : string.Empty; output += !DecimalMath.IsClose(actual.MeanAnomaly, expected.MeanAnomaly, epsilon) ? $"\nMeanAnomaly\t\texpected : {expected.MeanAnomaly} actual {actual.MeanAnomaly}" : string.Empty; output += !DecimalMath.IsClose(actual.SemimajorAxis, expected.SemimajorAxis, epsilon) ? $"\nSemimajorAxis\t\texpected : {expected.SemimajorAxis} actual {actual.SemimajorAxis}" : string.Empty; Assert.True(string.IsNullOrEmpty(output), output); }
public static decimal CalculateSumLongitude(DateTime date) { var T = JulianDateCalculator.ToJulianCenturiesJ2000(date); var sum = AL(T); foreach (var term in terms) { var e = Fe(T, term.m); var sinFs = DecimalMath.Sin(Fs(T, term)); var component = e * term.S * sinFs; sum += component; #if DEBUG Console.WriteLine($"Component no{term.no}\t{component}\te {e} \tLCoeff\t{e * term.S}\tSinFs{sinFs}"); #endif } #if DEBUG Console.WriteLine($"Sum SIGMA_L = {sum}"); #endif return(sum); }
public Vector2 <decimal> EclipticCoordinates(DateTime date) { var DegToRad = DecimalMath.DegToRad; var T = JulianDateCalculator.ToJulianCenturiesJ2000(date); var L = CommonCalculations.From0To360(FL(T)); var M = CommonCalculations.From0To360(FMMoon(T)); var Mrad = M * DegToRad; var F = CommonCalculations.From0To360(FF(T)); var Frad = F * DegToRad; var lambda = CommonCalculations.From0To360(L + 1e-6M * CalculateSumLongitude(date)); var beta = (5.128m * DecimalMath.Sin(Frad)); #if DEBUG Console.WriteLine($"Julian centuries passed: {T}, L = {L}, M = {M}, F = {F}"); Console.WriteLine($"Lambda: {lambda}, Beta : {beta}"); #endif return(new Vector2 <decimal>(lambda, beta)); }
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); }
/// <summary> /// Berechnung des Abschreibungs- und Restbuchwertes (<see cref="CalculationResult"/>) für das Abschreibungsjahr (<paramref name="period"/>). /// </summary> /// <param name="data">Die grundlegenden Daten für die Abschreibungsberechnung</param> /// <param name="period">Das Abschreibungsjahr für das die Daten errechnet werden sollen.</param> /// <returns>Die errechneten Abschreibungs- und Restbuchwerte</returns> public CalculationResult CalculateDepreciation(CalculationData data, int period) { if (period < 1 || period > data.DepreciationRange) { throw new ArgumentOutOfRangeException(nameof(period), "The period must be greater than 0 and less than the value of depreciationRange."); } var factor = CalculateFactor(data); var depreciations = Enumerable.Range(0, 6) .Select(x => DecimalMath.Pow(factor, x)) .Select(x => data.AcquisitionValue * x) .SelectWithPrevious((prev, current) => prev - current) .Reverse() .ToList(); var depreciation = depreciations[period - 1]; var remainingValue = data.AcquisitionValue - depreciations.Take(period).Sum(); return(new CalculationResult(period, depreciation, remainingValue)); }
public override Vector3 <decimal> ApparentEclipticEarth3D(DateTime date) { var E = EarthPosition.EarthInstance.EclipticSun3D(date); Vector3 <decimal> P; var tempDate = date; var TT = decimal.MaxValue; while (true) { P = EclipticSun3D(tempDate); var s = Vector3 <decimal> .Distance(E, P); var newTT = s / CommonCalculations.LIGHTSPEED_AUperTick; if (DecimalMath.Abs(newTT - TT) < TimeSpan.TicksPerSecond) // try with date up to 1 second. { break; } tempDate -= new TimeSpan(Convert.ToInt64(newTT)); TT = newTT; } return(new Vector3 <decimal>(P.X - E.X, P.Y - E.Y, P.Z - E.Z)); }