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 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 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 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 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 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);
}
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));
}
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));
}
/// <summary>
/// Returns ascendant integer value.
/// For instance 1 is ascendant between 0 and 30 degrees (Aries),
/// 2 is ascendant between 30 and 60 degrees (Taurus).
/// For more details see https://en.wikipedia.org/wiki/Astrological_sign
/// </summary>
/// <param name="birthDateTime">UTC time at moment of birth</param>
/// <param name="longitude">West are negative values, East are positive values</param>
/// <param name="latitude">North are positive values, South are negative values</param>
/// <param name="isVedic"></param>
/// <returns></returns>
public static int GetAscendant(DateTime birthDateTime, double longitude, double latitude, bool isVedic = true)
{
if (CoordinatesInvalid())
{
throw new ArgumentOutOfRangeException("Invalid longitude");
}
var asc = AscendantCalculations.GetAscendant(longitude, latitude, birthDateTime, isVedic);
if (isVedic)
{
var shift = CommonCalculations.GetVedicShift(birthDateTime);
asc -= shift;
}
#if DEBUG
Console.WriteLine(asc);
#endif
return((int)asc / 30 + 1);
bool CoordinatesInvalid()
{
return(longitude > 180 || longitude < -180 || latitude > 90 || latitude < -90);
}
}
public Vector2 <decimal> EclipticCoordinates(DateTime date)
{
var d = JulianDateCalculator.ToJulianDaysJ2000(date);
return(new Vector2 <decimal>(CommonCalculations.From0To360(n0 + n1 * d), 0));
}
/// <summary>
/// Returns dictionary translating int Houses to lists of tuples (int Planet, decimal Degree)
/// Degrees values are ecliptical longitudes (longitudes % 30).
/// Complete longitude value may be retrieved from correspodning House number.
/// </summary>
/// <param name="date"></param>
/// <param name="longitude"></param>
/// <param name="latitude"></param>
/// <param name="isVedic"></param>
/// <param name="HousesPlanets">12 item list. Each item corresponds to one House. Each item contains array of numbers of planets</param>
/// <param name="PlanetDegrees">List of planets with longitudes</param>
/// <returns></returns>
public void CalculatePositions(DateTime date, double longitude, double latitude, bool isVedic,
out List <int[]> HousesPlanets, out List <Pair <int, decimal> > PlanetDegrees)
{
// Initialize output lists
List <int[]> housesPlanets;
List <Pair <int, decimal> > planetDegrees;
InitializeLists();
// Calculate vedic shift
var vedicShift = isVedic ? CommonCalculations.GetVedicShift(date) : 0m;
// Add ascendant to output list
AddAscendant();
// Add planets to outputlist
AddPlanets();
// Assign results to output references
HousesPlanets = housesPlanets;
PlanetDegrees = planetDegrees;
// Local functions
void InitializeLists()
{
housesPlanets = new List <int[]>();
for (var i = 0; i < 12; i++)
{
housesPlanets.Add(new int[] { });
}
planetDegrees = new List <Pair <int, decimal> >(PlanetPositions.Count);
}
void AddAscendant()
{
var asc = AscendantCalculations.GetAscendant(longitude, latitude, date, isVedic);
if (isVedic)
{
asc -= vedicShift;
}
From0_To360(ref asc);
var house = (int)(asc / 30);
var currentArray = housesPlanets[house];
var newArray = new int[currentArray.Length + 1];
currentArray.CopyTo(newArray, 0);
newArray[currentArray.Length] = planetToNumbers["Ascendant"];
housesPlanets[house] = newArray;
planetDegrees.Add(new Pair <int, decimal>(0, asc % 30));
}
void AddPlanets()
{
foreach (var planet in PlanetPositions)
{
var planetNumber = planetToNumbers[planet.Name];
var eclLon = planet.EclipticCoordinates(date).X;
From0_To360(ref eclLon);
if (isVedic)
{
eclLon -= vedicShift;
}
From0_To360(ref eclLon);
#if DEBUG
Console.WriteLine($"{planet.Name} degrees: {eclLon}\n\n\n\n");
#endif
var house = (int)(eclLon / 30);
var currentArray = housesPlanets[house];
var newArray = new int[currentArray.Length + 1];
currentArray.CopyTo(newArray, 0);
newArray[currentArray.Length] = planetToNumbers[planet.Name];
housesPlanets[house] = newArray;
planetDegrees.Add(new Pair <int, decimal>(planetNumber, eclLon % 30));
}
}
// degrees should be in [0,360)
void From0_To360(ref decimal deg)
{
deg %= 360;
deg += 360;
deg %= 360;
}
}
