jyotish-calc 1.2.0 → 1.3.0

package/src/panchanga/solar-calendar.js

@@ -0,0 +1,301 @@
+/**
+ * Solar Calendar Functions
+ * Solar month, Sankranti, Tamil calendar, Samvatsara
+ */
+
+const sunriseSunset = require('./sunrise-sunset');
+const utils = require('./utils');
+const { SOLAR_MONTH_NAMES, TAMIL_MONTH_NAMES, SAMVATSARA_NAMES, SIGN_NAMES } = require('./constants');
+
+/**
+ * Get solar month (Raasi) for given date
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} Solar month details
+ */
+function raasi(jd, place) {
+    const jdUTC = utils.toUTC(jd, place.timezone);
+    const rise = sunriseSunset.sunrise(jd, place);
+
+    if (!rise) return null;
+
+    const riseJDUTC = utils.toUTC(rise.jd, place.timezone);
+    const sunLong = sunriseSunset.solarLongitude(riseJDUTC);
+    const raasiNo = Math.floor(sunLong / 30) + 1;
+    const degreesInRaasi = sunLong % 30;
+    const degreesLeft = 30 - degreesInRaasi;
+
+    // Calculate end time using interpolation
+    const offsets = [0.0, 0.25, 0.5, 0.75, 1.0];
+    const sunLongs = offsets.map(t => sunriseSunset.solarLongitude(riseJDUTC + t));
+    const unwrapped = utils.unwrapAngles(sunLongs);
+
+    let endTime;
+    const targetDegree = raasiNo * 30;
+    try {
+        const jdAtStart = utils.dateToJD(
+            utils.jdToDate(jd).year,
+            utils.jdToDate(jd).month,
+            utils.jdToDate(jd).day
+        );
+        const approxEnd = utils.inverseLagrange(offsets, unwrapped, targetDegree);
+        endTime = (rise.jd + approxEnd - jdAtStart) * 24;
+    } catch {
+        // Sun moves ~1 degree per day
+        endTime = rise.hours + degreesLeft * 24;
+    }
+
+    return {
+        number: raasiNo,
+        name: SOLAR_MONTH_NAMES[raasiNo - 1],
+        signName: SIGN_NAMES[raasiNo - 1],
+        sunLongitude: sunLong,
+        degreesInRaasi,
+        degreesLeft,
+        endTime,
+        endTimeString: utils.formatTime(endTime > 24 ? endTime - 24 : endTime)
+    };
+}
+
+/**
+ * Get Tamil solar month and date
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} Tamil month and date
+ */
+function tamilSolarMonthAndDate(jd, place) {
+    const set = sunriseSunset.sunset(jd, place);
+    if (!set) return null;
+
+    const setJDUTC = utils.toUTC(set.jd, place.timezone);
+    const sunLong = sunriseSunset.solarLongitude(setJDUTC);
+    const tamilMonth = Math.floor(sunLong / 30);
+
+    // Count days since sun entered this raasi
+    let dayCount = 1;
+    let searchJD = set.jd;
+    let searchLong = sunLong;
+
+    while (true) {
+        const remainder = searchLong % 30;
+        if (remainder < 1 && remainder > 0) {
+            break;
+        }
+        searchJD -= 1;
+        const searchSetJDUTC = utils.toUTC(searchJD, place.timezone);
+        searchLong = sunriseSunset.solarLongitude(searchSetJDUTC);
+        dayCount++;
+
+        // Safety limit
+        if (dayCount > 32) break;
+    }
+
+    return {
+        month: tamilMonth,
+        monthNumber: tamilMonth + 1,
+        monthName: TAMIL_MONTH_NAMES[tamilMonth],
+        date: dayCount,
+        sunLongitude: sunLong
+    };
+}
+
+/**
+ * Get Samvatsara (60-year cycle) for given date
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} Samvatsara details
+ */
+function samvatsara(jd, place) {
+    const tamilDate = tamilSolarMonthAndDate(jd, place);
+    if (!tamilDate) return null;
+
+    // Find previous Mesha Sankranti (start of year)
+    const prevSankranti = previousSankranti(jd, place, 0); // 0 = Mesha
+    const year = prevSankranti ? prevSankranti.date.year : utils.jdToDate(jd).year;
+
+    // Calculate samvatsara index
+    // Using the traditional formula
+    const adjustedYear = year > 0 ? year - 1 : year;
+    const samvatsaraIndex = ((adjustedYear - 1926) % 60 + 60) % 60;
+
+    return {
+        index: samvatsaraIndex,
+        number: samvatsaraIndex + 1,
+        name: SAMVATSARA_NAMES[samvatsaraIndex],
+        year
+    };
+}
+
+/**
+ * Get previous Sankranti (sun entering a sign)
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @param {number} targetSign - Target sign (0-11), null for any
+ * @returns {object} Sankranti details
+ */
+function previousSankranti(jd, place, targetSign = null) {
+    const set = sunriseSunset.sunset(jd, place);
+    if (!set) return null;
+
+    let searchJD = set.jd;
+    let searchJDUTC = utils.toUTC(searchJD, place.timezone);
+    let sunLong = sunriseSunset.solarLongitude(searchJDUTC);
+    let currentSign = Math.floor(sunLong / 30);
+
+    // Search backwards for sign change
+    let maxDays = 35;
+    while (maxDays > 0) {
+        searchJD -= 1;
+        searchJDUTC = utils.toUTC(searchJD, place.timezone);
+        const newSunLong = sunriseSunset.solarLongitude(searchJDUTC);
+        const newSign = Math.floor(newSunLong / 30);
+
+        if (newSign !== currentSign) {
+            // Found a sign change
+            if (targetSign === null || currentSign === targetSign) {
+                // Refine the time
+                const riseJD = sunriseSunset.sunrise(searchJD + 1, place).jd;
+                const riseJDUTC = utils.toUTC(riseJD, place.timezone);
+                const offsets = [0.0, 0.25, 0.5, 0.75, 1.0];
+                const sunLongs = offsets.map(t => sunriseSunset.solarLongitude(riseJDUTC + t));
+
+                const sankrantiDegree = currentSign * 30;
+                let sankrantiTime;
+                try {
+                    sankrantiTime = utils.inverseLagrange(offsets, sunLongs, sankrantiDegree);
+                } catch {
+                    sankrantiTime = 0;
+                }
+
+                const date = utils.jdToDate(searchJD + 1);
+                return {
+                    sign: currentSign,
+                    signName: SIGN_NAMES[currentSign],
+                    solarMonth: SOLAR_MONTH_NAMES[currentSign],
+                    tamilMonth: TAMIL_MONTH_NAMES[currentSign],
+                    date: {
+                        year: date.year,
+                        month: date.month,
+                        day: Math.floor(date.day)
+                    },
+                    time: sankrantiTime,
+                    jd: searchJD + 1 + sankrantiTime
+                };
+            }
+        }
+
+        currentSign = newSign;
+        sunLong = newSunLong;
+        maxDays--;
+    }
+
+    return null;
+}
+
+/**
+ * Get next Sankranti
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @param {number} targetSign - Target sign (0-11), null for any
+ * @returns {object} Sankranti details
+ */
+function nextSankranti(jd, place, targetSign = null) {
+    const set = sunriseSunset.sunset(jd, place);
+    if (!set) return null;
+
+    let searchJD = set.jd;
+    let searchJDUTC = utils.toUTC(searchJD, place.timezone);
+    let sunLong = sunriseSunset.solarLongitude(searchJDUTC);
+    let currentSign = Math.floor(sunLong / 30);
+
+    // Search forwards for sign change
+    let maxDays = 35;
+    while (maxDays > 0) {
+        searchJD += 1;
+        searchJDUTC = utils.toUTC(searchJD, place.timezone);
+        const newSunLong = sunriseSunset.solarLongitude(searchJDUTC);
+        const newSign = Math.floor(newSunLong / 30);
+
+        if (newSign !== currentSign) {
+            if (targetSign === null || newSign === targetSign) {
+                const riseJD = sunriseSunset.sunrise(searchJD, place).jd;
+                const riseJDUTC = utils.toUTC(riseJD, place.timezone);
+                const offsets = [0.0, 0.25, 0.5, 0.75, 1.0];
+                const sunLongs = offsets.map(t => sunriseSunset.solarLongitude(riseJDUTC + t));
+
+                const sankrantiDegree = newSign * 30;
+                let sankrantiTime;
+                try {
+                    sankrantiTime = utils.inverseLagrange(offsets, sunLongs, sankrantiDegree);
+                } catch {
+                    sankrantiTime = 0;
+                }
+
+                const date = utils.jdToDate(searchJD);
+                return {
+                    sign: newSign,
+                    signName: SIGN_NAMES[newSign],
+                    solarMonth: SOLAR_MONTH_NAMES[newSign],
+                    tamilMonth: TAMIL_MONTH_NAMES[newSign],
+                    date: {
+                        year: date.year,
+                        month: date.month,
+                        day: Math.floor(date.day)
+                    },
+                    time: sankrantiTime,
+                    jd: searchJD + sankrantiTime
+                };
+            }
+        }
+
+        currentSign = newSign;
+        sunLong = newSunLong;
+        maxDays--;
+    }
+
+    return null;
+}
+
+/**
+ * Get number of days in Tamil month
+ * @param {number} jd - Julian Day Number
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {number} Days in the month
+ */
+function daysInTamilMonth(jd, place) {
+    const current = tamilSolarMonthAndDate(jd, place);
+    if (!current) return 30;
+
+    // Find next sankranti
+    const next = nextSankranti(jd, place);
+    if (!next) return 30;
+
+    // Count days
+    const daysPassed = current.date;
+    let searchJD = jd;
+    let daysRemaining = 0;
+
+    while (true) {
+        searchJD += 1;
+        const checkDate = tamilSolarMonthAndDate(searchJD, place);
+        if (!checkDate || checkDate.month !== current.month) {
+            break;
+        }
+        daysRemaining++;
+        if (daysRemaining > 35) break;
+    }
+
+    return daysPassed + daysRemaining;
+}
+
+module.exports = {
+    raasi,
+    tamilSolarMonthAndDate,
+    samvatsara,
+    previousSankranti,
+    nextSankranti,
+    daysInTamilMonth,
+    SOLAR_MONTH_NAMES,
+    TAMIL_MONTH_NAMES,
+    SAMVATSARA_NAMES
+};

package/src/panchanga/sunrise-sunset.js

@@ -0,0 +1,400 @@
+/**
+ * Sunrise/Sunset Calculations
+ * Calculate sun and moon rise/set times using Swiss Ephemeris
+ * With simplified astronomical formulas for reliability
+ */
+
+const swe = require('swisseph-v2');
+const utils = require('./utils');
+
+// Set ephemeris path  
+swe.swe_set_ephe_path('./node_modules/swisseph-v2/ephe');
+
+/**
+ * Calculate sunrise for given date and place
+ * @param {number} jd - Julian Day Number (local time)
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} {hours, string, jd} - sunrise time
+ */
+function sunrise(jd, place) {
+    const { year, month, day } = utils.jdToDate(jd);
+
+    // Use simple sunrise formula
+    const result = calculateSunTime(year, month, day, place.latitude, place.longitude, place.timezone, true);
+
+    if (result === null) {
+        return null;
+    }
+
+    const jdAtStart = utils.dateToJD(year, month, day);
+
+    return {
+        hours: result,
+        string: utils.formatTime(result),
+        string24: utils.formatTime(result, true),
+        jd: jdAtStart + result / 24
+    };
+}
+
+/**
+ * Calculate sunset for given date and place
+ * @param {number} jd - Julian Day Number (local time)
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} {hours, string, jd} - sunset time
+ */
+function sunset(jd, place) {
+    const { year, month, day } = utils.jdToDate(jd);
+
+    const result = calculateSunTime(year, month, day, place.latitude, place.longitude, place.timezone, false);
+
+    if (result === null) {
+        return null;
+    }
+
+    const jdAtStart = utils.dateToJD(year, month, day);
+
+    return {
+        hours: result,
+        string: utils.formatTime(result),
+        string24: utils.formatTime(result, true),
+        jd: jdAtStart + result / 24
+    };
+}
+
+/**
+ * Simple and reliable sunrise/sunset calculation
+ * Based on Meeus "Astronomical Algorithms"
+ */
+function calculateSunTime(year, month, day, lat, lng, tz, isSunrise) {
+    // Day of year
+    const N1 = Math.floor(275 * month / 9);
+    const N2 = Math.floor((month + 9) / 12);
+    const N3 = 1 + Math.floor((year - 4 * Math.floor(year / 4) + 2) / 3);
+    const N = N1 - (N2 * N3) + day - 30;
+
+    // Convert longitude to hour value
+    const lngHour = lng / 15;
+
+    // Approximate time
+    let t;
+    if (isSunrise) {
+        t = N + (6 - lngHour) / 24;
+    } else {
+        t = N + (18 - lngHour) / 24;
+    }
+
+    // Sun's mean anomaly
+    const M = (0.9856 * t) - 3.289;
+
+    // Sun's true longitude
+    let L = M + (1.916 * Math.sin(utils.toRadians(M))) +
+        (0.020 * Math.sin(utils.toRadians(2 * M))) + 282.634;
+    L = ((L % 360) + 360) % 360;
+
+    // Sun's right ascension
+    let RA = utils.toDegrees(Math.atan(0.91764 * Math.tan(utils.toRadians(L))));
+    RA = ((RA % 360) + 360) % 360;
+
+    // RA in same quadrant as L
+    const Lquadrant = Math.floor(L / 90) * 90;
+    const RAquadrant = Math.floor(RA / 90) * 90;
+    RA = RA + (Lquadrant - RAquadrant);
+
+    // RA to hours
+    RA = RA / 15;
+
+    // Sun's declination
+    const sinDec = 0.39782 * Math.sin(utils.toRadians(L));
+    const cosDec = Math.cos(Math.asin(sinDec));
+
+    // Sun's local hour angle
+    const zenith = 90.833; // Official zenith with refraction correction
+    const cosH = (Math.cos(utils.toRadians(zenith)) -
+        (sinDec * Math.sin(utils.toRadians(lat)))) /
+        (cosDec * Math.cos(utils.toRadians(lat)));
+
+    // Check if sun rises/sets
+    if (cosH > 1) {
+        return null; // Sun never rises
+    }
+    if (cosH < -1) {
+        return null; // Sun never sets
+    }
+
+    // Hour angle
+    let H;
+    if (isSunrise) {
+        H = 360 - utils.toDegrees(Math.acos(cosH));
+    } else {
+        H = utils.toDegrees(Math.acos(cosH));
+    }
+    H = H / 15; // Convert to hours
+
+    // Local mean time
+    const T = H + RA - (0.06571 * t) - 6.622;
+
+    // UTC time
+    let UT = T - lngHour;
+    UT = ((UT % 24) + 24) % 24;
+
+    // Local time
+    const localTime = UT + tz;
+
+    return ((localTime % 24) + 24) % 24;
+}
+
+/**
+ * Calculate moonrise for given date and place
+ * @param {number} jd - Julian Day Number (local time)
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} {hours, string, jd} - moonrise time
+ */
+function moonrise(jd, place) {
+    const { year, month, day } = utils.jdToDate(jd);
+    const jdNoon = utils.dateToJD(year, month, day, 12);
+    const jdNoonUTC = jdNoon - place.timezone / 24;
+
+    let moonriseTime = null;
+
+    for (let hour = 0; hour < 24; hour += 0.5) {
+        const testJD = jdNoonUTC - 12 / 24 + hour / 24;
+        const alt = getMoonAltitude(testJD, place.latitude, place.longitude);
+        const nextAlt = getMoonAltitude(testJD + 0.5 / 24, place.latitude, place.longitude);
+
+        if (alt < 0 && nextAlt >= 0) {
+            moonriseTime = hour;
+            break;
+        }
+    }
+
+    if (moonriseTime === null) {
+        return null;
+    }
+
+    const jdAtStart = utils.dateToJD(year, month, day);
+
+    return {
+        hours: moonriseTime,
+        string: utils.formatTime(moonriseTime),
+        string24: utils.formatTime(moonriseTime, true),
+        jd: jdAtStart + moonriseTime / 24
+    };
+}
+
+/**
+ * Calculate moonset for given date and place
+ */
+function moonset(jd, place) {
+    const { year, month, day } = utils.jdToDate(jd);
+    const jdNoon = utils.dateToJD(year, month, day, 12);
+    const jdNoonUTC = jdNoon - place.timezone / 24;
+
+    let moonsetTime = null;
+
+    for (let hour = 0; hour < 24; hour += 0.5) {
+        const testJD = jdNoonUTC - 12 / 24 + hour / 24;
+        const alt = getMoonAltitude(testJD, place.latitude, place.longitude);
+        const nextAlt = getMoonAltitude(testJD + 0.5 / 24, place.latitude, place.longitude);
+
+        if (alt >= 0 && nextAlt < 0) {
+            moonsetTime = hour;
+            break;
+        }
+    }
+
+    if (moonsetTime === null) {
+        return null;
+    }
+
+    const jdAtStart = utils.dateToJD(year, month, day);
+
+    return {
+        hours: moonsetTime,
+        string: utils.formatTime(moonsetTime),
+        string24: utils.formatTime(moonsetTime, true),
+        jd: jdAtStart + moonsetTime / 24
+    };
+}
+
+/**
+ * Get approximate moon altitude
+ */
+function getMoonAltitude(jdUTC, lat, lng) {
+    const flags = swe.SEFLG_SWIEPH;
+    const result = swe.swe_calc_ut(jdUTC, swe.SE_MOON, flags);
+
+    if (result.error) {
+        return 0;
+    }
+
+    const moonLong = result.longitude;
+    const moonLat = result.latitude;
+
+    const obliquity = 23.44;
+    const oblRad = utils.toRadians(obliquity);
+    const longRad = utils.toRadians(moonLong);
+    const latRad = utils.toRadians(moonLat);
+
+    const sinRA = Math.sin(longRad) * Math.cos(oblRad) - Math.tan(latRad) * Math.sin(oblRad);
+    const cosRA = Math.cos(longRad);
+    const RA = Math.atan2(sinRA, cosRA);
+
+    const sinDec = Math.sin(latRad) * Math.cos(oblRad) +
+        Math.cos(latRad) * Math.sin(oblRad) * Math.sin(longRad);
+    const dec = Math.asin(sinDec);
+
+    const LST = getLST(jdUTC, lng);
+    const LSTrad = utils.toRadians(LST);
+
+    const HA = LSTrad - RA;
+
+    const latRadObs = utils.toRadians(lat);
+    const sinAlt = Math.sin(dec) * Math.sin(latRadObs) +
+        Math.cos(dec) * Math.cos(latRadObs) * Math.cos(HA);
+    const altitude = utils.toDegrees(Math.asin(sinAlt));
+
+    return altitude;
+}
+
+/**
+ * Get Local Sidereal Time
+ */
+function getLST(jdUTC, lng) {
+    const T = (jdUTC - 2451545.0) / 36525.0;
+    let GMST = 280.46061837 + 360.98564736629 * (jdUTC - 2451545.0) +
+        0.000387933 * T * T - T * T * T / 38710000.0;
+    GMST = ((GMST % 360) + 360) % 360;
+
+    const LST = GMST + lng;
+    return ((LST % 360) + 360) % 360;
+}
+
+/**
+ * Calculate midday time (sun at highest point)
+ */
+function midday(jd, place) {
+    const rise = sunrise(jd, place);
+    const set = sunset(jd, place);
+
+    if (!rise || !set) return null;
+
+    const hours = (rise.hours + set.hours) / 2;
+    const middayJD = (rise.jd + set.jd) / 2;
+
+    return {
+        hours,
+        string: utils.formatTime(hours),
+        string24: utils.formatTime(hours, true),
+        jd: middayJD
+    };
+}
+
+/**
+ * Calculate midnight time (sun at lowest point)
+ */
+function midnight(jd, place) {
+    const set = sunset(jd, place);
+    const nextRise = sunrise(jd + 1, place);
+
+    if (!set || !nextRise) return null;
+
+    let hours = (set.hours + 24 + nextRise.hours) / 2;
+    if (hours > 24) hours -= 24;
+
+    return {
+        hours,
+        string: utils.formatTime(hours),
+        string24: utils.formatTime(hours, true)
+    };
+}
+
+/**
+ * Calculate day length (sunrise to sunset)
+ */
+function dayLength(jd, place) {
+    const rise = sunrise(jd, place);
+    const set = sunset(jd, place);
+
+    if (!rise || !set) return 12;
+
+    let length = set.hours - rise.hours;
+    if (length < 0) length += 24;
+    return length;
+}
+
+/**
+ * Calculate night length (sunset to next sunrise)
+ */
+function nightLength(jd, place) {
+    const day = dayLength(jd, place);
+    return 24 - day;
+}
+
+/**
+ * Get sidereal longitude of a planet/point
+ */
+function siderealLongitude(jdUTC, planet, ayanamsaMode = 'LAHIRI') {
+    swe.swe_set_sid_mode(swe.SE_SIDM_LAHIRI, 0, 0);
+
+    const flags = swe.SEFLG_SWIEPH | swe.SEFLG_SIDEREAL | swe.SEFLG_SPEED;
+    const result = swe.swe_calc_ut(jdUTC, planet, flags);
+
+    if (result.error) {
+        console.warn('Planet calculation error:', result.error);
+        return 0;
+    }
+
+    return utils.norm360(result.longitude);
+}
+
+/**
+ * Get solar longitude (sidereal)
+ */
+function solarLongitude(jdUTC) {
+    return siderealLongitude(jdUTC, swe.SE_SUN);
+}
+
+/**
+ * Get lunar longitude (sidereal)
+ */
+function lunarLongitude(jdUTC) {
+    return siderealLongitude(jdUTC, swe.SE_MOON);
+}
+
+/**
+ * Get daily motion of Moon
+ */
+function lunarDailyMotion(jdUTC) {
+    const today = lunarLongitude(jdUTC);
+    const tomorrow = lunarLongitude(jdUTC + 1);
+    let motion = tomorrow - today;
+    if (motion < 0) motion += 360;
+    return motion;
+}
+
+/**
+ * Get daily motion of Sun
+ */
+function solarDailyMotion(jdUTC) {
+    const today = solarLongitude(jdUTC);
+    const tomorrow = solarLongitude(jdUTC + 1);
+    let motion = tomorrow - today;
+    if (motion < 0) motion += 360;
+    return motion;
+}
+
+module.exports = {
+    sunrise,
+    sunset,
+    moonrise,
+    moonset,
+    midday,
+    midnight,
+    dayLength,
+    nightLength,
+    siderealLongitude,
+    solarLongitude,
+    lunarLongitude,
+    lunarDailyMotion,
+    solarDailyMotion
+};