Mean Planet Position: অহর্গণ থেকে মধ্যম গ্রহস্ফুটের সম্পূর্ণ গণনা

অহর্গণ, epoch state, revolution count, direct ও retrograde motion থেকে সূর্যসিদ্ধান্তীয় মধ্যম গ্রহস্ফুট নির্ণয়ের পূর্ণ সূত্র, worked table, C# engine এবং validation।

মধ্যম গ্রহস্ফুট হলো uniform mean-motion model-এ কোনো গ্রহ বা auxiliary point-এর zodiacal longitude। এটি true বা পর্যবেক্ষণযোগ্য অবস্থান নয়; বরং manda ও śīghra correction-এর input। তাই mean calculation-এ ছোট ভুল পরবর্তী প্রতিটি correction-এ প্রবেশ করে।

Mean Planet বলতে কী বোঝায়?

Modern astronomy-তে “mean longitude” এবং traditional siddhāntic “madhyama graha” পুরোপুরি একই theoretical model নয়। তবে computational ভূমিকা কাছাকাছি: অনিয়মিত apparent motion-এর আগে একটি uniform angular position।

এই project-এ mean position বলতে বোঝানো হবে:

  • নিরয়ণ zodiac-এ normalized angle;
  • ঘোষিত traditional epoch ও constants profile-এর ফল;
  • manda ও śīghra correction-এর পূর্ববর্তী value;
  • modern Swiss Ephemeris longitude নয়;
  • printed-Panjika ModernFit correction-সহ Saṅkrānti result-ও নয়।

অতএব UI বা XML-এ MeanLongitude, TrueLongitude এবং ModernEphemerisLongitude আলাদা fields হওয়া উচিত। শুধু “গ্রহস্ফুট” লিখলে কোন স্তরের ফল দেখানো হয়েছে তা অস্পষ্ট থেকে যায়।

Calculation Dependency: কোনটি আগে?

  1. Calculation profile নির্বাচন;
  2. Input civil date/time ও location resolve;
  3. Calendar scale ও time zone থেকে unique instant;
  4. Instant-কে profile-এর reference instant-এ রূপান্তর;
  5. Whole ও fractional অহর্গণ তৈরি;
  6. Target definition থেকে revolution count, direction ও epoch offset নেওয়া;
  7. Exact modular arithmetic-এ mean longitude;
  8. Rāśi–degree–kalā–vikalā formatting;
  9. Mean positions থেকে Chapter II-এর correction inputs তৈরি;
  10. Manda/śīghra correction শেষে true longitude।

ধাপ ৮ পর্যন্তই এই প্রবন্ধের বিষয়। Mean layer complete ও test না করে true-place function লেখা হলে ভুলের উৎস আলাদা করা কঠিন হয়।

Mean Position-এর Master Formula

ধরা যাক:

  • D = epoch থেকে signed elapsed days, fraction-সহ;
  • R = target-এর Mahāyuga revolution count;
  • N = Mahāyuga terrestrial days;
  • s = direction; direct হলে +1, retrograde হলে −1;
  • λ₀ = practical epoch-এ target-এর initial mean longitude;
  • λ̄ = target moment-এর normalized mean longitude।

Elapsed turns = D × R / N

λ̄ = normalize(λ₀ + s × 360° × D × R / N)

যদি D integer হয়, multiplication ও modulo সম্পূর্ণ integer arithmetic-এ করা যায়। D যদি rational a/b হয়:

D = a / b

λ̄ = normalize(λ₀ + s × 360° × aR / bN)

প্রথমে decimal daily motion বের করে D দিয়ে গুণ করার দরকার নেই। বরং numerator ও denominator exact রেখে শেষে normalized remainder থেকে display angle তৈরি করা নিরাপদ।

Epoch State শুধু একটি Date নয়

Chapter I.57–58-এ একটি traditional initial configuration বর্ণিত: mean planets Aries-এর শুরুতে সমবেত; lunar apogee Capricorn-এর শুরুতে এবং node Libra-এর শুরুতে। কিন্তু practical software-এ Chapter I.56 অনুসারে অন্য verified epoch থেকেও calculation abridge করা যায়।

একটি পূর্ণ epoch state-এ থাকা উচিত:

Fieldকেন দরকার
EpochIdResult কোন initial state থেকে এসেছে তা শনাক্ত করে
EpochInstantCalendar, date, time ও scale-সহ D = 0
ReferenceMeridianTraditional time reference ও deśāntara bridge
DayBoundaryMidnight, sunrise বা অন্য reference
InitialLongitudeপ্রতিটি target-এর λ₀
ConstantsProfileRevolution ও cycle-day version
BijaProfileঐতিহাসিক সংশোধন প্রয়োগ হয়েছে কি না
CalibrationProfileModernFit-এর মতো project adjustment আলাদা রাখে

pancanga3.14-এর practical example

Yano–Fushimi reference script-এর একটি implementation route-এ Julian Day থেকে অহর্গণ পেতে 588465.50 বাদ দেওয়া হয়। একই script-এর get_mean_long function কার্যত:

360 × fractional_part(rotation × ahargana / YugaCivilDays)

এই value-টি সেই reference implementation-এর epoch convention। আপনার C# engine-এ blindly copy না করে তার JD convention, initial offsets এবং local-time adjustment-সহ port করতে হবে।

একটি Revolution Table যথেষ্ট নয়: Planet-Class Mapping

প্রতিটি printed row-কে একই “planet” type ধরে calculation করলে Mercury ও Venus-এ ভুল হবে। একটি target definition table দরকার:

Output targetMean rotationŚīghra rotationDirection
SunSunSun/প্রযোজ্য নয়Direct
MoonMoonপ্রযোজ্য নয়Direct
MercurySunMercury śīghraDirect
VenusSunVenus śīghraDirect
MarsMarsSunDirect
JupiterJupiterSunDirect
SaturnSaturnSunDirect
Lunar apogeeChandroccaনেইDirect
Ascending node/RāhuNodeনেইRetrograde

Reference script-এ Mercury ও Venus-এর PlanetRotation Sun-এর revolution count পায়, কিন্তু তাদের PlanetSighra নিজস্ব fast count পায়। Mars, Jupiter ও Saturn-এর ক্ষেত্রে উল্টো dependency: mean planet নিজস্ব slow count, śīghra reference Sun। এই mapping-ই Chapter II correction pipeline-এর প্রস্তুতি।

Mercury ও Venus: একই Mean Sun, আলাদা Śīghra Point

Traditional scheme-এ Mercury ও Venus-এর mean planet longitude mean Sun-এর সঙ্গে যুক্ত, কিন্তু তাদের śīghrocca দ্রুত নিজস্ব rate-এ চলে। তাই একই মুহূর্তে তিনটি value আলাদা নামে রাখতে হবে:

MeanSun
MeanMercury        // traditional mapping-এ MeanSun-এর সমান
MercurySighrocca   // 17,937,060 revolutions/cycle

MeanVenus          // traditional mapping-এ MeanSun-এর সমান
VenusSighrocca     // 7,022,376 revolutions/cycle

UI-তে Mercury-এর “mean longitude” দেখিয়ে তার fast count ব্যবহার করলে তা source model-এর সঙ্গে মিলবে না। আবার śīghra point-কে modern heliocentric planet longitude বলাও ভুল। এটি traditional correction geometry-এর auxiliary point।

চন্দ্রোচ্চ ও Rāhu/Node

Mean Moon correction-এর জন্য lunar apogee বা চন্দ্রোচ্চ দরকার। Reference implementation raw Chandrocca motion-এর সঙ্গে 90° initial offset যোগ করে। Node-এর count negative/retrograde এবং 180° initial offset যোগ করা হয়। ফলে general formula-তেই দুইটি বিষয় কাজ করে:

  • Chandrocca: Direction = +1, InitialLongitude = 90°;
  • Rāhu/node: Direction = −1, InitialLongitude = 180°।

আপনার epoch profile অন্য initial state ব্যবহার করলে offsets পরিবর্তিত হতে পারে। Code-এর মধ্যে +90 ও +180 ছড়িয়ে না রেখে target definition-এ রাখুন।

Whole Day থেকে Target Moment: Fractional অহর্গণ

একই civil date-এর midnight, sunrise, noon ও Saṅkrānti time-এ mean longitude এক হবে না। তাই অহর্গণকে শুধু integer রাখলে daily details ও transition search-এ precision হারায়।

ধরা যাক whole-day count W, এবং day boundary থেকে h hour, m minute, s second অতিক্রান্ত:

Fraction = (3600h + 60m + s) / 86400

D = W + Fraction

Traditional nāḍī/ghaṭī input হলে:

১ দিন = ৬০ nāḍī

১ nāḍī = ৬০ vināḍī

Fraction = (60 × nāḍī + vināḍī) / 3600

তবে fraction-এর zero point profile-এর day boundary। Civil midnight থেকে elapsed clock time এবং sunrise থেকে elapsed traditional time একই numerator নয়।

Elapsed না remaining?

Chapter I.67-এর interpretation-এ selected time boundary-এর আগে না পরে—এই orientation গুরুত্বপূর্ণ। Code-এ ambiguous boolean না রেখে enum ব্যবহার করুন:

public enum TimeFractionSense
{
    ElapsedFromBoundary,
    RemainingToBoundary
}

Elapsed হলে fraction যোগ; remaining হলে selected boundary-এর state থেকে motion proportion বাদ। Result trace-এ sense লিখুন।

একই Instant-এ Location কি Mean Planet বদলায়?

একই geocentric instant-এর mean longitude observer-এর শহর বদলালে বদলায় না। কিন্তু শহর বদলালে স্থানীয় date/time, sunrise এবং যে instant-এ দৈনিক পঞ্জিকা evaluate করা হচ্ছে তা বদলে যায়। ফলে location পরোক্ষভাবে input instant নির্ধারণ করে।

  • Dhaka ও New York-এর “12 October 2026, sunrise” একই instant নয়;
  • একই UTC instant দিলে geocentric mean position একই হওয়া উচিত;
  • traditional deśāntara local meridian থেকে reference meridian-এর time difference bridge করে;
  • modern time-zone offset deśāntara নয়;
  • DST civil clock conversion-এ লাগে, planetary model-এর revolution rate-এ নয়।

pancanga3.14 location longitude ও Ujjayinī longitude-এর difference-কে day fraction হিসেবে ব্যবহার করে, পরে sunrise calculation-এর equation যোগ করে। Port করার সময় time-zone conversion, longitude correction ও sunrise correction তিনটি পৃথক step রাখুন।

Worked Table: Epoch-এর ১,০০০ দিন পরে

নিচের উদাহরণ কোনো ঐতিহাসিক তারিখ দাবি করে না। এটি arithmetic verification dataset। ধরা হয়েছে:

  • D = 1,000.0 terrestrial days;
  • N = 1,577,917,828;
  • Sun, Moon ও planets-এর সাধারণ λ₀ = 0°;
  • Mercury/Venus-এর mean rotation = Sun;
  • Chandrocca offset = 90°;
  • Node offset = 180° এবং direction retrograde।
TargetDecimal longitudeRāśi indexWithin rāśi
Mean Sun265.602654589°825° 36′ 09.56″
Mean Moon216.352146520°706° 21′ 07.73″
Mean Mercury265.602654589°825° 36′ 09.56″
Mercury śīghra132.318044334°412° 19′ 04.96″
Mean Venus265.602654589°825° 36′ 09.56″
Venus śīghra162.146395167°512° 08′ 47.02″
Mean Mars164.019378784°514° 01′ 09.76″
Mean Jupiter83.096342327°223° 05′ 46.83″
Mean Saturn33.439307842°103° 26′ 21.51″
Chandrocca201.382910365°621° 22′ 58.48″
Rāhu/node127.015187663°407° 00′ 54.68″

এই table regression test fixture হিসেবে ব্যবহার করা যায়। Mean Mercury ও Mean Venus কেন Mean Sun-এর সমান, অথচ তাদের śīghra values আলাদা—table-টি সেই model distinction-ও দৃশ্যমান করে।

Sun row-এর exact trace

Product = 1,000 × 4,320,000 = 4,320,000,000

Whole revolutions = 2

Remainder = 1,164,164,344

λ̄ = 360° × 1,164,164,344 / 1,577,917,828

λ̄ = 265.602654589°

C# Data Model: Target-এর পরিচয় আলাদা রাখুন

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

public enum MeanPointRole
{
    MeanPlanet,
    Sighrocca,
    LunarApogee,
    LunarNode
}

public sealed class RationalDay
{
    public BigInteger Numerator { get; private set; }
    public BigInteger Denominator { get; private set; }

    public RationalDay(BigInteger numerator, BigInteger denominator)
    {
        if (denominator <= BigInteger.Zero)
            throw new ArgumentOutOfRangeException("denominator");

        BigInteger gcd =
            BigInteger.GreatestCommonDivisor(
                BigInteger.Abs(numerator), denominator);

        Numerator = numerator / gcd;
        Denominator = denominator / gcd;
    }

    public static RationalDay FromWholeAndSeconds(
        BigInteger wholeDays,
        int elapsedSeconds)
    {
        if (elapsedSeconds < 0 || elapsedSeconds >= 86400)
            throw new ArgumentOutOfRangeException(
                "elapsedSeconds");

        return new RationalDay(
            wholeDays * 86400 + elapsedSeconds,
            86400);
    }
}

public sealed class MeanPointDefinition
{
    public string Key { get; set; }
    public string DisplayName { get; set; }
    public MeanPointRole Role { get; set; }
    public BigInteger RevolutionsPerCycle { get; set; }

    // +1 direct, -1 retrograde.
    public int Direction { get; set; }

    // Exact arcseconds at D = 0.
    public BigInteger InitialLongitudeArcSeconds { get; set; }

    public string SourceFormulaId { get; set; }
}

Initial longitude arcsecond-এ রাখলে 90° ও 180° exact integer হয়। আরও সূক্ষ্ম epoch state দরকার হলে rational arcsecond type ব্যবহার করুন।

Traditional target definitions

public static IList<MeanPointDefinition>
    CreateTraditionalTargets()
{
    return new List<MeanPointDefinition>
    {
        Point("mean-sun", "মধ্যম সূর্য",
            MeanPointRole.MeanPlanet, 4320000, +1, 0),

        Point("mean-moon", "মধ্যম চন্দ্র",
            MeanPointRole.MeanPlanet, 57753336, +1, 0),

        // Mercury/Venus mean planet uses Sun rotation.
        Point("mean-mercury", "মধ্যম বুধ",
            MeanPointRole.MeanPlanet, 4320000, +1, 0),
        Point("mercury-sighra", "বুধ শীঘ্র",
            MeanPointRole.Sighrocca, 17937060, +1, 0),

        Point("mean-venus", "মধ্যম শুক্র",
            MeanPointRole.MeanPlanet, 4320000, +1, 0),
        Point("venus-sighra", "শুক্র শীঘ্র",
            MeanPointRole.Sighrocca, 7022376, +1, 0),

        Point("mean-mars", "মধ্যম মঙ্গল",
            MeanPointRole.MeanPlanet, 2296832, +1, 0),
        Point("mean-jupiter", "মধ্যম বৃহস্পতি",
            MeanPointRole.MeanPlanet, 364220, +1, 0),
        Point("mean-saturn", "মধ্যম শনি",
            MeanPointRole.MeanPlanet, 146568, +1, 0),

        Point("lunar-apogee", "চন্দ্রোচ্চ",
            MeanPointRole.LunarApogee, 488203, +1, 90 * 3600),
        Point("lunar-node", "রাহু",
            MeanPointRole.LunarNode, 232238, -1, 180 * 3600)
    };
}

static MeanPointDefinition Point(
    string key,
    string name,
    MeanPointRole role,
    long rotations,
    int direction,
    long initialArcSeconds)
{
    return new MeanPointDefinition
    {
        Key = key,
        DisplayName = name,
        Role = role,
        RevolutionsPerCycle =
            new BigInteger(rotations),
        Direction = direction,
        InitialLongitudeArcSeconds =
            new BigInteger(initialArcSeconds),
        SourceFormulaId = "SS-I-53-54"
    };
}

এই list traditional zero/conjunction example-এর জন্য। Production practical epoch ব্যবহার করলে একই definitions-এর initial longitudes verified epoch state থেকে override হবে।

Exact Mean-Position Engine

১ circle = 1,296,000 arcsecond। Fractional day-সহ সম্পূর্ণ angle-কে rational arcsecond হিসেবে গণনা করলে final conversion-এর আগে precision নষ্ট হয় না।

public sealed class MeanPositionTrace
{
    public string Key { get; set; }
    public BigInteger DayNumerator { get; set; }
    public BigInteger DayDenominator { get; set; }
    public BigInteger Revolutions { get; set; }
    public int Direction { get; set; }
    public BigInteger InitialArcSeconds { get; set; }

    // Normalized angle =
    // NormalizedAngleNumerator / AngleDenominator
    // arcseconds.
    public BigInteger NormalizedAngleNumerator { get; set; }
    public BigInteger AngleDenominator { get; set; }

    public double LongitudeDegrees { get; set; }
    public TraditionalAngle Traditional { get; set; }
}

public static class MeanPositionEngine
{
    static readonly BigInteger ArcSecondsPerCircle =
        new BigInteger(1296000);

    static readonly BigInteger ArcSecondsPerDegree =
        new BigInteger(3600);

    public static readonly BigInteger CivilDaysPerMahayuga =
        new BigInteger(1577917828L);

    public static MeanPositionTrace Calculate(
        RationalDay ahargana,
        MeanPointDefinition point)
    {
        if (point.Direction != 1 && point.Direction != -1)
            throw new ArgumentOutOfRangeException("Direction");

        BigInteger angleDenominator =
            ahargana.Denominator * CivilDaysPerMahayuga;

        BigInteger motionNumerator =
            ahargana.Numerator *
            point.RevolutionsPerCycle *
            point.Direction *
            ArcSecondsPerCircle;

        BigInteger offsetNumerator =
            point.InitialLongitudeArcSeconds *
            angleDenominator;

        BigInteger circleNumerator =
            ArcSecondsPerCircle * angleDenominator;

        BigInteger normalizedNumerator =
            EuclideanMod(
                motionNumerator + offsetNumerator,
                circleNumerator);

        double longitude =
            (double)normalizedNumerator /
            (double)(angleDenominator *
                     ArcSecondsPerDegree);

        return new MeanPositionTrace
        {
            Key = point.Key,
            DayNumerator = ahargana.Numerator,
            DayDenominator = ahargana.Denominator,
            Revolutions = point.RevolutionsPerCycle,
            Direction = point.Direction,
            InitialArcSeconds =
                point.InitialLongitudeArcSeconds,
            NormalizedAngleNumerator =
                normalizedNumerator,
            AngleDenominator = angleDenominator,
            LongitudeDegrees = longitude,
            Traditional =
                TraditionalAngle.FromDegrees(longitude)
        };
    }

    static BigInteger EuclideanMod(
        BigInteger value,
        BigInteger modulus)
    {
        BigInteger result = value % modulus;
        return result.Sign < 0 ? result + modulus : result;
    }
}

এখানে direction negative হলেও normalized numerator সবসময় 0 থেকে এক circle-এর কম। Epoch-এর আগের negative অহর্গণও একই function নিরাপদে handle করে।

সব target একবারে গণনা

public static IDictionary<string, MeanPositionTrace>
    CalculateAll(
        RationalDay ahargana,
        IEnumerable<MeanPointDefinition> points)
{
    var result =
        new Dictionary<string, MeanPositionTrace>(
            StringComparer.OrdinalIgnoreCase);

    foreach (MeanPointDefinition point in points)
    {
        if (result.ContainsKey(point.Key))
            throw new InvalidOperationException(
                "Duplicate mean-point key: " + point.Key);

        result.Add(
            point.Key,
            MeanPositionEngine.Calculate(
                ahargana, point));
    }

    return result;
}

এই dictionary পরবর্তী correction engine-এ typed dependency হিসেবে যাবে। যেমন Mercury correction-এর জন্য mean-mercury, mercury-sighra ও Mercury mandocca দরকার হবে।

Rāśi–Degree–Kalā–Vikalā Formatting

Internal longitude 0°–360° রাখুন; traditional breakdown display-only। Zero-based rāśi index:

Rāśi = floor(λ / 30°)

Degree = floor(λ mod 30°)

Kalā = floor(fractional degree × 60)

Vikalā = remaining fraction × 60

public sealed class TraditionalAngle
{
    public int RasiIndex { get; set; }
    public int Degree { get; set; }
    public int Kala { get; set; }
    public double Vikala { get; set; }

    public static TraditionalAngle FromDegrees(
        double longitude)
    {
        double x = longitude % 360.0;
        if (x < 0.0) x += 360.0;

        int rasi = (int)Math.Floor(x / 30.0);
        double withinRasi = x - rasi * 30.0;

        int degree =
            (int)Math.Floor(withinRasi);

        double minuteValue =
            (withinRasi - degree) * 60.0;

        int kala =
            (int)Math.Floor(minuteValue);

        double vikala =
            (minuteValue - kala) * 60.0;

        return NormalizeCarry(
            rasi, degree, kala, vikala, 2);
    }

    static TraditionalAngle NormalizeCarry(
        int rasi,
        int degree,
        int kala,
        double vikala,
        int decimalPlaces)
    {
        vikala = Math.Round(
            vikala,
            decimalPlaces,
            MidpointRounding.AwayFromZero);

        if (vikala >= 60.0)
        {
            vikala = 0.0;
            kala++;
        }
        if (kala >= 60)
        {
            kala = 0;
            degree++;
        }
        if (degree >= 30)
        {
            degree = 0;
            rasi = (rasi + 1) % 12;
        }

        return new TraditionalAngle
        {
            RasiIndex = rasi,
            Degree = degree,
            Kala = kala,
            Vikala = vikala
        };
    }
}

Classification-এর জন্য rounded TraditionalAngle ব্যবহার করবেন না। 29°59′59.999″ display-তে 30° হয়ে পরের rāśi দেখালেও raw exact angle কোন পাশে আছে তা event search-এ গুরুত্বপূর্ণ।

Rāśi names

static readonly string[] RasiNames =
{
    "মেষ", "বৃষ", "মিথুন", "কর্কট",
    "সিংহ", "কন্যা", "তুলা", "বৃশ্চিক",
    "ধনু", "মকর", "কুম্ভ", "মীন"
};

Index 0 = মেষ। যদি printed Panjika 1–12 numbering ব্যবহার করে, display-তে 1 যোগ করুন; engine key zero-based রাখলে array ও modulo logic সহজ হয়।

একটি Research-Grade Calculation Trace

শুধু final longitude সংরক্ষণ না করে নিচের fields export করুন:

{
  "formulaId": "SS-I-53-54",
  "constantsProfile": "SS-TRADITIONAL",
  "epochId": "PROJECT-EPOCH-...",
  "target": "mean-sun",
  "aharganaNumerator": "...",
  "aharganaDenominator": "...",
  "cycleDays": "1577917828",
  "revolutions": "4320000",
  "direction": 1,
  "initialLongitudeArcSeconds": "0",
  "normalizedAngleNumerator": "...",
  "angleDenominator": "...",
  "longitudeDegrees": 265.602654589,
  "rasiIndex": 8,
  "degree": 25,
  "kala": 36,
  "vikala": 9.56,
  "usesBija": false,
  "usesModernFit": false
}

এই trace দিয়ে:

  • C# বনাম Perl intermediate comparison করা যায়;
  • ভিন্ন epoch profile-এর পার্থক্য আলাদা করা যায়;
  • rounding error ও source-constant error শনাক্ত করা যায়;
  • batch historical HTML পরে পুনর্গঠন করা যায়;
  • API consumer বুঝতে পারে result traditional mean না true/modern।

Validation Strategy

TestExpected result
D = 0প্রতিটি target তার λ₀ ফেরত দেবে
D = Nপূর্ণ cycle পরে একই λ₀
Fraction = 0Whole-day function-এর সঙ্গে exact match
Fraction = 1 dayপরবর্তী whole day-এর সঙ্গে match
D = −1সব longitude 0°–360°-এ normalized
Node direct বনাম retrogradeoffset বাদে angular motion complementary
Mercury/Venus meanTraditional profile-এ mean Sun-এর equal
Worked fixture D = 1000উপরের সব table values tolerance-এর মধ্যে
Cross-languageC# ও reference Perl একই profile-এ match
Same UTC, different cityMean geocentric longitude একই
Different-city sunriseEvaluation instant আলাদা হওয়ায় result আলাদা

Worked-fixture unit test

[TestMethod]
public void MeanSunAtDay1000MatchesFixture()
{
    RationalDay day =
        new RationalDay(1000, 1);

    MeanPointDefinition sun =
        CreateTraditionalTargets()
        .Single(x => x.Key == "mean-sun");

    MeanPositionTrace result =
        MeanPositionEngine.Calculate(day, sun);

    Assert.AreEqual(
        265.602654589,
        result.LongitudeDegrees,
        0.000000001);

    Assert.AreEqual(8, result.Traditional.RasiIndex);
    Assert.AreEqual(25, result.Traditional.Degree);
    Assert.AreEqual(36, result.Traditional.Kala);
    Assert.AreEqual(
        9.56,
        result.Traditional.Vikala,
        0.01);
}

কোন Correction এখনো প্রয়োগ হয়নি?

এই article-এর output পাওয়ার পরও নিচের কাজ বাকি:

  1. প্রতিটি planet-এর mandocca বা slow apsis নির্ধারণ;
  2. manda kendra/anomaly;
  3. epicycle circumference ও bhujā–koṭi geometry;
  4. jyā table interpolation;
  5. manda correction;
  6. śīghra anomaly ও śīghra correction;
  7. planet class অনুযায়ী half/full repeated correction;
  8. final true longitude normalization;
  9. latitude/node correction যেখানে প্রযোজ্য;
  10. modern ephemeris-এর সঙ্গে comparison—replacement নয়।

বিশেষভাবে মনে রাখুন: Mean Sun থেকে Saṅkrānti search চালালে traditional true Sun boundary পাওয়া যাবে না। Saṅkrānti-এর জন্য true solar longitude দরকার; project-এর ModernFit profile তার ওপর একটি পৃথক published-Panjika alignment layer।

সাধারণ Implementation ভুল

একটি rotation field দিয়ে সব planet চালানো

Mercury/Venus mean ও śīghra mapping হারিয়ে যায়। Role-specific target definitions ব্যবহার করুন।

Epoch longitude সব target-এর জন্য 0° ধরা

Demonstration fixture-এ চললেও practical epoch-এ verified λ₀ দরকার। Chandrocca/node-এর offsets বিশেষভাবে গুরুত্বপূর্ণ।

Time-zone hour-কে longitude correction ভাবা

Time zone civil convention; deśāntara geographic meridian difference। পৃথক রাখুন।

Sunrise result ও midnight result তুলনা

প্রথমে exact instant এক করুন। একই date label মানেই একই ahargaṇa fraction নয়।

Negative node count এবং negative direction দুটোই একসঙ্গে দেওয়া

Double negative হয়ে motion direct হয়ে যাবে। Magnitude positive + direction −1 অথবা signed count—একটি convention বেছে নিন। এই article positive magnitude + direction field ব্যবহার করেছে।

Rounded DMS থেকে পরবর্তী correction

True-place engine-এ exact rational/decimal longitude পাঠান; formatted string নয়।

Mean result-এ ModernFit star correction ঢোকানো

1947+ Sankranti correction শুধু তার ঘোষিত solar-date/Saṅkrānti branch-এ থাকবে। Mean Moon, Mars বা tithi calculation-এ নয়।

Production Checklist

  1. Unique instant ও calendar scale resolve হয়েছে?
  2. Ahargaṇa whole/fraction exact?
  3. Epoch ID ও reference meridian আছে?
  4. Cycle-day এবং revolution profile versioned?
  5. Direct/retrograde convention একটিই?
  6. Mercury/Venus mean ও śīghra আলাদা?
  7. Mars/Jupiter/Saturn śīghra reference Sun?
  8. Chandrocca/node initial offsets profile-এ?
  9. BigInteger multiplication ও Euclidean modulo ব্যবহার?
  10. Rounding কেবল display layer-এ?
  11. Rāśi index 0-based না 1-based documented?
  12. Mean/true/modern labels পৃথক?
  13. D = 1000 regression fixture pass?
  14. Same-instant multi-location test pass?
  15. Trace JSON/XML-এ formula ও profile IDs আছে?

উপসংহার

অহর্গণ থেকে mean planet position বের করার arithmetic সংক্ষিপ্ত: elapsed days × revolutions ÷ cycle-days। কিন্তু একটি বিশ্বস্ত implementation-এর প্রকৃত কাজ formula-র চারপাশে—epoch state, target role, direction, initial longitude, fractional day, location-to-instant conversion এবং precision policy।

এই architecture-এ প্রতিটি intermediate quantity নাম ও source পায়। Mean Mercury ও Venus mean Sun-এর সঙ্গে যুক্ত থাকে, কিন্তু তাদের śīghra points পৃথক; node retrograde থাকে; Chandrocca ও node-এর offsets configuration-এ থাকে; এবং exact rational angle display-এর আগে পর্যন্ত অক্ষুণ্ণ থাকে। ফলে Chapter II-এর correction pipeline একটি পরিষ্কার, testable input set পায়।

পরবর্তী প্রবন্ধে শুরু হবে Manda Correction: mean planet ও mandocca থেকে manda kendra, bhujā–koṭi, epicycle measure এবং jyā ব্যবহার করে প্রথম corrected বা স্পষ্ট অবস্থান কীভাবে পাওয়া যায়—শ্লোক, geometry, formula ও C# trace-সহ।

প্রাথমিক পাঠ ও তথ্যসূত্র

  1. Ebenezer Burgess, Translation of the Sûrya-Siddhânta: A Text-book of Hindu Astronomy, 1858/1860; Chapter I mean motions, ahargaṇa, mean-place ও initial configuration-এর public-domain translation।
  2. Sūrya Siddhānta, Chapter I—Sanskrit verse ledger; I.28 angular units, I.29–40 constants, I.48–54 ahargaṇa/mean place, I.56 practical epoch, I.57–58 initial positions এবং I.67 fractional-time rule।
  3. Sūrya Siddhānta I.51–55; mean-place operation এবং reverse-moving node-এর independent translation witness।
  4. M. Yano and M. Fushimi, Pancanga version 3.14; reference implementation description।
  5. pancanga3.14 source; get_mean_long, revolution constants, Mercury/Venus planet–śīghra mapping, Chandrocca/Rāhu offsets, ahargaṇa/JD bridge ও deśāntara path-এর executable reference।

পাঠকের কণ্ঠ

প্রশ্ন ও আলোচনা 0

যেকোনো মন্তব্য বা উত্তরে আবার উত্তর দিন। প্রতিটি উত্তর তার মূল আলোচনার সঙ্গে থাকবে।

আলোচনাটি আপনিই শুরু করুন

এই প্রবন্ধ নিয়ে আপনার প্রশ্ন বা মতামত লিখুন।

আলোচনায় যোগ দিন

আপনার প্রশ্ন বা মতামত

সম্পাদকের অনুমোদনের পর আপনার মন্তব্য প্রকাশিত হবে।