Lunar Month: conjunction longitude, amānta নাম ও adhika-māsa detection

সূর্যসিদ্ধান্তীয় true Sun–Moon conjunction থেকে অমান্ত চান্দ্রমাস, মাসের নাম, zero/one/two ingress classification, অধিমাস ও ক্ষয়মাস context নির্ণয়ের JD-safe C# পদ্ধতি।

একটি তিথি বা করণ বর্তমান elongation থেকেই জানা যায়; কিন্তু চান্দ্রমাস জানতে একটি সম্পূর্ণ lunation-এর দুই প্রান্ত দেখতে হয়। বর্তমান দিনের Sun/Moon state যথেষ্ট নয়—আগের এবং পরের conjunction, তাদের মাঝের solar ingress এবং neighboring month sequence দরকার।

Lunation ও অমান্ত মাস

True Moon–Sun elongation:

E(t) = normalize(λM(t) − λS(t))

Astronomical New Moon বা conjunction-এ:

E(tN) = 0°

λM(tN) = λS(tN)

পরপর দুই conjunction Ni এবং Ni+1 একটি canonical amānta lunation:

Li = [Ni, Ni+1)

Half-open interval ব্যবহার করলে boundary ownership স্পষ্ট: conjunction instant নতুন lunation-এর অন্তর্ভুক্ত; আগেরটির নয়। Civil sunrise-based মাসের প্রথম displayed day আলাদা rule layer—astronomical lunation boundary নিজে exact instant।

New Moon Root কীভাবে নির্ণয় করবেন?

Normalized elongation 359° থেকে 0°-এ ফিরে আসে। তাই সরাসরি E == 0 বা sign change খোঁজা বিপজ্জনক। একটি signed angular difference ব্যবহার করুন:

D(t) = atan2(sin(λM−λS), cos(λM−λS))

−180° < D ≤ 180°

New Moon-এর কাছে D negative থেকে positive হয়। কিন্তু Full Moon-এর কাছে signed angle +180° থেকে −180°-এ discontinuously লাফ দেয়। তাই bracket গ্রহণের সময়:

  • left ≤ 0 এবং right ≥ 0 হতে হবে;
  • step-এর angular change ছোট হতে হবে;
  • root-এ Sun/Moon separation tolerance-এর মধ্যে হতে হবে;
  • Moon-এর relative motion forward কিনা verify করতে হবে।

বর্তমান Instant থেকে আগের ও পরের Conjunction

Article 71-এর continuous tithi value:

T = E/12, যেখানে 0 ≤ T < 30

Traditional mean synodic month:

S = YugaCivilDays / (MoonRevolutions − SunRevolutions)

S = 29.530587946… দিন

Root-এর initial guess:

Previous guess = t − T × (S/30)

Next guess = t + (30−T) × (S/30)

এগুলো final conjunction নয়; bracket center মাত্র। True Sun/Moon manda correction-এর কারণে exact root guess থেকে সরে যায়। Guess-এর চারপাশে কয়েক দিনের window scan করে তারপর bisection বা Brent solve করুন।

Conjunction-এ কোন Longitude সংরক্ষণ করবেন?

Root instant-এ Sun ও Moon longitude সমান। একটি NewMoonEvent-এ রাখুন:

  • absolute ahargana/JD;
  • true Sun longitude;
  • true Moon longitude;
  • solar rāśi index;
  • angular residual;
  • astronomical profile/version।

Reference source-এর clong ও nclong নাম “current/next conjunction solar longitude” বোঝায়—শুধু conjunction time নয়। Modern DTO-তে time ও longitude আলাদা field রাখলে ambiguity দূর হয়।

দুই New Moon-এর মধ্যে ০/১/২ Saṅkrānti

Lunation interval [Ni, Ni+1) এর মধ্যে true nirayaṇa Sun-এর 30° boundary crossing count করুন:

Ingress countClassificationঅর্থ
0Adhikaপুরো lunation-এ Sun নতুন rāśi-তে প্রবেশ করেনি
1Regularস্বাভাবিক একটি Saṅkrānti; তার target rāśi month-name দেয়
2Kṣaya contextএক lunation-এ দুই ingress; একটি expected month identity পৃথক lunation হিসেবে প্রকাশিত হয় না

Count করার safest উপায় exact ingress roots list করা। শুধু দুই endpoint-এর floor(Sun/30) তুলনা zero-ingress regular case-এ কাজ করলেও exact boundary, 360° wrap ও two-ingress edge case-এ evidence হারায়।

Interval ownership

Ingress list-ও [start, end) convention ব্যবহার করবে। Start conjunction-এর exact instant-এ Sun 30° boundary-তে থাকলে সেই ingress নতুন lunation-এর event; end conjunction-এর exact instant-এ হলে পরের lunation-এর event। একটি shared time tolerance ও ownership comparator ব্যবহার করুন।

Saṅkrānti Target থেকে মাসের নাম

Regular amānta lunation-এ যে একমাত্র solar ingress ঘটে, তার target rāśi-এর সঙ্গে month name map হয়:

Ingress targetIndexAmānta month
মেষ0চৈত্র
বৃষ1বৈশাখ
মিথুন2জ্যৈষ্ঠ
কর্কট3আষাঢ়
সিংহ4শ্রাবণ
কন্যা5ভাদ্রপদ
তুলা6আশ্বিন
বৃশ্চিক7কার্তিক
ধনু8মার্গশীর্ষ
মকর9পৌষ
কুম্ভ10মাঘ
মীন11ফাল্গুন

Names localization resource-এ রাখুন; astronomy layer numeric BaseMonthIndex দেবে। “মার্গশীর্ষ/অগ্রহায়ণ”, “আশ্বিন/আশ্বয়ুজ” ইত্যাদি regional display নাম একই canonical index থেকে আসতে পারে।

অধিমাস ও পরবর্তী নিজ মাস

Zero-ingress lunation-এর নিজস্ব ingress নেই। তার base month name আসে পরবর্তী regular ingress-এর target থেকে। ফলে সাধারণ sequence:

Adhika X → Nija/Śuddha X → পরবর্তী month

Software-এ দুটি X একই string হলেও identity আলাদা:

FieldAdhika XNija X
BaseMonthIndexএকই Xএকই X
KindAdhikaNija/Regular
Ingress count01
Lunation IDস্বতন্ত্রস্বতন্ত্র

একটি current lunation zero-ingress বুঝলেই নাম finalize করবেন না; future look-ahead করে প্রথম regular ingress সংগ্রহ করুন। Cache-এ resolver version ও look-ahead evidence রাখুন।

ক্ষয়মাস Context: দুই Ingress-এর অর্থ

এক lunation-এ দুইটি Saṅkrānti হলে normal one-ingress-one-name correspondence ভেঙে যায়। “ক্ষয়মাস” ছোট 28 দিনের মাস নয় এবং তিথিক্ষয়ও নয়; month-name sequence-এর একটি identity আলাদা lunation হিসেবে অনুপস্থিত থাকে।

Production resolver:

  1. দুই ingress-এর exact instant ও target rāśi সংরক্ষণ করবে;
  2. আগের ও পরের কয়েকটি lunation classification দেখবে;
  3. published tradition/profile অনুযায়ী assigned ও suppressed identity নির্ধারণ করবে;
  4. একটি blind monthIndex + 2 shortcut ব্যবহার করবে না;
  5. output-এ evidence trace রাখবে।

Worked Example: অহর্গণ 1000

Article 71-এর true luminaries থেকে evaluation instant-এ:

Quantityমান
True Sun265.921211747°
True Moon215.043371342°
Elongation309.122159595°
Continuous tithi T25.760179966
Mean synodic month S29.530587946 দিন

Guess-কে signed-angle conjunction root-এ refine করলে:

EventAharganaConjunction longitudeSolar sign
Previous New Moon Ni974.752551261240.091008186°ধনু
Next New Moon Ni+11004.478725175270.502184870°মকর

Lunation length = 29.726173914 দিন

Interval-এর solar ingress = 1টি, মকর 270°

Classification = Regular

Base month index = 9

Amānta month = পৌষ

দুই conjunction-এর Sun sign আলাদা হওয়ায় এটি adhika নয়। Exact ingress list মকর boundary একবার অতিক্রম নিশ্চিত করে; তাই regular পৌষ।

Reference Code থেকে Formula Reconstruction

pancanga3.14-এর flow:

  1. বর্তমান true Sun/Moon থেকে continuous tithi;
  2. mean synodic month দিয়ে previous/next conjunction guess;
  3. guess-এর ±2 দিনের মধ্যে conjunction search;
  4. root-এ true Sun longitude ফেরত;
  5. previous ও next conjunction solar sign একই হলে Adhika-;
  6. current Sun sign ও previous-conjunction sign থেকে month index নির্বাচন।

এই logic ঐতিহাসিক reference পুনর্গঠনে গুরুত্বপূর্ণ। Production extension-এ আমরা তিনটি পরিবর্তন করি:

  • conjunction time ও solar longitude আলাদা field;
  • same-sign boolean-এর বদলে exact ingress event list;
  • 0/1/2 ingress classification ও kṣaya neighborhood resolver।

C# 5/.NET Framework 4 Implementation

নিচের code Article 71-এর CalculateLuminaries, Normalize360 এবং Article 66-এর yuga constants reuse করে।

public enum LunarMonthKind
{
    Regular,
    Adhika,
    Nija,
    KshayaContext
}

public sealed class NewMoonEvent
{
    public double Ahargana { get; set; }
    public double TrueSunLongitude { get; set; }
    public double TrueMoonLongitude { get; set; }
    public int SolarRashiIndex { get; set; }
    public double ResidualDegrees { get; set; }
}

public sealed class SolarIngressEvent
{
    public double Ahargana { get; set; }
    public double TargetLongitude { get; set; }
    public int TargetRashiIndex { get; set; }
}

public sealed class LunarMonthDecision
{
    public NewMoonEvent Start { get; set; }
    public NewMoonEvent End { get; set; }
    public IList<SolarIngressEvent> Ingresses { get; set; }
    public LunarMonthKind Kind { get; set; }
    public int? BaseMonthIndex { get; set; }
    public string BaseMonthName { get; set; }
    public string RuleTrace { get; set; }
}

Signed elongation

static double Normalize180(double degrees)
{
    double value = Normalize360(degrees);
    return value > 180.0 ? value - 360.0 : value;
}

static double SignedElongation(double ahargana)
{
    LuminaryState l = CalculateLuminaries(ahargana);
    return Normalize180(l.TrueMoon - l.TrueSun);
}

Normalize180 −180° থেকে +180° phase দেয়। Opposition discontinuity reject করার জন্য bracket-এর phase jump পরীক্ষা করতে হবে।

Conjunction root near a guess

static NewMoonEvent FindConjunctionNear(double guess)
{
    const double step = 1.0 / 8.0; // 3 hours
    double left = guess - 2.0;
    double fLeft = SignedElongation(left);
    bool bracketed = false;
    double right = left;
    double fRight = fLeft;

    for (int i = 1; i <= 32; i++)
    {
        right = guess - 2.0 + i * step;
        fRight = SignedElongation(right);

        // Negative-to-positive, without the Full Moon discontinuity.
        if (fLeft <= 0.0 && fRight >= 0.0 &&
            Math.Abs(fRight - fLeft) < 30.0)
        {
            bracketed = true;
            break;
        }

        left = right;
        fLeft = fRight;
    }

    if (!bracketed)
        throw new InvalidOperationException(
            "Conjunction root guess-এর চার দিনে পাওয়া যায়নি।");

    while (right - left > 1e-8)
    {
        double middle = (left + right) / 2.0;
        if (SignedElongation(middle) >= 0.0)
            right = middle;
        else
            left = middle;
    }

    double root = (left + right) / 2.0;
    LuminaryState state = CalculateLuminaries(root);
    double residual = Normalize180(
        state.TrueMoon - state.TrueSun);

    return new NewMoonEvent
    {
        Ahargana = root,
        TrueSunLongitude = state.TrueSun,
        TrueMoonLongitude = state.TrueMoon,
        SolarRashiIndex =
            (int)Math.Floor(state.TrueSun / 30.0),
        ResidualDegrees = residual
    };
}

Previous and next New Moon

const double YugaCivilDays = 1577917828.0;
const double SunRevolutions = 4320000.0;
const double MoonRevolutions = 57753336.0;

static void FindBoundingNewMoons(
    double ahargana,
    out NewMoonEvent previous,
    out NewMoonEvent next)
{
    LuminaryState state = CalculateLuminaries(ahargana);
    double elongation = Normalize360(
        state.TrueMoon - state.TrueSun);
    double continuousTithi = elongation / 12.0;
    double synodicMonth = YugaCivilDays /
        (MoonRevolutions - SunRevolutions);

    double previousGuess = ahargana -
        continuousTithi * (synodicMonth / 30.0);
    double nextGuess = ahargana +
        (30.0 - continuousTithi) * (synodicMonth / 30.0);

    previous = FindConjunctionNear(previousGuess);
    next = FindConjunctionNear(nextGuess);

    if (!(previous.Ahargana <= ahargana &&
          ahargana < next.Ahargana))
        throw new InvalidOperationException(
            "Bounding conjunction chronology is invalid.");
}

Solar longitude unwrap

static double UnwrappedSun(
    double ahargana,
    double baseSun)
{
    double current =
        CalculateLuminaries(ahargana).TrueSun;
    return baseSun + Normalize360(current - baseSun);
}

এক lunation-এ Sun 360° ঘোরে না; তাই start-এর তুলনায় one-cycle unwrap নিরাপদ। Multi-year search-এ accumulated cycle count দরকার।

Ingress roots in a lunation

static List<SolarIngressEvent> FindIngresses(
    NewMoonEvent start,
    NewMoonEvent end)
{
    var result = new List<SolarIngressEvent>();
    double baseSun = start.TrueSunLongitude;
    double endSun = UnwrappedSun(end.Ahargana, baseSun);
    double scaled = baseSun / 30.0;
    double nearestBoundary = Math.Round(scaled);
    bool startsOnBoundary =
        Math.Abs(scaled - nearestBoundary) < 1e-10;
    double target = startsOnBoundary
        ? nearestBoundary * 30.0
        : (Math.Floor(scaled) + 1.0) * 30.0;

    while (target < endSun - 1e-9)
    {
        double left = start.Ahargana;
        double right = end.Ahargana;

        while (right - left > 1e-8)
        {
            double middle = (left + right) / 2.0;
            if (UnwrappedSun(middle, baseSun) >= target)
                right = middle;
            else
                left = middle;
        }

        int rashi = ((int)Math.Round(target / 30.0)) % 12;
        result.Add(new SolarIngressEvent
        {
            Ahargana = (left + right) / 2.0,
            TargetLongitude = target,
            TargetRashiIndex = rashi
        });

        target += 30.0;
    }

    return result;
}

Exact end-boundary ownership-এর জন্য এখানে endSun - 1e-9 ব্যবহৃত। Production-এ angular epsilon ও time epsilon central configuration-এ রাখুন এবং start-boundary case-এর explicit test লিখুন।

Classification

static readonly string[] LunarMonthNames =
{
    "চৈত্র", "বৈশাখ", "জ্যৈষ্ঠ", "আষাঢ়",
    "শ্রাবণ", "ভাদ্রপদ", "আশ্বিন", "কার্তিক",
    "মার্গশীর্ষ", "পৌষ", "মাঘ", "ফাল্গুন"
};

static LunarMonthDecision ClassifyLunation(
    NewMoonEvent start,
    NewMoonEvent end)
{
    List<SolarIngressEvent> ingresses =
        FindIngresses(start, end);

    var decision = new LunarMonthDecision
    {
        Start = start,
        End = end,
        Ingresses = ingresses
    };

    if (ingresses.Count == 0)
    {
        decision.Kind = LunarMonthKind.Adhika;
        decision.BaseMonthIndex = null; // resolve by look-ahead
        decision.RuleTrace = "0 ingress: Adhika; name pending.";
    }
    else if (ingresses.Count == 1)
    {
        int index = ingresses[0].TargetRashiIndex;
        decision.Kind = LunarMonthKind.Regular;
        decision.BaseMonthIndex = index;
        decision.BaseMonthName = LunarMonthNames[index];
        decision.RuleTrace = "1 ingress: regular month.";
    }
    else if (ingresses.Count == 2)
    {
        decision.Kind = LunarMonthKind.KshayaContext;
        decision.BaseMonthIndex = null;
        decision.RuleTrace =
            "2 ingresses: neighborhood resolver required.";
    }
    else
    {
        throw new InvalidOperationException(
            "এক lunation-এ দুইটির বেশি solar ingress পাওয়া গেছে।");
    }

    return decision;
}

Adhika name look-ahead

static void ResolveAdhikaName(
    LunarMonthDecision adhika,
    IList<LunarMonthDecision> following)
{
    if (adhika.Kind != LunarMonthKind.Adhika)
        throw new ArgumentException("Decision is not Adhika.");

    for (int i = 0; i < following.Count; i++)
    {
        LunarMonthDecision next = following[i];
        if (next.Ingresses.Count == 1)
        {
            int index = next.Ingresses[0].TargetRashiIndex;
            adhika.BaseMonthIndex = index;
            adhika.BaseMonthName = LunarMonthNames[index];
            adhika.RuleTrace +=
                " Name from next regular ingress.";

            if (next.Kind == LunarMonthKind.Regular)
                next.Kind = LunarMonthKind.Nija;
            return;
        }
    }

    throw new InvalidOperationException(
        "Adhika month name-এর জন্য regular look-ahead নেই।");
}

Kṣaya context-কে এই simple look-ahead-এ force করবেন না। তার জন্য neighboring sequence, দুই ingress target এবং declared tradition সহ পৃথক resolver লাগবে।

পূর্ণিমান্ত Display কীভাবে আলাদা?

Adhika/Kṣaya classification-এর canonical basis হিসেবে amānta New-Moon-to-New-Moon sequence রাখা সবচেয়ে পরিষ্কার। পূর্ণিমান্ত calendar একই lunar phases-কে Full Moon boundary-তে display মাসে ভাগ করে:

  • regular শুক্লপক্ষে amānta ও pūrṇimānta name সাধারণত একই;
  • regular কৃষ্ণপক্ষে pūrṇimānta display next amānta month identity ব্যবহার করে;
  • Adhika/Nija/Kṣaya sequence-এ blind +1 নয়—canonical lunation links অনুসরণ করুন;
  • festival rule কোন system-এর month-name চায়, তা rule metadata-তে লিখুন।

অমান্ত ও পূর্ণিমান্ত দুটি আলাদা astronomy নয়; একই tithi sequence-এর দুটি month-boundary convention। Core record-এ phase ও lunation canonical রাখুন, presentation layer-এ system-specific name দিন।

Historical ও Multi-location Safety

Geocentric New Moon এবং nirayaṇa solar ingress absolute astronomical event। একই profile-এ Dhaka, Kolkata ও New York-এর জন্য event JD ও month classification একই থাকবে। তবে local civil date, weekday ও sunrise-day আলাদা হতে পারে।

  • core chronology ahargana/JD-তে রাখুন;
  • Julian/Gregorian dual labels display layer-এ দিন;
  • 1582/1752 civil skip-কে lunation duration-এ ঢোকাবেন না;
  • early year-এ DateTime range পরীক্ষা করুন;
  • cache key-তে profile, constants, bīja এবং solver version রাখুন;
  • location cache-এ শুধু local rendering রাখুন।

Regression ও Boundary Tests

[TestMethod]
public void Ahargana1000_LunarMonthFixture()
{
    NewMoonEvent previous;
    NewMoonEvent next;
    FindBoundingNewMoons(1000.0, out previous, out next);
    LunarMonthDecision month = ClassifyLunation(previous, next);

    Assert.AreEqual(974.752551261, previous.Ahargana, 1e-9);
    Assert.AreEqual(240.091008186,
        previous.TrueSunLongitude, 1e-9);
    Assert.AreEqual(1004.478725175, next.Ahargana, 1e-9);
    Assert.AreEqual(270.502184870,
        next.TrueSunLongitude, 1e-9);
    Assert.AreEqual(29.726173914,
        next.Ahargana - previous.Ahargana, 1e-9);
    Assert.AreEqual(1, month.Ingresses.Count);
    Assert.AreEqual(9, month.Ingresses[0].TargetRashiIndex);
    Assert.AreEqual(LunarMonthKind.Regular, month.Kind);
    Assert.AreEqual(9, month.BaseMonthIndex.Value);
    Assert.AreEqual("পৌষ", month.BaseMonthName);
    Assert.IsTrue(Math.Abs(previous.ResidualDegrees) < 1e-7);
    Assert.IsTrue(Math.Abs(next.ResidualDegrees) < 1e-7);
}

Structural test suite

  • evaluation instant দুই returned conjunction-এর মধ্যে;
  • conjunction root-এ true Sun ≈ true Moon;
  • Full Moon discontinuity conjunction হিসেবে গ্রহণ নয়;
  • New Moon exact instant নতুন lunation-এর start;
  • end conjunction [start,end) ingress list-এর বাইরে;
  • 0 ingress → Adhika;
  • 1 ingress → Regular ও target rāśi month index;
  • 2 ingress → KshayaContext;
  • Adhika name পরবর্তী regular ingress থেকে;
  • পরবর্তী same-name regular month Nija;
  • মীন→মেষ solar wrap-এ month index 0;
  • conjunction ঠিক 30° boundary-তে ownership deterministic;
  • same absolute events সব location-এ same classification;
  • local civil labels timezone অনুযায়ী আলাদা।

Property tests

  • প্রতিটি returned lunation duration sensible configured range-এ;
  • New Moon sequence strictly increasing;
  • প্রতিটি regular month-এর exactly one ingress;
  • Adhika month-এর zero ingress;
  • একটি ingress দুই lunation-এ duplicate নয়;
  • Base month index 0–11;
  • 12 regular ingress targets cyclic order বজায় রাখে;
  • serialized trace থেকে decision পুনর্গঠন করা যায়।

সাধারণ ভুল ও লক্ষণ

ভুললক্ষণসমাধান
Fixed 29/30-day tableHistorical month driftExact conjunction roots
Normalized E sign-changeFull Moon ভুল rootSigned angle + jump filter
Guess-কে final New MoonBoundary ঘণ্টা সরে যায়Root refinement
শুধু current Sun signMonth near boundary ভুলFull lunation ingress list
Endpoint sign equality-ই সবKṣaya evidence হারায়Exact 0/1/2 event count
Adhika নাম current sign থেকেRepeated name ভুলNext regular ingress look-ahead
Kṣaya = short monthConceptual misclassificationName-sequence context
Tithikṣaya = Kṣayamāsaদুটি আলাদা ঘটনা মিশে যায়Separate models
Amānta/Pūrṇimānta core মিশ্রণকৃষ্ণপক্ষ label ভুলCanonical lunation + display mapping
Modern-fit correction leakTithi/month inconsistencyProfile isolation
Local DateTime coreHistorical/calendar-gap errorJD/ahargana core

Production trace-এ রাখুন

  • astronomical profile ও constants version;
  • evaluation ahargana/JD ও continuous tithi;
  • previous/next guess;
  • conjunction brackets, iterations ও residual;
  • conjunction Sun/Moon longitudes;
  • lunation interval convention;
  • প্রতিটি ingress instant ও target rāśi;
  • ingress count ও classification;
  • base month index, qualifier ও naming evidence;
  • Adhika look-ahead/Nija link;
  • Kṣaya neighboring sequence evidence;
  • display system—Amānta/Pūrṇimānta।

Production Checklist

  1. True Sun/Moon একই profile-এর?
  2. Conjunction signed-angle root-solved?
  3. Full Moon discontinuity rejected?
  4. Previous ≤ instant < next chronology?
  5. Lunation [start,end) convention?
  6. Exact solar ingress list?
  7. 0/1/2 count classification?
  8. Regular name ingress target থেকে?
  9. Adhika name look-ahead থেকে?
  10. Nija identity পৃথক?
  11. Kṣaya full resolver-এ?
  12. Amānta core ও Pūrṇimānta display পৃথক?
  13. Historical JD ও dual civil labels?
  14. Regression এবং rare-case tests pass?

উপসংহার

চান্দ্রমাস কোনো fixed civil-date block নয়। এটি consecutive true Sun–Moon conjunction-এর মধ্যবর্তী lunation। সেই interval-এ নিরয়ণ Sun-এর exact 30° ingress count থেকেই regular, adhika বা kṣaya context নির্ধারিত হয়।

Reference algorithm-এর conjunction guess, root এবং same-sign adhika test ঐতিহাসিক reconstruction-এর শক্ত ভিত্তি। Production engine-এ time ও longitude আলাদা model, exact ingress list, 0/1/2 classification, Adhika–Nija link এবং Kṣaya neighborhood resolver যোগ করলে ফল গবেষণাযোগ্য ও ব্যাখ্যাযোগ্য হয়।

পরবর্তী প্রবন্ধে Saṅkrānti Calculation দেখানো হবে—true Sun-এর 30° boundary crossing, exact ingress root, Meṣa→Mīna target cycle, deśāntara/local time এবং Bengali month-start rule থেকে calculation layer বিচ্ছিন্ন রাখার পদ্ধতি।

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

  1. Ebenezer Burgess, Translation of the Sûrya-Siddhânta: A Text-book of Hindu Astronomy, 1858/1860; conjunction, lunar month এবং intercalation সম্পর্কিত public-domain translation ও notes।
  2. Yano–Fushimi pancanga3.14 source; get_conj, get_clong, get_nclong, adhimasa_p ও get_masa_num-এর executable reference।

পাঠকের কণ্ঠ

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

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

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

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

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

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

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