use crate::calendar::jieqi::{is_before_lichun, jieqi};
use crate::time::jd::JulianDay;
use crate::time::solar_time::equation_of_time_seconds;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Tiangan {
Jia,
Yi,
Bing,
Ding,
Wu,
Ji,
Geng,
Xin,
Ren,
Gui,
}
impl Tiangan {
pub fn from_index(index: usize) -> Self {
match index % 10 {
0 => Tiangan::Jia,
1 => Tiangan::Yi,
2 => Tiangan::Bing,
3 => Tiangan::Ding,
4 => Tiangan::Wu,
5 => Tiangan::Ji,
6 => Tiangan::Geng,
7 => Tiangan::Xin,
8 => Tiangan::Ren,
9 => Tiangan::Gui,
_ => unreachable!(),
}
}
pub fn index(&self) -> usize {
match self {
Tiangan::Jia => 0,
Tiangan::Yi => 1,
Tiangan::Bing => 2,
Tiangan::Ding => 3,
Tiangan::Wu => 4,
Tiangan::Ji => 5,
Tiangan::Geng => 6,
Tiangan::Xin => 7,
Tiangan::Ren => 8,
Tiangan::Gui => 9,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Dizhi {
Zi,
Chou,
Yin,
Mao,
Chen,
Si,
Wu,
Wei,
Shen,
You,
Xu,
Hai,
}
impl Dizhi {
pub fn from_index(index: usize) -> Self {
match index % 12 {
0 => Dizhi::Zi,
1 => Dizhi::Chou,
2 => Dizhi::Yin,
3 => Dizhi::Mao,
4 => Dizhi::Chen,
5 => Dizhi::Si,
6 => Dizhi::Wu,
7 => Dizhi::Wei,
8 => Dizhi::Shen,
9 => Dizhi::You,
10 => Dizhi::Xu,
11 => Dizhi::Hai,
_ => unreachable!(),
}
}
pub fn index(&self) -> usize {
match self {
Dizhi::Zi => 0,
Dizhi::Chou => 1,
Dizhi::Yin => 2,
Dizhi::Mao => 3,
Dizhi::Chen => 4,
Dizhi::Si => 5,
Dizhi::Wu => 6,
Dizhi::Wei => 7,
Dizhi::Shen => 8,
Dizhi::You => 9,
Dizhi::Xu => 10,
Dizhi::Hai => 11,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct GanZhi {
pub gan: Tiangan,
pub zhi: Dizhi,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Bazi {
pub year: GanZhi,
pub month: GanZhi,
pub day: GanZhi,
pub hour: GanZhi,
}
pub fn bazi(year: i32, month: u32, day: u32, hour: u32, minute: u32, longitude: f64) -> Bazi {
let jd_midnight = JulianDay::from_ymd(year, month, day).0;
let jd_std = jd_midnight + hour as f64 / 24.0 + minute as f64 / 1440.0;
let mlon = (longitude / 15.0).round() * 15.0;
let jd_lmt = jd_std + (longitude - mlon) / 15.0 / 24.0;
let jd_apparent = jd_lmt + equation_of_time_seconds(jd_lmt) / 86400.0;
let jd_app_mid = jd_apparent.floor();
let jd_app_noon = jd_app_mid + 0.5;
let hour_index = ((hour as i32 + 1) / 2) as usize % 12;
let day_gz = day_ganzhi(jd_app_noon);
let hour_gz = GanZhi {
gan: Tiangan::from_index(rat_rule(day_gz.gan).index() + hour_index),
zhi: Dizhi::from_index(hour_index),
};
let (ay, _, _) = JulianDay(jd_apparent).to_ymd();
let year_gz = year_ganzhi(ay, is_before_lichun(jd_apparent, ay));
let month_gz = month_ganzhi(year_gz.gan, jd_apparent);
Bazi {
year: year_gz,
month: month_gz,
day: day_gz,
hour: hour_gz,
}
}
pub fn day_ganzhi(jd: f64) -> GanZhi {
let day_num = (jd + 0.5).floor() as i64;
let idx = ((day_num - 11) % 60 + 60) % 60;
GanZhi {
gan: Tiangan::from_index(idx as usize),
zhi: Dizhi::from_index(idx as usize),
}
}
pub fn year_ganzhi(year: i32, is_before_lichun: bool) -> GanZhi {
let base_year = 1984; let y = if is_before_lichun { year - 1 } else { year };
let idx = ((y - base_year) % 60 + 60) % 60;
GanZhi {
gan: Tiangan::from_index(idx as usize),
zhi: Dizhi::from_index(idx as usize),
}
}
fn tiger_rule(year_tg: Tiangan) -> Tiangan {
match year_tg {
Tiangan::Jia | Tiangan::Ji => Tiangan::Bing,
Tiangan::Yi | Tiangan::Geng => Tiangan::Wu,
Tiangan::Bing | Tiangan::Xin => Tiangan::Geng,
Tiangan::Ding | Tiangan::Ren => Tiangan::Ren,
Tiangan::Wu | Tiangan::Gui => Tiangan::Jia,
}
}
fn rat_rule(day_tg: Tiangan) -> Tiangan {
match day_tg {
Tiangan::Jia | Tiangan::Ji => Tiangan::Jia,
Tiangan::Yi | Tiangan::Geng => Tiangan::Bing,
Tiangan::Bing | Tiangan::Xin => Tiangan::Wu,
Tiangan::Ding | Tiangan::Ren => Tiangan::Geng,
Tiangan::Wu | Tiangan::Gui => Tiangan::Ren,
}
}
pub fn month_branch(jd: f64) -> Dizhi {
const MONTH_STARTS: [(u32, usize); 12] = [
(0, 2),
(2, 3),
(4, 4),
(6, 5),
(8, 6),
(10, 7),
(12, 8),
(14, 9),
(16, 10),
(18, 11),
(20, 0),
(22, 1),
];
let (year, _, _) = JulianDay(jd).to_ymd();
let spring_this = jieqi(year, 0);
let spring_prev = jieqi(year - 1, 0);
let solar_term_year = if jd >= spring_this {
year
} else if jd >= spring_prev {
year - 1
} else {
year - 2
};
let mut boundaries: Vec<(f64, usize)> = MONTH_STARTS
.iter()
.map(|&(n, dz)| {
(jieqi(solar_term_year, n), dz)
})
.collect();
boundaries.push((jieqi(solar_term_year + 1, 0), 2));
for i in 0..boundaries.len() - 1 {
if jd >= boundaries[i].0 && jd < boundaries[i + 1].0 {
return Dizhi::from_index(boundaries[i].1);
}
}
Dizhi::from_index(2) }
pub fn month_ganzhi(year_tg: Tiangan, jd: f64) -> GanZhi {
let dz = month_branch(jd);
let dz_idx = dz.index();
let start_tg = tiger_rule(year_tg);
let offset = (dz_idx + 12 - 2) % 12;
let gan = Tiangan::from_index(start_tg.index() + offset);
GanZhi { gan, zhi: dz }
}
pub fn hour_ganzhi(day_tg: Tiangan, hour_index: usize) -> GanZhi {
let start_tg = rat_rule(day_tg);
let gan = Tiangan::from_index(start_tg.index() + hour_index);
let zhi = Dizhi::from_index(hour_index);
GanZhi { gan, zhi }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_day_ganzhi_2000_01_01() {
let gz = day_ganzhi(2451545.0);
assert_eq!(gz.gan, Tiangan::Wu);
assert_eq!(gz.zhi, Dizhi::Wu);
}
#[test]
fn test_year_ganzhi_2000() {
let before = year_ganzhi(2000, true);
assert_eq!(before.gan, Tiangan::Ji);
assert_eq!(before.zhi, Dizhi::Mao);
let after = year_ganzhi(2000, false);
assert_eq!(after.gan, Tiangan::Geng);
assert_eq!(after.zhi, Dizhi::Chen);
}
#[test]
fn test_tiger_rule() {
assert_eq!(tiger_rule(Tiangan::Jia), Tiangan::Bing);
assert_eq!(tiger_rule(Tiangan::Yi), Tiangan::Wu);
assert_eq!(tiger_rule(Tiangan::Geng), Tiangan::Wu);
}
#[test]
fn test_rat_rule() {
assert_eq!(rat_rule(Tiangan::Jia), Tiangan::Jia);
assert_eq!(rat_rule(Tiangan::Yi), Tiangan::Bing);
assert_eq!(rat_rule(Tiangan::Geng), Tiangan::Bing);
}
#[test]
fn test_hour_ganzhi() {
let gz = hour_ganzhi(Tiangan::Jia, 0);
assert_eq!(gz.gan, Tiangan::Jia);
assert_eq!(gz.zhi, Dizhi::Zi);
let gz = hour_ganzhi(Tiangan::Jia, 1);
assert_eq!(gz.gan, Tiangan::Yi);
assert_eq!(gz.zhi, Dizhi::Chou);
let gz = hour_ganzhi(Tiangan::Yi, 0);
assert_eq!(gz.gan, Tiangan::Bing);
assert_eq!(gz.zhi, Dizhi::Zi);
}
#[test]
fn test_month_branch_known() {
let winter = JulianDay::from_ymd(2024, 2, 3).0;
assert_eq!(month_branch(winter), Dizhi::Chou, "立春前一天应为丑月");
assert_eq!(
month_branch(winter + 1.0),
Dizhi::Chou,
"立春日00:00UT仍在丑月"
);
let after = JulianDay::from_ymd(2024, 2, 5).0;
assert_eq!(month_branch(after), Dizhi::Yin, "立春次日应为寅月");
}
#[test]
fn test_month_ganzhi_2024() {
let spring = JulianDay::from_ymd(2024, 2, 5).0;
let gz = month_ganzhi(Tiangan::Geng, spring);
assert_eq!(gz.gan, Tiangan::Wu, "庚年寅月=戊寅");
assert_eq!(gz.zhi, Dizhi::Yin);
}
}