tea-bond 0.3.14__tar.gz → 0.3.15__tar.gz

{tea_bond-0.3.14 → tea_bond-0.3.15}/Cargo.lock

@@ -2195,7 +2195,7 @@ dependencies = [
 
 [[package]]
 name = "pybond"
-version = "0.3.14"
+version = "0.3.15"
 dependencies = [
  "chrono",
  "itertools 0.14.0",
@@ -3117,7 +3117,7 @@ dependencies = [
 
 [[package]]
 name = "tea-bond"
-version = "0.3.14"
+version = "0.3.15"
 dependencies = [
  "anyhow",
  "chrono",
@@ -3136,7 +3136,7 @@ dependencies = [
 
 [[package]]
 name = "tea-calendar"
-version = "0.3.14"
+version = "0.3.15"
 dependencies = [
  "chrono",
 ]

{tea_bond-0.3.14 → tea_bond-0.3.15}/Cargo.toml

@@ -4,7 +4,7 @@ default-members = ["tea-bond", "tea-calendar"]
 resolver = "2"
 
 [workspace.package]
-version = "0.3.14"
+version = "0.3.15"
 edition = "2024"
 
 [workspace.dependencies]

{tea_bond-0.3.14 → tea_bond-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tea-bond
-Version: 0.3.14
+Version: 0.3.15
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{tea_bond-0.3.14/pybond → tea_bond-0.3.15}/pybond/pl.py

@@ -406,7 +406,27 @@ class Bonds:
         """
         return self._evaluator(date=date).remain_cp_num
 
-    # TODO(Teamon): 实现向量化根据净价反推ytm的函数
+    def calc_ytm_with_price(
+        self,
+        date: IntoExpr = "date",
+        dirty_price: IntoExpr = "dirty_price",
+        clean_price: IntoExpr | None = None,
+    ):
+        bond = parse_into_expr(self.bond)
+        date = parse_into_expr(date)
+        if clean_price is None:
+            dirty_price = parse_into_expr(dirty_price)
+        else:
+            assert dirty_price == "dirty_price", (
+                "should not set dirty_price when clean_price is set"
+            )
+            clean_price = parse_into_expr(clean_price)
+            dirty_price = clean_price + self.accrued_interest(date)
+        return register_plugin(
+            args=[bond, date, dirty_price],
+            symbol="bonds_calc_ytm_with_price",
+            is_elementwise=False,
+        )
 
 
 class Futures:

{tea_bond-0.3.14 → tea_bond-0.3.15/pybond}/pybond/pl.py

@@ -406,7 +406,27 @@ class Bonds:
         """
         return self._evaluator(date=date).remain_cp_num
 
-    # TODO(Teamon): 实现向量化根据净价反推ytm的函数
+    def calc_ytm_with_price(
+        self,
+        date: IntoExpr = "date",
+        dirty_price: IntoExpr = "dirty_price",
+        clean_price: IntoExpr | None = None,
+    ):
+        bond = parse_into_expr(self.bond)
+        date = parse_into_expr(date)
+        if clean_price is None:
+            dirty_price = parse_into_expr(dirty_price)
+        else:
+            assert dirty_price == "dirty_price", (
+                "should not set dirty_price when clean_price is set"
+            )
+            clean_price = parse_into_expr(clean_price)
+            dirty_price = clean_price + self.accrued_interest(date)
+        return register_plugin(
+            args=[bond, date, dirty_price],
+            symbol="bonds_calc_ytm_with_price",
+            is_elementwise=False,
+        )
 
 
 class Futures:

{tea_bond-0.3.14 → tea_bond-0.3.15}/pybond/src/batch_eval.rs

@@ -183,6 +183,7 @@ where
     let (future_price, bond_ytm, capital_rate) =
         auto_cast!(Float64(future_price, bond_ytm, capital_rate));
     let date = auto_cast!(Date(date));
+    let bond = auto_cast!(String(bond));
     Ok(batch_eval_impl(
         future.str()?,
         bond.str()?,
@@ -524,7 +525,7 @@ fn evaluators_last_trading_date(
     Ok(result.into_date().into_series())
 }
 
-#[polars_expr(output_type=Date)]
+#[polars_expr(output_type=Float64)]
 fn bonds_remain_year(
     inputs: &[Series],
     kwargs: EvaluatorBatchParams,
@@ -584,6 +585,63 @@ fn bonds_maturity_date(
     Ok(result.into_date().into_series())
 }
 
+#[polars_expr(output_type=Float64)]
+fn bonds_calc_ytm_with_price(
+    inputs: &[Series]
+) -> PolarsResult<Series> {
+    let dirty_price_se = auto_cast!(Float64(&inputs[2]));
+    let bond_se = auto_cast!(String(&inputs[0]));
+    let date_se = auto_cast!(Date(&inputs[1]));
+    let len = dirty_price_se.len();
+    let bond = bond_se.str()?;
+    let date = date_se.date()?;
+    let dirty_price = dirty_price_se.f64()?;
+    let mut bond_iter = bond.iter();
+    let mut date_iter = date.physical().iter();
+    let mut bond = CachedBond::new(bond_iter.next().unwrap().unwrap_or(""), None).unwrap();
+    let mut dirty_price_iter = dirty_price.iter();
+    let mut date_physical = date_iter.next().unwrap().unwrap_or(0);
+    let mut date = EPOCH
+        .checked_add_days(Days::new(date_physical as u64))
+        .unwrap();
+    let mut dirty_price = dirty_price_iter.next().unwrap().unwrap_or(f64::NAN);
+    let mut result = Vec::with_capacity(len);
+    if bond.bond_code().is_empty() {
+        result.push(None)
+    } else {
+        result.push(bond.calc_ytm_with_price(dirty_price, date, None, None).ok().filter(|v| !v.is_nan()))
+    }
+    for _ in 1..len {
+        if let Some(dp) = dirty_price_iter.next() {
+            dirty_price = dp.unwrap_or(f64::NAN);
+        };
+        if let Some(dt) = date_iter.next() {
+            let dt = dt.unwrap_or(0);
+            if dt != date_physical {
+                date_physical = dt;
+                date = EPOCH.checked_add_days(Days::new(dt as u64)).unwrap()
+            }
+        };
+        if let Some(b) = bond_iter.next() {
+            if let Some(b) = b {
+                if b != bond.code() && bond.bond_code != b {
+                    bond = CachedBond::new(b, None).unwrap();
+                }
+            } else {
+                result.push(None);
+                continue;
+            }
+        };
+        if bond.bond_code().is_empty() {
+            result.push(None);
+        } else {
+            result.push(bond.calc_ytm_with_price(dirty_price, date, None, None).ok().filter(|v| !v.is_nan()))
+        }
+    }
+    let result: Float64Chunked = result.into_iter().collect_trusted();
+    Ok(result.into_series())
+}
+
 #[derive(Deserialize)]
 struct FindWorkdayKwargs {
     market: Market,

{tea_bond-0.3.14 → tea_bond-0.3.15}/tea-bond/src/bond/mod.rs

@@ -345,6 +345,15 @@ impl Bond {
     ) -> Result<f64> {
         match self.interest_type {
             InterestType::Fixed => {
+                if self.is_zero_coupon() {
+                    let remain_year = self.remain_year(date);
+                    if remain_year >= 1. {
+                        return Ok((self.par_value / dirty_price).powf(1.0 / remain_year) - 1.)
+                    } else {
+                        return Ok((self.par_value / dirty_price - 1.) * remain_year)
+                    }
+                    
+                }
                 let inst_freq = self.inst_freq as f64;
                 let coupon = self.get_coupon();
                 let (pre_cp_date, next_cp_date) =

{tea_bond-0.3.14 → tea_bond-0.3.15}/tea-bond/src/tf_evaluator/evaluator.rs

@@ -161,7 +161,8 @@ impl TfEvaluator {
     pub fn with_accrued_interest(mut self) -> Result<Self> {
         if self.accrued_interest.is_none() {
             if self.bond.is_zero_coupon() {
-                self.accrued_interest = Some(0.);
+                let days = ACTUAL.count_days(self.bond.carry_date, self.date);
+                self.accrued_interest = Some(self.bond.cp_rate * self.bond.par_value * days as f64 / 365.);
                 return Ok(self);
             }
             let mut out = self.with_nearest_cp_dates()?;
@@ -181,7 +182,11 @@ impl TfEvaluator {
         if self.dirty_price.is_none() {
             if self.bond.is_zero_coupon() {
                 let remain_year = self.bond.remain_year(self.date);
-                self.dirty_price = Some(100.0 / (1.0+self.bond.ytm()).powf(remain_year));
+                if remain_year > 1. {
+                    self.dirty_price = Some(self.bond.par_value / (1.0+self.bond.ytm()).powf(remain_year));
+                } else {
+                    self.dirty_price = Some(self.bond.par_value / (1.0+self.bond.ytm() * remain_year));
+                }
                 return Ok(self);
             }
             let mut out = self.with_remain_cp_num()?;