merge duration, mduration #44

merge price, yield #29

merge fvschedule #56

merge pricedisc, pricemat, yielddisc, yieldmat, disc, received, intrate #57

merge accrint, accrintm #58

merge coupdaybs, coupdays, coupdaysnc, coupncd, coupnum, couppcd #59

fix cursor

refactor

refactor

fix build

base/src/expressions/parser/static_analysis.rs

@@ -550,6 +550,14 @@ fn args_signature_irr(arg_count: usize) -> Vec<Signature> {
     }
 }
 
+fn args_signature_fvschedule(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Scalar, Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
 fn args_signature_xirr(arg_count: usize) -> Vec<Signature> {
     if arg_count == 2 {
         vec![Signature::Vector; arg_count]
@@ -752,6 +760,7 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Dollarfr => args_signature_scalars(arg_count, 2, 0),
         Function::Effect => args_signature_scalars(arg_count, 2, 0),
         Function::Fv => args_signature_scalars(arg_count, 3, 2),
+        Function::Fvschedule => args_signature_fvschedule(arg_count),
         Function::Ipmt => args_signature_scalars(arg_count, 4, 2),
         Function::Irr => args_signature_irr(arg_count),
         Function::Ispmt => args_signature_scalars(arg_count, 4, 0),
@@ -759,9 +768,20 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Nominal => args_signature_scalars(arg_count, 2, 0),
         Function::Nper => args_signature_scalars(arg_count, 3, 2),
         Function::Npv => args_signature_npv(arg_count),
+        Function::Duration => args_signature_scalars(arg_count, 5, 1),
+        Function::Mduration => args_signature_scalars(arg_count, 5, 1),
         Function::Pduration => args_signature_scalars(arg_count, 3, 0),
+        Function::Accrint => args_signature_scalars(arg_count, 6, 2),
+        Function::Accrintm => args_signature_scalars(arg_count, 4, 1),
+        Function::Coupdaybs => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupdays => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupdaysnc => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupncd => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupnum => args_signature_scalars(arg_count, 3, 1),
+        Function::Couppcd => args_signature_scalars(arg_count, 3, 1),
         Function::Pmt => args_signature_scalars(arg_count, 3, 2),
         Function::Ppmt => args_signature_scalars(arg_count, 4, 2),
+        Function::Price => args_signature_scalars(arg_count, 6, 1),
         Function::Pv => args_signature_scalars(arg_count, 3, 2),
         Function::Rate => args_signature_scalars(arg_count, 3, 3),
         Function::Rri => args_signature_scalars(arg_count, 3, 0),
@@ -770,6 +790,14 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Tbilleq => args_signature_scalars(arg_count, 3, 0),
         Function::Tbillprice => args_signature_scalars(arg_count, 3, 0),
         Function::Tbillyield => args_signature_scalars(arg_count, 3, 0),
+        Function::Yield => args_signature_scalars(arg_count, 6, 1),
+        Function::Pricedisc => args_signature_scalars(arg_count, 4, 1),
+        Function::Pricemat => args_signature_scalars(arg_count, 5, 1),
+        Function::Yielddisc => args_signature_scalars(arg_count, 4, 1),
+        Function::Yieldmat => args_signature_scalars(arg_count, 5, 1),
+        Function::Disc => args_signature_scalars(arg_count, 4, 1),
+        Function::Received => args_signature_scalars(arg_count, 4, 1),
+        Function::Intrate => args_signature_scalars(arg_count, 4, 1),
         Function::Xirr => args_signature_xirr(arg_count),
         Function::Xnpv => args_signature_xnpv(arg_count),
         Function::Besseli => args_signature_scalars(arg_count, 2, 0),
@@ -1016,6 +1044,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Dollarfr => not_implemented(args),
         Function::Effect => not_implemented(args),
         Function::Fv => not_implemented(args),
+        Function::Fvschedule => not_implemented(args),
         Function::Ipmt => not_implemented(args),
         Function::Irr => not_implemented(args),
         Function::Ispmt => not_implemented(args),
@@ -1023,9 +1052,20 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Nominal => not_implemented(args),
         Function::Nper => not_implemented(args),
         Function::Npv => not_implemented(args),
+        Function::Duration => not_implemented(args),
+        Function::Mduration => not_implemented(args),
         Function::Pduration => not_implemented(args),
+        Function::Accrint => not_implemented(args),
+        Function::Accrintm => not_implemented(args),
+        Function::Coupdaybs => not_implemented(args),
+        Function::Coupdays => not_implemented(args),
+        Function::Coupdaysnc => not_implemented(args),
+        Function::Coupncd => not_implemented(args),
+        Function::Coupnum => not_implemented(args),
+        Function::Couppcd => not_implemented(args),
         Function::Pmt => not_implemented(args),
         Function::Ppmt => not_implemented(args),
+        Function::Price => not_implemented(args),
         Function::Pv => not_implemented(args),
         Function::Rate => not_implemented(args),
         Function::Rri => not_implemented(args),
@@ -1034,6 +1074,14 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Tbilleq => not_implemented(args),
         Function::Tbillprice => not_implemented(args),
         Function::Tbillyield => not_implemented(args),
+        Function::Yield => not_implemented(args),
+        Function::Pricedisc => not_implemented(args),
+        Function::Pricemat => not_implemented(args),
+        Function::Yielddisc => not_implemented(args),
+        Function::Yieldmat => not_implemented(args),
+        Function::Disc => not_implemented(args),
+        Function::Received => not_implemented(args),
+        Function::Intrate => not_implemented(args),
         Function::Xirr => not_implemented(args),
         Function::Xnpv => not_implemented(args),
         Function::Besseli => scalar_arguments(args),

base/src/functions/mod.rs

@@ -217,6 +217,14 @@ pub enum Function {
     Isoweeknum,
 
     // Financial
+    Accrint,
+    Accrintm,
+    Coupdaybs,
+    Coupdays,
+    Coupdaysnc,
+    Coupncd,
+    Coupnum,
+    Couppcd,
     Cumipmt,
     Cumprinc,
     Db,
@@ -225,6 +233,7 @@ pub enum Function {
     Dollarfr,
     Effect,
     Fv,
+    Fvschedule,
     Ipmt,
     Irr,
     Ispmt,
@@ -232,9 +241,12 @@ pub enum Function {
     Nominal,
     Nper,
     Npv,
+    Duration,
+    Mduration,
     Pduration,
     Pmt,
     Ppmt,
+    Price,
     Pv,
     Rate,
     Rri,
@@ -243,8 +255,16 @@ pub enum Function {
     Tbilleq,
     Tbillprice,
     Tbillyield,
+    Pricedisc,
+    Pricemat,
+    Yielddisc,
+    Yieldmat,
+    Disc,
+    Received,
+    Intrate,
     Xirr,
     Xnpv,
+    Yield,
 
     // Engineering: Bessel and transcendental functions
     Besseli,
@@ -313,7 +333,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 256> {
+    pub fn into_iter() -> IntoIter<Function, 276> {
         [
             Function::And,
             Function::False,
@@ -474,18 +494,23 @@ impl Function {
             Function::WorkdayIntl,
             Function::Yearfrac,
             Function::Isoweeknum,
+            Function::Accrint,
+            Function::Accrintm,
             Function::Pmt,
             Function::Pv,
             Function::Rate,
             Function::Nper,
             Function::Fv,
+            Function::Fvschedule,
             Function::Ppmt,
+            Function::Price,
             Function::Ipmt,
             Function::Npv,
             Function::Mirr,
             Function::Irr,
             Function::Xirr,
             Function::Xnpv,
+            Function::Yield,
             Function::Rept,
             Function::Textafter,
             Function::Textbefore,
@@ -497,10 +522,25 @@ impl Function {
             Function::Syd,
             Function::Nominal,
             Function::Effect,
+            Function::Duration,
+            Function::Mduration,
             Function::Pduration,
+            Function::Coupdaybs,
+            Function::Coupdays,
+            Function::Coupdaysnc,
+            Function::Coupncd,
+            Function::Coupnum,
+            Function::Couppcd,
             Function::Tbillyield,
             Function::Tbillprice,
             Function::Tbilleq,
+            Function::Pricedisc,
+            Function::Pricemat,
+            Function::Yielddisc,
+            Function::Yieldmat,
+            Function::Disc,
+            Function::Received,
+            Function::Intrate,
             Function::Dollarde,
             Function::Dollarfr,
             Function::Ddb,
@@ -813,15 +853,20 @@ impl Function {
             "YEARFRAC" => Some(Function::Yearfrac),
             "ISOWEEKNUM" | "_XLFN.ISOWEEKNUM" => Some(Function::Isoweeknum),
             // Financial
+            "ACCRINT" => Some(Function::Accrint),
+            "ACCRINTM" => Some(Function::Accrintm),
             "PMT" => Some(Function::Pmt),
             "PV" => Some(Function::Pv),
             "RATE" => Some(Function::Rate),
             "NPER" => Some(Function::Nper),
             "FV" => Some(Function::Fv),
+            "FVSCHEDULE" => Some(Function::Fvschedule),
             "PPMT" => Some(Function::Ppmt),
+            "PRICE" => Some(Function::Price),
             "IPMT" => Some(Function::Ipmt),
             "NPV" => Some(Function::Npv),
             "XNPV" => Some(Function::Xnpv),
+            "YIELD" => Some(Function::Yield),
             "MIRR" => Some(Function::Mirr),
             "IRR" => Some(Function::Irr),
             "XIRR" => Some(Function::Xirr),
@@ -832,11 +877,27 @@ impl Function {
             "SYD" => Some(Function::Syd),
             "NOMINAL" => Some(Function::Nominal),
             "EFFECT" => Some(Function::Effect),
+            "DURATION" => Some(Function::Duration),
+            "MDURATION" => Some(Function::Mduration),
             "PDURATION" | "_XLFN.PDURATION" => Some(Function::Pduration),
 
+            "COUPDAYBS" => Some(Function::Coupdaybs),
+            "COUPDAYS" => Some(Function::Coupdays),
+            "COUPDAYSNC" => Some(Function::Coupdaysnc),
+            "COUPNCD" => Some(Function::Coupncd),
+            "COUPNUM" => Some(Function::Coupnum),
+            "COUPPCD" => Some(Function::Couppcd),
+
             "TBILLYIELD" => Some(Function::Tbillyield),
             "TBILLPRICE" => Some(Function::Tbillprice),
             "TBILLEQ" => Some(Function::Tbilleq),
+            "PRICEDISC" => Some(Function::Pricedisc),
+            "PRICEMAT" => Some(Function::Pricemat),
+            "YIELDDISC" => Some(Function::Yielddisc),
+            "YIELDMAT" => Some(Function::Yieldmat),
+            "DISC" => Some(Function::Disc),
+            "RECEIVED" => Some(Function::Received),
+            "INTRATE" => Some(Function::Intrate),
 
             "DOLLARDE" => Some(Function::Dollarde),
             "DOLLARFR" => Some(Function::Dollarfr),
@@ -1052,18 +1113,23 @@ impl fmt::Display for Function {
             Function::WorkdayIntl => write!(f, "WORKDAY.INTL"),
             Function::Yearfrac => write!(f, "YEARFRAC"),
             Function::Isoweeknum => write!(f, "ISOWEEKNUM"),
+            Function::Accrint => write!(f, "ACCRINT"),
+            Function::Accrintm => write!(f, "ACCRINTM"),
             Function::Pmt => write!(f, "PMT"),
             Function::Pv => write!(f, "PV"),
             Function::Rate => write!(f, "RATE"),
             Function::Nper => write!(f, "NPER"),
             Function::Fv => write!(f, "FV"),
+            Function::Fvschedule => write!(f, "FVSCHEDULE"),
             Function::Ppmt => write!(f, "PPMT"),
+            Function::Price => write!(f, "PRICE"),
             Function::Ipmt => write!(f, "IPMT"),
             Function::Npv => write!(f, "NPV"),
             Function::Mirr => write!(f, "MIRR"),
             Function::Irr => write!(f, "IRR"),
             Function::Xirr => write!(f, "XIRR"),
             Function::Xnpv => write!(f, "XNPV"),
+            Function::Yield => write!(f, "YIELD"),
             Function::Rept => write!(f, "REPT"),
             Function::Textafter => write!(f, "TEXTAFTER"),
             Function::Textbefore => write!(f, "TEXTBEFORE"),
@@ -1075,10 +1141,25 @@ impl fmt::Display for Function {
             Function::Syd => write!(f, "SYD"),
             Function::Nominal => write!(f, "NOMINAL"),
             Function::Effect => write!(f, "EFFECT"),
+            Function::Duration => write!(f, "DURATION"),
+            Function::Mduration => write!(f, "MDURATION"),
             Function::Pduration => write!(f, "PDURATION"),
+            Function::Coupdaybs => write!(f, "COUPDAYBS"),
+            Function::Coupdays => write!(f, "COUPDAYS"),
+            Function::Coupdaysnc => write!(f, "COUPDAYSNC"),
+            Function::Coupncd => write!(f, "COUPNCD"),
+            Function::Coupnum => write!(f, "COUPNUM"),
+            Function::Couppcd => write!(f, "COUPPCD"),
             Function::Tbillyield => write!(f, "TBILLYIELD"),
             Function::Tbillprice => write!(f, "TBILLPRICE"),
             Function::Tbilleq => write!(f, "TBILLEQ"),
+            Function::Pricedisc => write!(f, "PRICEDISC"),
+            Function::Pricemat => write!(f, "PRICEMAT"),
+            Function::Yielddisc => write!(f, "YIELDDISC"),
+            Function::Yieldmat => write!(f, "YIELDMAT"),
+            Function::Disc => write!(f, "DISC"),
+            Function::Received => write!(f, "RECEIVED"),
+            Function::Intrate => write!(f, "INTRATE"),
             Function::Dollarde => write!(f, "DOLLARDE"),
             Function::Dollarfr => write!(f, "DOLLARFR"),
             Function::Ddb => write!(f, "DDB"),
@@ -1329,18 +1410,24 @@ impl Model {
             Function::WorkdayIntl => self.fn_workday_intl(args, cell),
             Function::Yearfrac => self.fn_yearfrac(args, cell),
             Function::Isoweeknum => self.fn_isoweeknum(args, cell),
+            // Financial
+            Function::Accrint => self.fn_accrint(args, cell),
+            Function::Accrintm => self.fn_accrintm(args, cell),
             Function::Pmt => self.fn_pmt(args, cell),
             Function::Pv => self.fn_pv(args, cell),
             Function::Rate => self.fn_rate(args, cell),
             Function::Nper => self.fn_nper(args, cell),
             Function::Fv => self.fn_fv(args, cell),
+            Function::Fvschedule => self.fn_fvschedule(args, cell),
             Function::Ppmt => self.fn_ppmt(args, cell),
+            Function::Price => self.fn_price(args, cell),
             Function::Ipmt => self.fn_ipmt(args, cell),
             Function::Npv => self.fn_npv(args, cell),
             Function::Mirr => self.fn_mirr(args, cell),
             Function::Irr => self.fn_irr(args, cell),
             Function::Xirr => self.fn_xirr(args, cell),
             Function::Xnpv => self.fn_xnpv(args, cell),
+            Function::Yield => self.fn_yield(args, cell),
             Function::Rept => self.fn_rept(args, cell),
             Function::Textafter => self.fn_textafter(args, cell),
             Function::Textbefore => self.fn_textbefore(args, cell),
@@ -1352,10 +1439,25 @@ impl Model {
             Function::Syd => self.fn_syd(args, cell),
             Function::Nominal => self.fn_nominal(args, cell),
             Function::Effect => self.fn_effect(args, cell),
+            Function::Duration => self.fn_duration(args, cell),
+            Function::Mduration => self.fn_mduration(args, cell),
             Function::Pduration => self.fn_pduration(args, cell),
+            Function::Coupdaybs => self.fn_coupdaybs(args, cell),
+            Function::Coupdays => self.fn_coupdays(args, cell),
+            Function::Coupdaysnc => self.fn_coupdaysnc(args, cell),
+            Function::Coupncd => self.fn_coupncd(args, cell),
+            Function::Coupnum => self.fn_coupnum(args, cell),
+            Function::Couppcd => self.fn_couppcd(args, cell),
             Function::Tbillyield => self.fn_tbillyield(args, cell),
             Function::Tbillprice => self.fn_tbillprice(args, cell),
             Function::Tbilleq => self.fn_tbilleq(args, cell),
+            Function::Pricedisc => self.fn_pricedisc(args, cell),
+            Function::Pricemat => self.fn_pricemat(args, cell),
+            Function::Yielddisc => self.fn_yielddisc(args, cell),
+            Function::Yieldmat => self.fn_yieldmat(args, cell),
+            Function::Disc => self.fn_disc(args, cell),
+            Function::Received => self.fn_received(args, cell),
+            Function::Intrate => self.fn_intrate(args, cell),
             Function::Dollarde => self.fn_dollarde(args, cell),
             Function::Dollarfr => self.fn_dollarfr(args, cell),
             Function::Ddb => self.fn_ddb(args, cell),

base/src/test/mod.rs

@@ -11,14 +11,19 @@ mod test_datedif_leap_month_end;
 mod test_days360_month_end;
 mod test_degrees_radians;
 mod test_error_propagation;
+mod test_fn_accrint;
+mod test_fn_accrintm;
 mod test_fn_average;
 mod test_fn_averageifs;
 mod test_fn_choose;
 mod test_fn_concatenate;
 mod test_fn_count;
+mod test_fn_coupon;
 mod test_fn_day;
+mod test_fn_duration;
 mod test_fn_exact;
 mod test_fn_financial;
+mod test_fn_financial_bonds;
 mod test_fn_formulatext;
 mod test_fn_if;
 mod test_fn_maxifs;
@@ -63,6 +68,7 @@ mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;
 mod test_fn_round;
+mod test_fn_fvschedule;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_geomean;

base/src/test/test_fn_accrint.rs

@@ -0,0 +1,134 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn fn_accrint() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,1,1)");
+    model._set("A3", "=DATE(2020,1,31)");
+    model._set("A4", "10%");
+    model._set("A5", "$1,000");
+    model._set("A6", "2");
+
+    model._set("B1", "=ACCRINT(A1,A2,A3,A4,A5,A6)");
+    model._set("C1", "=ACCRINT(A1)");
+    model._set("C2", "=ACCRINT(A1,A2,A3,A4,A5,3)");
+
+    model.evaluate();
+
+    match model.get_cell_value_by_ref("Sheet1!B1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 8.333333333333334).abs() < 1e-9);
+        }
+        other => unreachable!("Expected number for B1, got {:?}", other),
+    }
+    assert_eq!(model._get_text("C1"), *"#ERROR!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
+}
+
+#[test]
+fn fn_accrint_parameters() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,1,1)");
+    model._set("A3", "=DATE(2020,7,1)");
+    model._set("A4", "8%");
+    model._set("A5", "1000");
+
+    model._set("B1", "=ACCRINT(A1,A2,A3,A4,A5,2,0,TRUE)");
+    model._set("B2", "=ACCRINT(A1,A2,A3,A4,A5,2,1,TRUE)");
+    model._set("B3", "=ACCRINT(A1,A2,A3,A4,A5,2,4,TRUE)");
+    model._set("B4", "=ACCRINT(A1,A2,A3,A4,A5,1)");
+    model._set("B5", "=ACCRINT(A1,A2,A3,A4,A5,4)");
+    model._set("B6", "=ACCRINT(A1,A2,A3,A4,A5,2)");
+    model._set("B7", "=ACCRINT(A1,A2,A3,A4,A5,2,0)");
+
+    model.evaluate();
+
+    match model.get_cell_value_by_ref("Sheet1!B1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 40.0).abs() < 1e-9);
+        }
+        other => unreachable!("Expected number for B1, got {:?}", other),
+    }
+
+    match (
+        model.get_cell_value_by_ref("Sheet1!B1"),
+        model.get_cell_value_by_ref("Sheet1!B6"),
+    ) {
+        (Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
+            assert!((v1 - v2).abs() < 1e-12);
+        }
+        other => unreachable!("Expected matching numbers, got {:?}", other),
+    }
+}
+
+#[test]
+fn fn_accrint_errors() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,1,1)");
+    model._set("A3", "=DATE(2020,7,1)");
+    model._set("A4", "8%");
+    model._set("A5", "1000");
+
+    model._set("B1", "=ACCRINT()");
+    model._set("B2", "=ACCRINT(A1,A2,A3,A4,A5)");
+    model._set("B3", "=ACCRINT(A1,A2,A3,A4,A5,2,0,TRUE,1)");
+    model._set("C1", "=ACCRINT(A1,A2,A3,A4,A5,0)");
+    model._set("C2", "=ACCRINT(A1,A2,A3,A4,A5,3)");
+    model._set("C3", "=ACCRINT(A1,A2,A3,A4,A5,-1)");
+    model._set("D1", "=ACCRINT(A1,A2,A3,A4,A5,2,-1)");
+    model._set("D2", "=ACCRINT(A1,A2,A3,A4,A5,2,5)");
+    model._set("E1", "=ACCRINT(A3,A2,A1,A4,A5,2)");
+    model._set("E2", "=ACCRINT(A1,A3,A1,A4,A5,2)");
+    model._set("F1", "=ACCRINT(A1,A2,A3,A4,0,2)");
+    model._set("F2", "=ACCRINT(A1,A2,A3,A4,-1000,2)");
+    model._set("F3", "=ACCRINT(A1,A2,A3,-8%,A5,2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+    assert_eq!(model._get_text("C1"), *"#NUM!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
+    assert_eq!(model._get_text("C3"), *"#NUM!");
+    assert_eq!(model._get_text("D1"), *"#NUM!");
+    assert_eq!(model._get_text("D2"), *"#NUM!");
+    assert_eq!(model._get_text("E1"), *"#NUM!");
+    assert_eq!(model._get_text("E2"), *"#NUM!");
+    assert_eq!(model._get_text("F2"), *"#NUM!");
+    assert_eq!(model._get_text("F3"), *"#NUM!");
+
+    match model.get_cell_value_by_ref("Sheet1!F1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 0.0).abs() < 1e-9);
+        }
+        other => unreachable!("Expected 0 for F1, got {:?}", other),
+    }
+}
+
+#[test]
+fn fn_accrint_combined() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2018,10,15)");
+    model._set("A2", "=DATE(2019,2,1)");
+    model._set("A3", "5%");
+    model._set("A4", "1000");
+
+    model._set("B1", "=ACCRINT(A1,A1,A2,A3,A4,2)");
+
+    model.evaluate();
+
+    match model.get_cell_value_by_ref("Sheet1!B1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 14.722222222222221).abs() < 1e-9);
+        }
+        other => unreachable!("Expected number for B1, got {:?}", other),
+    }
+}

base/src/test/test_fn_accrintm.rs

@@ -0,0 +1,122 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn fn_accrintm() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,7,1)");
+    model._set("A3", "10%");
+    model._set("A4", "$1,000");
+
+    model._set("B1", "=ACCRINTM(A1,A2,A3,A4)");
+    model._set("C1", "=ACCRINTM(A1)");
+
+    model.evaluate();
+
+    match model.get_cell_value_by_ref("Sheet1!B1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 50.0).abs() < 1e-9);
+        }
+        other => unreachable!("Expected number for B1, got {:?}", other),
+    }
+    assert_eq!(model._get_text("C1"), *"#ERROR!");
+}
+
+#[test]
+fn fn_accrintm_parameters() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,7,1)");
+    model._set("A3", "8%");
+    model._set("A4", "1000");
+
+    model._set("B1", "=ACCRINTM(A1,A2,A3,A4,0)");
+    model._set("B2", "=ACCRINTM(A1,A2,A3,A4,1)");
+    model._set("B3", "=ACCRINTM(A1,A2,A3,A4,4)");
+    model._set("C1", "=ACCRINTM(A1,A2,A3,A4)");
+
+    model.evaluate();
+
+    match (
+        model.get_cell_value_by_ref("Sheet1!B1"),
+        model.get_cell_value_by_ref("Sheet1!B2"),
+    ) {
+        (Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
+            assert!(v1 > 0.0 && v2 > 0.0);
+        }
+        other => unreachable!("Expected numbers for basis test, got {:?}", other),
+    }
+
+    match (
+        model.get_cell_value_by_ref("Sheet1!B1"),
+        model.get_cell_value_by_ref("Sheet1!C1"),
+    ) {
+        (Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
+            assert!((v1 - v2).abs() < 1e-12);
+        }
+        other => unreachable!(
+            "Expected matching numbers for default test, got {:?}",
+            other
+        ),
+    }
+}
+
+#[test]
+fn fn_accrintm_errors() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2020,7,1)");
+    model._set("A3", "8%");
+    model._set("A4", "1000");
+
+    model._set("B1", "=ACCRINTM()");
+    model._set("B2", "=ACCRINTM(A1,A2,A3)");
+    model._set("B3", "=ACCRINTM(A1,A2,A3,A4,0,1)");
+    model._set("C1", "=ACCRINTM(A1,A2,A3,A4,-1)");
+    model._set("C2", "=ACCRINTM(A1,A2,A3,A4,5)");
+    model._set("D1", "=ACCRINTM(A2,A1,A3,A4)");
+    model._set("E1", "=ACCRINTM(A1,A2,A3,0)");
+    model._set("E2", "=ACCRINTM(A1,A2,A3,-1000)");
+    model._set("E3", "=ACCRINTM(A1,A2,-8%,A4)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+    assert_eq!(model._get_text("C1"), *"#NUM!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
+    assert_eq!(model._get_text("D1"), *"#NUM!");
+    assert_eq!(model._get_text("E2"), *"#NUM!");
+    assert_eq!(model._get_text("E3"), *"#NUM!");
+
+    match model.get_cell_value_by_ref("Sheet1!E1") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 0.0).abs() < 1e-9);
+        }
+        other => unreachable!("Expected 0 for E1, got {:?}", other),
+    }
+}
+
+#[test]
+fn fn_accrintm_combined() {
+    let mut model = new_empty_model();
+    model._set("C1", "=DATE(2016,4,5)");
+    model._set("C2", "=DATE(2019,2,1)");
+    model._set("A3", "5%");
+    model._set("A4", "1000");
+    model._set("B2", "=ACCRINTM(C1,C2,A3,A4)");
+
+    model.evaluate();
+
+    match model.get_cell_value_by_ref("Sheet1!B2") {
+        Ok(CellValue::Number(v)) => {
+            assert!((v - 141.11111111111111).abs() < 1e-9);
+        }
+        other => unreachable!("Expected number for B2, got {:?}", other),
+    }
+}

base/src/test/test_fn_coupon.rs

@@ -0,0 +1,260 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn fn_coupon_functions() {
+    let mut model = new_empty_model();
+
+    // Test with basis 1 (original test)
+    model._set("A1", "=DATE(2001,1,25)");
+    model._set("A2", "=DATE(2001,11,15)");
+    model._set("B1", "=COUPDAYBS(A1,A2,2,1)");
+    model._set("B2", "=COUPDAYS(A1,A2,2,1)");
+    model._set("B3", "=COUPDAYSNC(A1,A2,2,1)");
+    model._set("B4", "=COUPNCD(A1,A2,2,1)");
+    model._set("B5", "=COUPNUM(A1,A2,2,1)");
+    model._set("B6", "=COUPPCD(A1,A2,2,1)");
+
+    // Test with basis 3 for better coverage
+    model._set("C1", "=COUPDAYBS(DATE(2001,1,25),DATE(2001,11,15),2,3)");
+    model._set("C2", "=COUPDAYS(DATE(2001,1,25),DATE(2001,11,15),2,3)");
+    model._set("C3", "=COUPDAYSNC(DATE(2001,1,25),DATE(2001,11,15),2,3)");
+    model._set("C4", "=COUPNCD(DATE(2001,1,25),DATE(2001,11,15),2,3)");
+    model._set("C5", "=COUPNUM(DATE(2007,1,25),DATE(2008,11,15),2,1)");
+    model._set("C6", "=COUPPCD(DATE(2001,1,25),DATE(2001,11,15),2,3)");
+
+    model.evaluate();
+
+    // Test basis 1
+    assert_eq!(model._get_text("B1"), "71");
+    assert_eq!(model._get_text("B2"), "181");
+    assert_eq!(model._get_text("B3"), "110");
+    assert_eq!(
+        model.get_cell_value_by_ref("Sheet1!B4"),
+        Ok(CellValue::Number(37026.0))
+    );
+    assert_eq!(model._get_text("B5"), "2");
+    assert_eq!(
+        model.get_cell_value_by_ref("Sheet1!B6"),
+        Ok(CellValue::Number(36845.0))
+    );
+
+    // Test basis 3 (more comprehensive coverage)
+    assert_eq!(model._get_text("C1"), "71");
+    assert_eq!(model._get_text("C2"), "181"); // Fixed: actual days
+    assert_eq!(model._get_text("C3"), "110");
+    assert_eq!(model._get_text("C4"), "37026");
+    assert_eq!(model._get_text("C5"), "4");
+    assert_eq!(model._get_text("C6"), "36845");
+}
+
+#[test]
+fn fn_coupon_functions_error_cases() {
+    let mut model = new_empty_model();
+
+    // Test invalid frequency
+    model._set("E1", "=COUPDAYBS(DATE(2001,1,25),DATE(2001,11,15),3,1)");
+    // Test invalid basis
+    model._set("E2", "=COUPDAYS(DATE(2001,1,25),DATE(2001,11,15),2,5)");
+    // Test settlement >= maturity
+    model._set("E3", "=COUPDAYSNC(DATE(2001,11,15),DATE(2001,1,25),2,1)");
+    // Test too few arguments
+    model._set("E4", "=COUPNCD(DATE(2001,1,25),DATE(2001,11,15))");
+    // Test too many arguments
+    model._set("E5", "=COUPNUM(DATE(2001,1,25),DATE(2001,11,15),2,1,1)");
+
+    model.evaluate();
+
+    // All should return errors
+    assert_eq!(model._get_text("E1"), "#NUM!");
+    assert_eq!(model._get_text("E2"), "#NUM!");
+    assert_eq!(model._get_text("E3"), "#NUM!");
+    assert_eq!(model._get_text("E4"), *"#ERROR!");
+    assert_eq!(model._get_text("E5"), *"#ERROR!");
+}
+
+#[test]
+fn fn_coupdays_actual_day_count_fix() {
+    // Verify COUPDAYS correctly distinguishes between fixed vs actual day count methods
+    // Bug: basis 2&3 were incorrectly using fixed calculations like basis 0&4
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2023,1,15)");
+    model._set("A2", "=DATE(2023,7,15)");
+
+    model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // 30/360: uses 360/freq
+    model._set("B2", "=COUPDAYS(A1,A2,2,2)"); // Actual/360: uses actual days
+    model._set("B3", "=COUPDAYS(A1,A2,2,3)"); // Actual/365: uses actual days
+    model._set("B4", "=COUPDAYS(A1,A2,2,4)"); // 30/360 European: uses 360/freq
+
+    model.evaluate();
+
+    // Basis 0&4: theoretical 360/2 = 180 days
+    assert_eq!(model._get_text("B1"), "180");
+    assert_eq!(model._get_text("B4"), "180");
+
+    // Basis 2&3: actual days between Jan 15 and Jul 15 = 181 days
+    assert_eq!(model._get_text("B2"), "181");
+    assert_eq!(model._get_text("B3"), "181");
+}
+
+// =============================================================================
+// FEBRUARY EDGE CASE TESTS - Day Count Convention Compliance
+// =============================================================================
+// These tests verify that financial functions correctly handle February dates
+// according to the official 30/360 day count convention specifications.
+
+#[test]
+fn test_coupon_functions_february_consistency() {
+    let mut model = new_empty_model();
+
+    // Test that coupon functions behave consistently between US and European methods
+    // when February dates are involved
+
+    // Settlement: Last day of February (non-leap year)
+    // Maturity: Some date in following year that creates a clear test case
+    model._set("A1", "=DATE(2023,2,28)"); // Last day of Feb, non-leap year
+    model._set("A2", "=DATE(2024,2,28)"); // Same day next year
+
+    // Test COUPDAYS with different basis values
+    model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // US 30/360 - should treat Feb 28 as day 30
+    model._set("B2", "=COUPDAYS(A1,A2,2,4)"); // European 30/360 - should treat Feb 28 as day 28
+    model._set("B3", "=COUPDAYS(A1,A2,2,1)"); // Actual/actual - should use real days
+
+    model.evaluate();
+
+    // All should return valid numbers (no errors)
+    assert_ne!(model._get_text("B1"), *"#NUM!");
+    assert_ne!(model._get_text("B2"), *"#NUM!");
+    assert_ne!(model._get_text("B3"), *"#NUM!");
+
+    // US and European 30/360 should potentially give different results for February dates
+    // (though the exact difference depends on the specific coupon calculation logic)
+    let us_result = model._get_text("B1");
+    let european_result = model._get_text("B2");
+    let actual_result = model._get_text("B3");
+
+    // Verify all are numeric
+    assert!(us_result.parse::<f64>().is_ok());
+    assert!(european_result.parse::<f64>().is_ok());
+    assert!(actual_result.parse::<f64>().is_ok());
+}
+
+#[test]
+fn test_february_edge_cases_leap_vs_nonleap() {
+    let mut model = new_empty_model();
+
+    // Test leap year vs non-leap year February handling
+
+    // Feb 28 in non-leap year (this IS the last day of February)
+    model._set("A1", "=DATE(2023,2,28)");
+    model._set("A2", "=DATE(2023,8,28)");
+
+    // Feb 28 in leap year (this is NOT the last day of February)
+    model._set("A3", "=DATE(2024,2,28)");
+    model._set("A4", "=DATE(2024,8,28)");
+
+    // Feb 29 in leap year (this IS the last day of February)
+    model._set("A5", "=DATE(2024,2,29)");
+    model._set("A6", "=DATE(2024,8,29)");
+
+    // Test with basis 0 (US 30/360) - should have special February handling
+    model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // Feb 28 non-leap (last day)
+    model._set("B2", "=COUPDAYS(A3,A4,2,0)"); // Feb 28 leap year (not last day)
+    model._set("B3", "=COUPDAYS(A5,A6,2,0)"); // Feb 29 leap year (last day)
+
+    model.evaluate();
+
+    // All should succeed
+    assert_ne!(model._get_text("B1"), *"#NUM!");
+    assert_ne!(model._get_text("B2"), *"#NUM!");
+    assert_ne!(model._get_text("B3"), *"#NUM!");
+
+    // Verify they're all numeric
+    assert!(model._get_text("B1").parse::<f64>().is_ok());
+    assert!(model._get_text("B2").parse::<f64>().is_ok());
+    assert!(model._get_text("B3").parse::<f64>().is_ok());
+}
+
+#[test]
+fn test_us_nasd_both_february_rule() {
+    let mut model = new_empty_model();
+
+    // Test the specific US/NASD rule: "If both date A and B fall on the last day of February,
+    // then date B will be changed to the 30th"
+
+    // Case 1: Both dates are Feb 28 in non-leap years (both are last day of February)
+    model._set("A1", "=DATE(2023,2,28)"); // Last day of Feb 2023
+    model._set("A2", "=DATE(2025,2,28)"); // Last day of Feb 2025
+
+    // Case 2: Both dates are Feb 29 in leap years (both are last day of February)
+    model._set("A3", "=DATE(2024,2,29)"); // Last day of Feb 2024
+    model._set("A4", "=DATE(2028,2,29)"); // Last day of Feb 2028
+
+    // Case 3: Mixed - Feb 28 non-leap to Feb 29 leap (both are last day of February)
+    model._set("A5", "=DATE(2023,2,28)"); // Last day of Feb 2023
+    model._set("A6", "=DATE(2024,2,29)"); // Last day of Feb 2024
+
+    // Case 4: Control - Feb 28 in leap year (NOT last day) to Feb 29 (IS last day)
+    model._set("A7", "=DATE(2024,2,28)"); // NOT last day of Feb 2024
+    model._set("A8", "=DATE(2024,2,29)"); // IS last day of Feb 2024
+
+    // Test using coupon functions that should apply US/NASD 30/360 (basis 0)
+    model._set("B1", "=COUPDAYS(A1,A2,1,0)"); // Both last day Feb - Rule 1 should apply
+    model._set("B2", "=COUPDAYS(A3,A4,1,0)"); // Both last day Feb - Rule 1 should apply
+    model._set("B3", "=COUPDAYS(A5,A6,1,0)"); // Both last day Feb - Rule 1 should apply
+    model._set("B4", "=COUPDAYS(A7,A8,1,0)"); // Only end is last day Feb - Rule 1 should NOT apply
+
+    // Compare with European method (basis 4) - should behave differently
+    model._set("C1", "=COUPDAYS(A1,A2,1,4)"); // European - no special Feb handling
+    model._set("C2", "=COUPDAYS(A3,A4,1,4)"); // European - no special Feb handling
+    model._set("C3", "=COUPDAYS(A5,A6,1,4)"); // European - no special Feb handling
+    model._set("C4", "=COUPDAYS(A7,A8,1,4)"); // European - no special Feb handling
+
+    model.evaluate();
+
+    // All should succeed without errors
+    for row in ["B1", "B2", "B3", "B4", "C1", "C2", "C3", "C4"] {
+        assert_ne!(model._get_text(row), *"#NUM!", "Failed for {row}");
+        assert!(
+            model._get_text(row).parse::<f64>().is_ok(),
+            "Non-numeric result for {row}"
+        );
+    }
+}
+
+#[test]
+fn test_coupon_functions_february_edge_cases() {
+    let mut model = new_empty_model();
+
+    // Test that coupon functions handle February dates correctly without errors
+
+    // Settlement: February 28, 2023 (non-leap), Maturity: February 28, 2024 (leap)
+    model._set("A1", "=DATE(2023,2,28)");
+    model._set("A2", "=DATE(2024,2,28)");
+
+    // Test with basis 0 (US 30/360 - should use special February handling)
+    model._set("B1", "=COUPDAYBS(A1,A2,2,0)");
+    model._set("B2", "=COUPDAYS(A1,A2,2,0)");
+    model._set("B3", "=COUPDAYSNC(A1,A2,2,0)");
+
+    // Test with basis 4 (European 30/360 - should NOT use special February handling)
+    model._set("C1", "=COUPDAYBS(A1,A2,2,4)");
+    model._set("C2", "=COUPDAYS(A1,A2,2,4)");
+    model._set("C3", "=COUPDAYSNC(A1,A2,2,4)");
+
+    model.evaluate();
+
+    // With US method (basis 0), February dates should be handled specially
+    // With European method (basis 4), February dates should use actual dates
+    // Key point: both should work without errors
+
+    // We're ensuring functions complete successfully with February dates
+    assert_ne!(model._get_text("B1"), *"#NUM!");
+    assert_ne!(model._get_text("B2"), *"#NUM!");
+    assert_ne!(model._get_text("B3"), *"#NUM!");
+    assert_ne!(model._get_text("C1"), *"#NUM!");
+    assert_ne!(model._get_text("C2"), *"#NUM!");
+    assert_ne!(model._get_text("C3"), *"#NUM!");
+}

base/src/test/test_fn_duration.rs

@@ -0,0 +1,350 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::panic)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+// Test constants for realistic bond scenarios
+const BOND_SETTLEMENT: &str = "=DATE(2020,1,1)";
+const BOND_MATURITY_4Y: &str = "=DATE(2024,1,1)";
+const BOND_MATURITY_INVALID: &str = "=DATE(2016,1,1)"; // Before settlement
+const BOND_MATURITY_SAME: &str = "=DATE(2020,1,1)"; // Same as settlement
+const BOND_MATURITY_1DAY: &str = "=DATE(2020,1,2)"; // Very short term
+
+// Standard investment-grade corporate bond parameters
+const STD_COUPON: f64 = 0.08; // 8% annual coupon rate
+const STD_YIELD: f64 = 0.09; // 9% yield (discount bond scenario)
+const STD_FREQUENCY: i32 = 2; // Semi-annual payments (most common)
+
+// Helper function to reduce test repetition
+fn assert_numerical_result(model: &crate::Model, cell_ref: &str, should_be_positive: bool) {
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref(cell_ref) {
+        if should_be_positive {
+            assert!(v > 0.0, "Expected positive value at {cell_ref}, got {v}");
+        }
+        // Value is valid - test passes
+    } else {
+        panic!("Expected numerical result at {cell_ref}");
+    }
+}
+
+#[test]
+fn fn_duration_mduration_arguments() {
+    let mut model = new_empty_model();
+
+    // Test argument count validation
+    model._set("A1", "=DURATION()");
+    model._set("A2", "=DURATION(1,2,3,4)");
+    model._set("A3", "=DURATION(1,2,3,4,5,6,7)");
+
+    model._set("B1", "=MDURATION()");
+    model._set("B2", "=MDURATION(1,2,3,4)");
+    model._set("B3", "=MDURATION(1,2,3,4,5,6,7)");
+
+    model.evaluate();
+
+    // Too few or too many arguments should result in errors
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+}
+
+#[test]
+fn fn_duration_mduration_settlement_maturity_errors() {
+    let mut model = new_empty_model();
+
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_INVALID); // Before settlement
+    model._set("A3", BOND_MATURITY_SAME); // Same as settlement
+
+    // Both settlement > maturity and settlement = maturity should error
+    model._set(
+        "B1",
+        &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B2",
+        &format!("=DURATION(A1,A3,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B3",
+        &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B4",
+        &format!("=MDURATION(A1,A3,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+    assert_eq!(model._get_text("B4"), *"#NUM!");
+}
+
+#[test]
+fn fn_duration_mduration_negative_values_errors() {
+    let mut model = new_empty_model();
+
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_4Y);
+
+    // Test negative coupon (coupons must be >= 0)
+    model._set(
+        "B1",
+        &format!("=DURATION(A1,A2,-0.01,{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B2",
+        &format!("=MDURATION(A1,A2,-0.01,{STD_YIELD},{STD_FREQUENCY})"),
+    );
+
+    // Test negative yield (yields must be >= 0)
+    model._set(
+        "C1",
+        &format!("=DURATION(A1,A2,{STD_COUPON},-0.01,{STD_FREQUENCY})"),
+    );
+    model._set(
+        "C2",
+        &format!("=MDURATION(A1,A2,{STD_COUPON},-0.01,{STD_FREQUENCY})"),
+    );
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("C1"), *"#NUM!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
+}
+
+#[test]
+fn fn_duration_mduration_invalid_frequency_errors() {
+    let mut model = new_empty_model();
+
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_4Y);
+
+    // Only 1, 2, and 4 are valid frequencies (annual, semi-annual, quarterly)
+    let invalid_frequencies = [0, 3, 5, 12]; // Common invalid values
+
+    for (i, &freq) in invalid_frequencies.iter().enumerate() {
+        let row = i + 1;
+        model._set(
+            &format!("B{row}"),
+            &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
+        );
+        model._set(
+            &format!("C{row}"),
+            &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
+        );
+    }
+
+    model.evaluate();
+
+    for i in 1..=invalid_frequencies.len() {
+        assert_eq!(model._get_text(&format!("B{i}")), *"#NUM!");
+        assert_eq!(model._get_text(&format!("C{i}")), *"#NUM!");
+    }
+}
+
+#[test]
+fn fn_duration_mduration_frequency_variations() {
+    let mut model = new_empty_model();
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_4Y);
+
+    // Test all valid frequencies: 1=annual, 2=semi-annual, 4=quarterly
+    let valid_frequencies = [1, 2, 4];
+
+    for (i, &freq) in valid_frequencies.iter().enumerate() {
+        let row = i + 1;
+        model._set(
+            &format!("B{row}"),
+            &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
+        );
+        model._set(
+            &format!("C{row}"),
+            &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
+        );
+    }
+
+    model.evaluate();
+
+    // All should return positive numerical values
+    for i in 1..=valid_frequencies.len() {
+        assert_numerical_result(&model, &format!("Sheet1!B{i}"), true);
+        assert_numerical_result(&model, &format!("Sheet1!C{i}"), true);
+    }
+}
+
+#[test]
+fn fn_duration_mduration_basis_variations() {
+    let mut model = new_empty_model();
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_4Y);
+
+    // Test all valid basis values (day count conventions)
+    // 0=30/360 US, 1=Actual/actual, 2=Actual/360, 3=Actual/365, 4=30/360 European
+    for basis in 0..=4 {
+        let row = basis + 1;
+        model._set(
+            &format!("B{row}"),
+            &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY},{basis})"),
+        );
+        model._set(
+            &format!("C{row}"),
+            &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY},{basis})"),
+        );
+    }
+
+    // Test default basis (should be 0)
+    model._set(
+        "D1",
+        &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "D2",
+        &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+
+    model.evaluate();
+
+    // All basis values should work
+    for row in 1..=5 {
+        assert_numerical_result(&model, &format!("Sheet1!B{row}"), true);
+        assert_numerical_result(&model, &format!("Sheet1!C{row}"), true);
+    }
+
+    // Default basis should match basis 0
+    if let (Ok(CellValue::Number(d1)), Ok(CellValue::Number(b1))) = (
+        model.get_cell_value_by_ref("Sheet1!D1"),
+        model.get_cell_value_by_ref("Sheet1!B1"),
+    ) {
+        assert!(
+            (d1 - b1).abs() < 1e-10,
+            "Default basis should match basis 0"
+        );
+    }
+}
+
+#[test]
+fn fn_duration_mduration_edge_cases() {
+    let mut model = new_empty_model();
+
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_1DAY); // Very short term (1 day)
+    model._set("A3", BOND_MATURITY_4Y); // Standard term
+
+    // Edge case scenarios with explanations
+    let test_cases = [
+        ("B", "A1", "A2", STD_COUPON, STD_YIELD, "short_term"), // 1-day bond
+        ("C", "A1", "A3", 0.0, STD_YIELD, "zero_coupon"),       // Zero coupon bond
+        ("D", "A1", "A3", STD_COUPON, 0.0, "zero_yield"),       // Zero yield
+        ("E", "A1", "A3", 1.0, 0.5, "high_rates"),              // High coupon/yield (100%/50%)
+    ];
+
+    for (col, settlement, maturity, coupon, yield_rate, _scenario) in test_cases {
+        model._set(
+            &format!("{col}1"),
+            &format!("=DURATION({settlement},{maturity},{coupon},{yield_rate},{STD_FREQUENCY})"),
+        );
+        model._set(
+            &format!("{col}2"),
+            &format!("=MDURATION({settlement},{maturity},{coupon},{yield_rate},{STD_FREQUENCY})"),
+        );
+    }
+
+    model.evaluate();
+
+    // All edge cases should return positive values
+    for col in ["B", "C", "D", "E"] {
+        assert_numerical_result(&model, &format!("Sheet1!{col}1"), true);
+        assert_numerical_result(&model, &format!("Sheet1!{col}2"), true);
+    }
+}
+
+#[test]
+fn fn_duration_mduration_relationship() {
+    let mut model = new_empty_model();
+    model._set("A1", BOND_SETTLEMENT);
+    model._set("A2", BOND_MATURITY_4Y);
+
+    // Test mathematical relationship: MDURATION = DURATION / (1 + yield/frequency)
+    model._set(
+        "B1",
+        &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B2",
+        &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set("B3", &format!("=B1/(1+{STD_YIELD}/{STD_FREQUENCY})")); // Manual calculation
+
+    // Test with quarterly frequency and different yield
+    model._set("C1", &format!("=DURATION(A1,A2,{STD_COUPON},0.12,4)"));
+    model._set("C2", &format!("=MDURATION(A1,A2,{STD_COUPON},0.12,4)"));
+    model._set("C3", "=C1/(1+0.12/4)"); // Manual calculation for quarterly
+
+    model.evaluate();
+
+    // MDURATION should equal DURATION / (1 + yield/frequency) for both scenarios
+    if let (Ok(CellValue::Number(md)), Ok(CellValue::Number(manual))) = (
+        model.get_cell_value_by_ref("Sheet1!B2"),
+        model.get_cell_value_by_ref("Sheet1!B3"),
+    ) {
+        assert!(
+            (md - manual).abs() < 1e-10,
+            "MDURATION should equal DURATION/(1+yield/freq)"
+        );
+    }
+
+    if let (Ok(CellValue::Number(md)), Ok(CellValue::Number(manual))) = (
+        model.get_cell_value_by_ref("Sheet1!C2"),
+        model.get_cell_value_by_ref("Sheet1!C3"),
+    ) {
+        assert!(
+            (md - manual).abs() < 1e-10,
+            "MDURATION should equal DURATION/(1+yield/freq) for quarterly"
+        );
+    }
+}
+
+#[test]
+fn fn_duration_mduration_regression() {
+    // Original regression test with known expected values
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2016,1,1)");
+    model._set("A2", "=DATE(2020,1,1)");
+    model._set(
+        "B1",
+        &format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+    model._set(
+        "B2",
+        &format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
+    );
+
+    model.evaluate();
+
+    // Verify exact values for regression testing
+    if let Ok(CellValue::Number(v1)) = model.get_cell_value_by_ref("Sheet1!B1") {
+        assert!(
+            (v1 - 3.410746844012284).abs() < 1e-9,
+            "DURATION regression test failed"
+        );
+    } else {
+        panic!("Unexpected value for DURATION");
+    }
+    if let Ok(CellValue::Number(v2)) = model.get_cell_value_by_ref("Sheet1!B2") {
+        assert!(
+            (v2 - 3.263872578002186).abs() < 1e-9,
+            "MDURATION regression test failed"
+        );
+    } else {
+        panic!("Unexpected value for MDURATION");
+    }
+}

base/src/test/test_fn_financial.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::panic)]
 
 use crate::{cell::CellValue, test::util::new_empty_model};
 
@@ -25,6 +26,10 @@ fn fn_arguments() {
     model._set("E2", "=RATE(1,1)");
     model._set("E3", "=RATE(1,1,1,1,1,1)");
 
+    model._set("F1", "=FVSCHEDULE()");
+    model._set("F2", "=FVSCHEDULE(1)");
+    model._set("F3", "=FVSCHEDULE(1,1,1)");
+
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#ERROR!");
@@ -46,6 +51,10 @@ fn fn_arguments() {
     assert_eq!(model._get_text("E1"), *"#ERROR!");
     assert_eq!(model._get_text("E2"), *"#ERROR!");
     assert_eq!(model._get_text("E3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("F1"), *"#ERROR!");
+    assert_eq!(model._get_text("F2"), *"#ERROR!");
+    assert_eq!(model._get_text("F3"), *"#ERROR!");
 }
 
 #[test]
@@ -468,3 +477,18 @@ fn fn_db_misc() {
 
     assert_eq!(model._get_text("B1"), "$0.00");
 }
+
+#[test]
+fn fn_fvschedule() {
+    let mut model = new_empty_model();
+    model._set("A1", "1000");
+    model._set("A2", "0.08");
+    model._set("A3", "0.09");
+    model._set("A4", "0.1");
+
+    model._set("B1", "=FVSCHEDULE(A1, A2:A4)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "1294.92");
+}

base/src/test/test_fn_financial_bonds.rs

@@ -0,0 +1,615 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn fn_price_yield() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+    model._set("A3", "5%");
+
+    model._set("B1", "=PRICE(A1,A2,A3,6%,100,1)");
+    model._set("B2", "=YIELD(A1,A2,A3,B1,100,1)");
+
+    model.evaluate();
+    assert_eq!(model._get_text("B1"), "99.056603774");
+    assert_eq!(model._get_text("B2"), "0.06");
+}
+
+#[test]
+fn fn_price_frequencies() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=PRICE(A1,A2,5%,6%,100,1)");
+    model._set("B2", "=PRICE(A1,A2,5%,6%,100,2)");
+    model._set("B3", "=PRICE(A1,A2,5%,6%,100,4)");
+
+    model.evaluate();
+
+    let annual: f64 = model._get_text("B1").parse().unwrap();
+    let semi: f64 = model._get_text("B2").parse().unwrap();
+    let quarterly: f64 = model._get_text("B3").parse().unwrap();
+
+    assert_ne!(annual, semi);
+    assert_ne!(semi, quarterly);
+}
+
+#[test]
+fn fn_yield_frequencies() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=YIELD(A1,A2,5%,99,100,1)");
+    model._set("B2", "=YIELD(A1,A2,5%,99,100,2)");
+    model._set("B3", "=YIELD(A1,A2,5%,99,100,4)");
+
+    model.evaluate();
+
+    let annual: f64 = model._get_text("B1").parse().unwrap();
+    let semi: f64 = model._get_text("B2").parse().unwrap();
+    let quarterly: f64 = model._get_text("B3").parse().unwrap();
+
+    assert_ne!(annual, semi);
+    assert_ne!(semi, quarterly);
+}
+
+#[test]
+fn fn_price_argument_errors() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=PRICE()");
+    model._set("B2", "=PRICE(A1,A2,5%,6%,100)");
+    model._set("B3", "=PRICE(A1,A2,5%,6%,100,2,0,99)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+}
+
+#[test]
+fn fn_yield_argument_errors() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=YIELD()");
+    model._set("B2", "=YIELD(A1,A2,5%,99,100)");
+    model._set("B3", "=YIELD(A1,A2,5%,99,100,2,0,99)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+}
+
+#[test]
+fn fn_price_invalid_frequency() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=PRICE(A1,A2,5%,6%,100,0)");
+    model._set("B2", "=PRICE(A1,A2,5%,6%,100,3)");
+    model._set("B3", "=PRICE(A1,A2,5%,6%,100,5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+}
+
+#[test]
+fn fn_pricedisc() {
+    let mut model = new_empty_model();
+    model._set("A2", "=DATE(2022,1,25)");
+    model._set("A3", "=DATE(2022,11,15)");
+    model._set("A4", "3.75%");
+    model._set("A5", "100");
+
+    model._set("B1", "=PRICEDISC(A2,A3,A4,A5)");
+    model._set("C1", "=PRICEDISC(A2,A3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "96.979166667");
+    assert_eq!(model._get_text("C1"), *"#ERROR!");
+}
+
+#[test]
+fn fn_pricemat() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2019,2,15)");
+    model._set("A2", "=DATE(2025,4,13)");
+    model._set("A3", "=DATE(2018,11,11)");
+    model._set("A4", "5.75%");
+    model._set("A5", "6.5%");
+
+    model._set("B1", "=PRICEMAT(A1,A2,A3,A4,A5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "96.271187821");
+}
+
+#[test]
+fn fn_yielddisc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2022,1,25)");
+    model._set("A2", "=DATE(2022,11,15)");
+    model._set("A3", "97");
+    model._set("A4", "100");
+
+    model._set("B1", "=YIELDDISC(A1,A2,A3,A4)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "0.038393175");
+}
+
+#[test]
+fn fn_yieldmat() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2019,2,15)");
+    model._set("A2", "=DATE(2025,4,13)");
+    model._set("A3", "=DATE(2018,11,11)");
+    model._set("A4", "5.75%");
+    model._set("A5", "96.27");
+
+    model._set("B1", "=YIELDMAT(A1,A2,A3,A4,A5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "0.065002762");
+}
+
+#[test]
+fn fn_disc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2022,1,25)");
+    model._set("A2", "=DATE(2022,11,15)");
+    model._set("A3", "97");
+    model._set("A4", "100");
+
+    model._set("B1", "=DISC(A1,A2,A3,A4)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "0.037241379");
+}
+
+#[test]
+fn fn_received() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2023,6,30)");
+    model._set("A3", "20000");
+    model._set("A4", "5%");
+    model._set("A5", "3");
+
+    model._set("B1", "=RECEIVED(A1,A2,A3,A4,A5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "24236.387782205");
+}
+
+#[test]
+fn fn_intrate() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2020,1,1)");
+    model._set("A2", "=DATE(2023,6,30)");
+    model._set("A3", "10000");
+    model._set("A4", "12000");
+    model._set("A5", "3");
+
+    model._set("B1", "=INTRATE(A1,A2,A3,A4,A5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "0.057210031");
+}
+
+#[test]
+fn fn_bond_functions_arguments() {
+    let mut model = new_empty_model();
+
+    // PRICEDISC: 4-5 args
+    model._set("A1", "=PRICEDISC()");
+    model._set("A2", "=PRICEDISC(1,2,3)");
+    model._set("A3", "=PRICEDISC(1,2,3,4,5,6)");
+
+    // PRICEMAT: 5-6 args
+    model._set("B1", "=PRICEMAT()");
+    model._set("B2", "=PRICEMAT(1,2,3,4)");
+    model._set("B3", "=PRICEMAT(1,2,3,4,5,6,7)");
+
+    // YIELDDISC: 4-5 args
+    model._set("C1", "=YIELDDISC()");
+    model._set("C2", "=YIELDDISC(1,2,3)");
+    model._set("C3", "=YIELDDISC(1,2,3,4,5,6)");
+
+    // YIELDMAT: 5-6 args
+    model._set("D1", "=YIELDMAT()");
+    model._set("D2", "=YIELDMAT(1,2,3,4)");
+    model._set("D3", "=YIELDMAT(1,2,3,4,5,6,7)");
+
+    // DISC: 4-5 args
+    model._set("E1", "=DISC()");
+    model._set("E2", "=DISC(1,2,3)");
+    model._set("E3", "=DISC(1,2,3,4,5,6)");
+
+    // RECEIVED: 4-5 args
+    model._set("F1", "=RECEIVED()");
+    model._set("F2", "=RECEIVED(1,2,3)");
+    model._set("F3", "=RECEIVED(1,2,3,4,5,6)");
+
+    // INTRATE: 4-5 args
+    model._set("G1", "=INTRATE()");
+    model._set("G2", "=INTRATE(1,2,3)");
+    model._set("G3", "=INTRATE(1,2,3,4,5,6)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+    assert_eq!(model._get_text("B3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("C1"), *"#ERROR!");
+    assert_eq!(model._get_text("C2"), *"#ERROR!");
+    assert_eq!(model._get_text("C3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("D1"), *"#ERROR!");
+    assert_eq!(model._get_text("D2"), *"#ERROR!");
+    assert_eq!(model._get_text("D3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("E1"), *"#ERROR!");
+    assert_eq!(model._get_text("E2"), *"#ERROR!");
+    assert_eq!(model._get_text("E3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("F1"), *"#ERROR!");
+    assert_eq!(model._get_text("F2"), *"#ERROR!");
+    assert_eq!(model._get_text("F3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("G1"), *"#ERROR!");
+    assert_eq!(model._get_text("G2"), *"#ERROR!");
+    assert_eq!(model._get_text("G3"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bond_functions_date_boundaries() {
+    let mut model = new_empty_model();
+
+    // Date boundary values
+    model._set("A1", "0"); // Below MINIMUM_DATE_SERIAL_NUMBER
+    model._set("A2", "1"); // MINIMUM_DATE_SERIAL_NUMBER
+    model._set("A3", "2958465"); // MAXIMUM_DATE_SERIAL_NUMBER
+    model._set("A4", "2958466"); // Above MAXIMUM_DATE_SERIAL_NUMBER
+
+    // Test settlement < minimum
+    model._set("B1", "=PRICEDISC(A1,A2,0.05,100)");
+    model._set("B2", "=YIELDDISC(A1,A2,95,100)");
+    model._set("B3", "=DISC(A1,A2,95,100)");
+    model._set("B4", "=RECEIVED(A1,A2,1000,0.05)");
+    model._set("B5", "=INTRATE(A1,A2,1000,1050)");
+
+    // Test maturity > maximum
+    model._set("C1", "=PRICEDISC(A2,A4,0.05,100)");
+    model._set("C2", "=YIELDDISC(A2,A4,95,100)");
+    model._set("C3", "=DISC(A2,A4,95,100)");
+    model._set("C4", "=RECEIVED(A2,A4,1000,0.05)");
+    model._set("C5", "=INTRATE(A2,A4,1000,1050)");
+
+    // Test PRICEMAT/YIELDMAT with issue < minimum
+    model._set("D1", "=PRICEMAT(A2,A3,A1,0.06,0.05)");
+    model._set("D2", "=YIELDMAT(A2,A3,A1,0.06,99)");
+
+    // Test PRICEMAT/YIELDMAT with issue > maximum
+    model._set("E1", "=PRICEMAT(A2,A3,A4,0.06,0.05)");
+    model._set("E2", "=YIELDMAT(A2,A3,A4,0.06,99)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+}
+
+#[test]
+fn fn_yield_invalid_frequency() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=YIELD(A1,A2,5%,99,100,0)");
+    model._set("B2", "=YIELD(A1,A2,5%,99,100,3)");
+    model._set("B3", "=YIELD(A1,A2,5%,99,100,5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+}
+
+#[test]
+fn fn_bond_functions_date_ordering() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2022,1,1)"); // settlement
+    model._set("A2", "=DATE(2021,12,31)"); // maturity (before settlement)
+    model._set("A3", "=DATE(2020,1,1)"); // issue
+
+    // Test settlement >= maturity
+    model._set("B1", "=PRICEDISC(A1,A2,0.05,100)");
+    model._set("B2", "=YIELDDISC(A1,A2,95,100)");
+    model._set("B3", "=DISC(A1,A2,95,100)");
+    model._set("B4", "=RECEIVED(A1,A2,1000,0.05)");
+    model._set("B5", "=INTRATE(A1,A2,1000,1050)");
+    model._set("B6", "=PRICEMAT(A1,A2,A3,0.06,0.05)");
+    model._set("B7", "=YIELDMAT(A1,A2,A3,0.06,99)");
+
+    // Test settlement < issue for YIELDMAT/PRICEMAT
+    model._set("A4", "=DATE(2023,1,1)"); // later issue date
+    model._set("C1", "=PRICEMAT(A1,A2,A4,0.06,0.05)"); // settlement < issue
+    model._set("C2", "=YIELDMAT(A1,A2,A4,0.06,99)"); // settlement < issue
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+}
+
+#[test]
+fn fn_price_invalid_dates() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=PRICE(A2,A1,5%,6%,100,2)");
+    model._set("B2", "=PRICE(A1,A1,5%,6%,100,2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+}
+
+#[test]
+fn fn_bond_functions_parameter_validation() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2022,1,1)");
+    model._set("A2", "=DATE(2022,12,31)");
+    model._set("A3", "=DATE(2021,1,1)");
+
+    // Test negative/zero prices and redemptions
+    model._set("B1", "=PRICEDISC(A1,A2,0.05,0)"); // zero redemption
+    model._set("B2", "=PRICEDISC(A1,A2,0,100)"); // zero discount
+    model._set("B3", "=PRICEDISC(A1,A2,-0.05,100)"); // negative discount
+
+    model._set("C1", "=YIELDDISC(A1,A2,0,100)"); // zero price
+    model._set("C2", "=YIELDDISC(A1,A2,95,0)"); // zero redemption
+    model._set("C3", "=YIELDDISC(A1,A2,-95,100)"); // negative price
+
+    model._set("D1", "=DISC(A1,A2,0,100)"); // zero price
+    model._set("D2", "=DISC(A1,A2,95,0)"); // zero redemption
+    model._set("D3", "=DISC(A1,A2,-95,100)"); // negative price
+
+    model._set("E1", "=RECEIVED(A1,A2,0,0.05)"); // zero investment
+    model._set("E2", "=RECEIVED(A1,A2,1000,0)"); // zero discount
+    model._set("E3", "=RECEIVED(A1,A2,-1000,0.05)"); // negative investment
+
+    model._set("F1", "=INTRATE(A1,A2,0,1050)"); // zero investment
+    model._set("F2", "=INTRATE(A1,A2,1000,0)"); // zero redemption
+    model._set("F3", "=INTRATE(A1,A2,-1000,1050)"); // negative investment
+
+    model._set("G1", "=PRICEMAT(A1,A2,A3,-0.06,0.05)"); // negative rate
+    model._set("G2", "=PRICEMAT(A1,A2,A3,0.06,-0.05)"); // negative yield
+
+    model._set("H1", "=YIELDMAT(A1,A2,A3,0.06,0)"); // zero price
+    model._set("H2", "=YIELDMAT(A1,A2,A3,-0.06,99)"); // negative rate
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+}
+
+#[test]
+fn fn_yield_invalid_dates() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=YIELD(A2,A1,5%,99,100,2)");
+    model._set("B2", "=YIELD(A1,A1,5%,99,100,2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+}
+
+#[test]
+fn fn_price_with_basis() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=PRICE(A1,A2,5%,6%,100,2,0)");
+    model._set("B2", "=PRICE(A1,A2,5%,6%,100,2,1)");
+
+    model.evaluate();
+
+    assert!(model._get_text("B1").parse::<f64>().is_ok());
+    assert!(model._get_text("B2").parse::<f64>().is_ok());
+}
+
+#[test]
+fn fn_yield_with_basis() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2023,1,1)");
+    model._set("A2", "=DATE(2024,1,1)");
+
+    model._set("B1", "=YIELD(A1,A2,5%,99,100,2,0)");
+    model._set("B2", "=YIELD(A1,A2,5%,99,100,2,1)");
+
+    model.evaluate();
+
+    assert!(model._get_text("B1").parse::<f64>().is_ok());
+    assert!(model._get_text("B2").parse::<f64>().is_ok());
+}
+
+#[test]
+fn fn_price_yield_inverse_functions() {
+    // Verifies PRICE and YIELD are mathematical inverses
+    // Regression test for periods calculation type mismatch
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2023,1,15)");
+    model._set("A2", "=DATE(2024,7,15)"); // ~1.5 years, fractional periods
+    model._set("A3", "4.75%"); // coupon
+    model._set("A4", "5.125%"); // yield
+
+    model._set("B1", "=PRICE(A1,A2,A3,A4,100,2)");
+    model._set("B2", "=YIELD(A1,A2,A3,B1,100,2)");
+
+    model.evaluate();
+
+    let calculated_yield: f64 = model._get_text("B2").parse().unwrap();
+    let expected_yield = 0.05125;
+
+    assert!(
+        (calculated_yield - expected_yield).abs() < 1e-12,
+        "YIELD should recover original yield: expected {expected_yield}, got {calculated_yield}"
+    );
+}
+
+#[test]
+fn fn_price_yield_round_trip_stability() {
+    // Tests numerical stability through multiple PRICE->YIELD->PRICE cycles
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2023,3,10)");
+    model._set("A2", "=DATE(2024,11,22)"); // Irregular period length
+    model._set("A3", "3.25%"); // coupon rate
+    model._set("A4", "4.875%"); // initial yield
+
+    // First round-trip
+    model._set("B1", "=PRICE(A1,A2,A3,A4,100,4)");
+    model._set("B2", "=YIELD(A1,A2,A3,B1,100,4)");
+
+    // Second round-trip
+    model._set("B3", "=PRICE(A1,A2,A3,B2,100,4)");
+
+    model.evaluate();
+
+    let price1: f64 = model._get_text("B1").parse().unwrap();
+    let price2: f64 = model._get_text("B3").parse().unwrap();
+
+    assert!(
+        (price1 - price2).abs() < 1e-10,
+        "Round-trip should be stable: {price1} vs {price2}"
+    );
+}
+
+#[test]
+fn fn_bond_functions_basis_validation() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DATE(2022,1,1)");
+    model._set("A2", "=DATE(2022,12,31)");
+    model._set("A3", "=DATE(2021,1,1)");
+
+    // Test valid basis values (0-4)
+    model._set("B1", "=PRICEDISC(A1,A2,0.05,100,0)");
+    model._set("B2", "=PRICEDISC(A1,A2,0.05,100,1)");
+    model._set("B3", "=PRICEDISC(A1,A2,0.05,100,2)");
+    model._set("B4", "=PRICEDISC(A1,A2,0.05,100,3)");
+    model._set("B5", "=PRICEDISC(A1,A2,0.05,100,4)");
+
+    // Test invalid basis values
+    model._set("C1", "=PRICEDISC(A1,A2,0.05,100,-1)");
+    model._set("C2", "=PRICEDISC(A1,A2,0.05,100,5)");
+    model._set("C3", "=YIELDDISC(A1,A2,95,100,10)");
+    model._set("C4", "=DISC(A1,A2,95,100,-5)");
+    model._set("C5", "=RECEIVED(A1,A2,1000,0.05,99)");
+    model._set("C6", "=INTRATE(A1,A2,1000,1050,-2)");
+    model._set("C7", "=PRICEMAT(A1,A2,A3,0.06,0.05,7)");
+    model._set("C8", "=YIELDMAT(A1,A2,A3,0.06,99,-3)");
+
+    model.evaluate();
+
+    // Valid basis should work
+    assert_ne!(model._get_text("B1"), *"#ERROR!");
+    assert_ne!(model._get_text("B2"), *"#ERROR!");
+    assert_ne!(model._get_text("B3"), *"#ERROR!");
+    assert_ne!(model._get_text("B4"), *"#ERROR!");
+    assert_ne!(model._get_text("B5"), *"#ERROR!");
+
+    // Invalid basis should error
+    assert_eq!(model._get_text("C1"), *"#NUM!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
+    assert_eq!(model._get_text("C3"), *"#NUM!");
+    assert_eq!(model._get_text("C4"), *"#NUM!");
+    assert_eq!(model._get_text("C5"), *"#NUM!");
+    assert_eq!(model._get_text("C6"), *"#NUM!");
+    assert_eq!(model._get_text("C7"), *"#NUM!");
+    assert_eq!(model._get_text("C8"), *"#NUM!");
+}
+
+#[test]
+fn fn_bond_functions_relationships() {
+    // Test mathematical relationships between functions
+    let mut model = new_empty_model();
+    model._set("A1", "=DATE(2021,1,1)");
+    model._set("A2", "=DATE(2021,7,1)");
+
+    model._set("B1", "=PRICEDISC(A1,A2,5%,100)");
+    model._set("B2", "=YIELDDISC(A1,A2,B1,100)");
+    model._set("B3", "=DISC(A1,A2,B1,100)");
+    model._set("B4", "=RECEIVED(A1,A2,1000,5%)");
+    model._set("B5", "=INTRATE(A1,A2,1000,1050)");
+    model._set("B6", "=PRICEMAT(A1,A2,DATE(2020,7,1),6%,5%)");
+    model._set("B7", "=YIELDMAT(A1,A2,DATE(2020,7,1),6%,99)");
+
+    model.evaluate();
+
+    assert_eq!(
+        model.get_cell_value_by_ref("Sheet1!B1"),
+        Ok(CellValue::Number(97.5))
+    );
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B2") {
+        assert!((v - 0.051282051).abs() < 1e-6);
+    }
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B3") {
+        assert!((v - 0.05).abs() < 1e-6);
+    }
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B4") {
+        assert!((v - 1025.641025).abs() < 1e-6);
+    }
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B5") {
+        assert!((v - 0.10).abs() < 1e-6);
+    }
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B6") {
+        assert!((v - 100.414634).abs() < 1e-6);
+    }
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B7") {
+        assert!((v - 0.078431372).abs() < 1e-6);
+    }
+}

base/src/test/test_fn_fvschedule.rs

@@ -0,0 +1,127 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn computation() {
+    let mut model = new_empty_model();
+    model._set("B1", "0.1");
+    model._set("B2", "0.2");
+    model._set("A1", "=FVSCHEDULE(100,B1:B2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "132");
+}
+
+#[test]
+fn fvschedule_basic_with_precise_assertion() {
+    let mut model = new_empty_model();
+    model._set("A1", "1000");
+    model._set("B1", "0.09");
+    model._set("B2", "0.11");
+    model._set("B3", "0.1");
+
+    model._set("C1", "=FVSCHEDULE(A1,B1:B3)");
+    model.evaluate();
+
+    assert_eq!(
+        model.get_cell_value_by_ref("Sheet1!C1"),
+        Ok(CellValue::Number(1330.89))
+    );
+}
+
+#[test]
+fn fvschedule_compound_rates() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "0.1");
+    model._set("A3", "0.2");
+    model._set("A4", "0.3");
+
+    model._set("B1", "=FVSCHEDULE(A1, A2:A4)");
+
+    model.evaluate();
+
+    // 1 * (1+0.1) * (1+0.2) * (1+0.3) = 1 * 1.1 * 1.2 * 1.3 = 1.716
+    assert_eq!(model._get_text("B1"), "1.716");
+}
+
+#[test]
+fn fvschedule_ignore_non_numbers() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "0.1");
+    model._set("A3", "foo"); // non-numeric value should be ignored
+    model._set("A4", "0.2");
+
+    model._set("B1", "=FVSCHEDULE(A1, A2:A4)");
+
+    model.evaluate();
+
+    // 1 * (1+0.1) * (1+0.2) = 1 * 1.1 * 1.2 = 1.32
+    assert_eq!(model._get_text("B1"), "1.32");
+}
+
+#[test]
+fn fvschedule_argument_count() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FVSCHEDULE()");
+    model._set("A2", "=FVSCHEDULE(1)");
+    model._set("A3", "=FVSCHEDULE(1,1,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+}
+
+#[test]
+fn fvschedule_edge_cases() {
+    let mut model = new_empty_model();
+
+    // Test with zero principal
+    model._set("A1", "0");
+    model._set("A2", "0.1");
+    model._set("A3", "0.2");
+    model._set("B1", "=FVSCHEDULE(A1, A2:A3)");
+
+    // Test with negative principal
+    model._set("C1", "-100");
+    model._set("D1", "=FVSCHEDULE(C1, A2:A3)");
+
+    // Test with zero rates
+    model._set("E1", "100");
+    model._set("E2", "0");
+    model._set("E3", "0");
+    model._set("F1", "=FVSCHEDULE(E1, E2:E3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "0"); // 0 * anything = 0
+    assert_eq!(model._get_text("D1"), "-132"); // -100 * 1.1 * 1.2 = -132
+    assert_eq!(model._get_text("F1"), "100"); // 100 * 1 * 1 = 100
+}
+
+#[test]
+fn fvschedule_rate_validation() {
+    let mut model = new_empty_model();
+
+    // Test with rate exactly -1 (should cause error due to validation in patch 1)
+    model._set("A1", "100");
+    model._set("A2", "-1");
+    model._set("A3", "0.1");
+    model._set("B1", "=FVSCHEDULE(A1, A2:A3)");
+
+    // Test with rate less than -1 (should cause error)
+    model._set("C1", "100");
+    model._set("C2", "-1.5");
+    model._set("C3", "0.1");
+    model._set("D1", "=FVSCHEDULE(C1, C2:C3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), "#NUM!");
+    assert_eq!(model._get_text("D1"), "#NUM!");
+}

docs/src/functions/financial.md

@@ -11,32 +11,32 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 
 | Function   | Status                                         | Documentation      |
 | ---------- | ---------------------------------------------- | ------------------ |
-| ACCRINT    | <Badge type="info" text="Not implemented yet" /> | –                  |
+| ACCRINT    | <Badge type="tip" text="Available" />          | [ACCRINT](financial/accrint) |
-| ACCRINTM   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| ACCRINTM   | <Badge type="tip" text="Available" />          | [ACCRINTM](financial/accrintm) |
 | AMORDEGRC  | <Badge type="info" text="Not implemented yet" /> | –                  |
 | AMORLINC   | <Badge type="info" text="Not implemented yet" /> | –                  |
-| COUPDAYBS  | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPDAYBS  | <Badge type="tip" text="Available" /> | –                  |
-| COUPDAYS   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPDAYS   | <Badge type="tip" text="Available" /> | –                  |
-| COUPDAYSNC | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPDAYSNC | <Badge type="tip" text="Available" /> | –                  |
-| COUPNCD    | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPNCD    | <Badge type="tip" text="Available" /> | –                  |
-| COUPNUM    | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPNUM    | <Badge type="tip" text="Available" /> | –                  |
-| COUPPCD    | <Badge type="info" text="Not implemented yet" /> | –                  |
+| COUPPCD    | <Badge type="tip" text="Available" /> | –                  |
 | CUMIPMT    | <Badge type="tip" text="Available" />          | –                  |
 | CUMPRINC   | <Badge type="tip" text="Available" />          | –                  |
 | DB         | <Badge type="tip" text="Available" />          | –                  |
 | DDB        | <Badge type="tip" text="Available" />          | –                  |
-| DISC       | <Badge type="info" text="Not implemented yet" /> | –                  |
+| DISC       | <Badge type="tip" text="Available" />          | –                  |
 | DOLLARDE   | <Badge type="tip" text="Available" />          | –                  |
 | DOLLARFR   | <Badge type="tip" text="Available" />          | –                  |
-| DURATION   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| DURATION   | <Badge type="tip" text="Available" />          | –                  |
 | EFFECT     | <Badge type="tip" text="Available" />          | –                  |
 | FV         | <Badge type="tip" text="Available" />          | [FV](financial/fv) |
-| FVSCHEDULE | <Badge type="info" text="Not implemented yet" /> | –                  |
+| FVSCHEDULE | <Badge type="tip" text="Available" /> | [FVSCHEDULE](financial/fvschedule) |
-| INTRATE    | <Badge type="info" text="Not implemented yet" /> | –                  |
+| INTRATE    | <Badge type="tip" text="Available" />          | –                  |
 | IPMT       | <Badge type="tip" text="Available" />          | –                  |
 | IRR        | <Badge type="tip" text="Available" />          | –                  |
 | ISPMT      | <Badge type="tip" text="Available" />          | –                  |
-| MDURATION  | <Badge type="info" text="Not implemented yet" /> | –                  |
+| MDURATION  | <Badge type="tip" text="Available" />          | –                  |
 | MIRR       | <Badge type="tip" text="Available" />          | –                  |
 | NOMINAL    | <Badge type="tip" text="Available" />          | –                  |
 | NPER       | <Badge type="tip" text="Available" />          | –                  |
@@ -48,12 +48,12 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | PDURATION  | <Badge type="tip" text="Available" />          | –                  |
 | PMT        | <Badge type="tip" text="Available" />          | –                  |
 | PPMT       | <Badge type="tip" text="Available" />          | –                  |
-| PRICE      | <Badge type="info" text="Not implemented yet" /> | –                  |
+| PRICE      | <Badge type="tip" text="Available" />          | –                  |
-| PRICEDISC  | <Badge type="info" text="Not implemented yet" /> | –                  |
+| PRICEDISC  | <Badge type="tip" text="Available" />          | –                  |
-| PRICEMAT   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| PRICEMAT   | <Badge type="tip" text="Available" />          | –                  |
 | PV         | <Badge type="tip" text="Available" />          | [PV](financial/pv) |
 | RATE       | <Badge type="tip" text="Available" />          | –                  |
-| RECEIVED   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| RECEIVED   | <Badge type="tip" text="Available" />          | –                  |
 | RRI        | <Badge type="tip" text="Available" />          | -                  |
 | SLN        | <Badge type="tip" text="Available" />          | –                  |
 | SYD        | <Badge type="tip" text="Available" />          | –                  |
@@ -63,6 +63,9 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | VDB        | <Badge type="info" text="Not implemented yet" /> | –                  |
 | XIRR       | <Badge type="tip" text="Available" />          | –                  |
 | XNPV       | <Badge type="tip" text="Available" />          | –                  |
-| YIELD      | <Badge type="info" text="Not implemented yet" /> | –                  |
+| YIELD      | <Badge type="tip" text="Available" />          | –                  |
 | YIELDDISC  | <Badge type="info" text="Not implemented yet" /> | –                  |
 | YIELDMAT   | <Badge type="info" text="Not implemented yet" /> | –                  |
+| YIELD      | <Badge type="tip" text="Available" />          | –                  |
+| YIELDDISC  | <Badge type="tip" text="Available" />          | –                  |
+| YIELDMAT   | <Badge type="tip" text="Available" />          | –                  |

docs/src/functions/financial/accrint.md

@@ -7,6 +7,5 @@ lang: en-US
 # ACCRINT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/accrintm.md

@@ -7,6 +7,5 @@ lang: en-US
 # ACCRINTM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/coupdaybs.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYBS
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/coupdays.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYS
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/coupdaysnc.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYSNC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/coupncd.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPNCD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/coupnum.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPNUM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/couppcd.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPPCD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/disc.md

@@ -7,6 +7,5 @@ lang: en-US
 # DISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/duration.md

@@ -7,6 +7,5 @@ lang: en-US
 # DURATION
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/fvschedule.md

@@ -7,6 +7,5 @@ lang: en-US
 # FVSCHEDULE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/intrate.md

@@ -7,6 +7,5 @@ lang: en-US
 # INTRATE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/mduration.md

@@ -7,6 +7,5 @@ lang: en-US
 # MDURATION
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/price.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/pricedisc.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICEDISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/pricemat.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICEMAT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/received.md

@@ -7,6 +7,5 @@ lang: en-US
 # RECEIVED
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/yield.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/yielddisc.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELDDISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

docs/src/functions/financial/yieldmat.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELDMAT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::