Compare commits
4 Commits
feature/br
...
llm_test/a
| Author | SHA1 | Date | |
|---|---|---|---|
|
ff5be2f544 | ||
|
|
a2d11a42cc | ||
|
|
480a2d1769 | ||
|
|
f30f6864e2 |
@@ -550,14 +550,6 @@ 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]
|
||||
@@ -760,7 +752,6 @@ 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),
|
||||
@@ -768,20 +759,9 @@ 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),
|
||||
@@ -790,14 +770,6 @@ 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),
|
||||
@@ -904,6 +876,8 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
|
||||
Function::Sheets => args_signature_scalars(arg_count, 0, 1),
|
||||
Function::Cell => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Info => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Accrint => args_signature_scalars(arg_count, 6, 2),
|
||||
Function::Accrintm => args_signature_scalars(arg_count, 4, 1),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1044,7 +1018,6 @@ 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),
|
||||
@@ -1052,20 +1025,9 @@ 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),
|
||||
@@ -1074,14 +1036,6 @@ 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),
|
||||
@@ -1187,5 +1141,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Sheets => scalar_arguments(args),
|
||||
Function::Cell => scalar_arguments(args),
|
||||
Function::Info => scalar_arguments(args),
|
||||
Function::Accrint => scalar_arguments(args),
|
||||
Function::Accrintm => scalar_arguments(args),
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -219,12 +219,6 @@ pub enum Function {
|
||||
// Financial
|
||||
Accrint,
|
||||
Accrintm,
|
||||
Coupdaybs,
|
||||
Coupdays,
|
||||
Coupdaysnc,
|
||||
Coupncd,
|
||||
Coupnum,
|
||||
Couppcd,
|
||||
Cumipmt,
|
||||
Cumprinc,
|
||||
Db,
|
||||
@@ -233,7 +227,6 @@ pub enum Function {
|
||||
Dollarfr,
|
||||
Effect,
|
||||
Fv,
|
||||
Fvschedule,
|
||||
Ipmt,
|
||||
Irr,
|
||||
Ispmt,
|
||||
@@ -241,12 +234,9 @@ pub enum Function {
|
||||
Nominal,
|
||||
Nper,
|
||||
Npv,
|
||||
Duration,
|
||||
Mduration,
|
||||
Pduration,
|
||||
Pmt,
|
||||
Ppmt,
|
||||
Price,
|
||||
Pv,
|
||||
Rate,
|
||||
Rri,
|
||||
@@ -255,16 +245,8 @@ pub enum Function {
|
||||
Tbilleq,
|
||||
Tbillprice,
|
||||
Tbillyield,
|
||||
Pricedisc,
|
||||
Pricemat,
|
||||
Yielddisc,
|
||||
Yieldmat,
|
||||
Disc,
|
||||
Received,
|
||||
Intrate,
|
||||
Xirr,
|
||||
Xnpv,
|
||||
Yield,
|
||||
|
||||
// Engineering: Bessel and transcendental functions
|
||||
Besseli,
|
||||
@@ -333,7 +315,7 @@ pub enum Function {
|
||||
}
|
||||
|
||||
impl Function {
|
||||
pub fn into_iter() -> IntoIter<Function, 276> {
|
||||
pub fn into_iter() -> IntoIter<Function, 258> {
|
||||
[
|
||||
Function::And,
|
||||
Function::False,
|
||||
@@ -494,23 +476,18 @@ 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,
|
||||
@@ -522,25 +499,10 @@ 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,
|
||||
@@ -611,6 +573,8 @@ impl Function {
|
||||
Function::Cell,
|
||||
Function::Info,
|
||||
Function::Sheets,
|
||||
Function::Accrint,
|
||||
Function::Accrintm,
|
||||
]
|
||||
.into_iter()
|
||||
}
|
||||
@@ -853,20 +817,15 @@ 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),
|
||||
@@ -877,27 +836,11 @@ 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),
|
||||
@@ -969,6 +912,8 @@ impl Function {
|
||||
"CELL" => Some(Function::Cell),
|
||||
"INFO" => Some(Function::Info),
|
||||
"SHEETS" | "_XLFN.SHEETS" => Some(Function::Sheets),
|
||||
"ACCRINT" => Some(Function::Accrint),
|
||||
"ACCRINTM" => Some(Function::Accrintm),
|
||||
|
||||
_ => None,
|
||||
}
|
||||
@@ -1113,23 +1058,18 @@ 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"),
|
||||
@@ -1141,25 +1081,10 @@ 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"),
|
||||
@@ -1255,6 +1180,9 @@ impl fmt::Display for Function {
|
||||
Function::Cell => write!(f, "CELL"),
|
||||
Function::Info => write!(f, "INFO"),
|
||||
Function::Sheets => write!(f, "SHEETS"),
|
||||
|
||||
Function::Accrint => write!(f, "ACCRINT"),
|
||||
Function::Accrintm => write!(f, "ACCRINTM"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1410,24 +1338,18 @@ 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),
|
||||
@@ -1439,25 +1361,10 @@ 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),
|
||||
@@ -1560,6 +1467,8 @@ impl Model {
|
||||
Function::Cell => self.fn_cell(args, cell),
|
||||
Function::Info => self.fn_info(args, cell),
|
||||
Function::Sheets => self.fn_sheets(args, cell),
|
||||
Function::Accrint => self.fn_accrint(args, cell),
|
||||
Function::Accrintm => self.fn_accrintm(args, cell),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,19 +11,14 @@ 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;
|
||||
@@ -66,9 +61,9 @@ mod test_number_format;
|
||||
mod test_arrays;
|
||||
mod test_escape_quotes;
|
||||
mod test_extend;
|
||||
mod test_fn_accrint;
|
||||
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;
|
||||
|
||||
23
base/src/test/test_even_odd
Normal file
23
base/src/test/test_even_odd
Normal file
@@ -0,0 +1,23 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=EVEN(2)");
|
||||
model._set("A2", "=ODD(2)");
|
||||
model._set("A3", "=EVEN()");
|
||||
model._set("A4", "=ODD()");
|
||||
model._set("A5", "=EVEN(1, 2)");
|
||||
model._set("A6", "=ODD(1, 2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"3");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,134 +1,23 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_accrint() {
|
||||
fn fn_average_accrint_simple_cases() {
|
||||
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)");
|
||||
|
||||
// ACCRINT(issue, first_interest, settlement, rate, par, frequency, [basis], [calc_method])
|
||||
model._set("A1", "=ACCRINT(39508, 39691, 39569, 0.1, 1000, 2, 0)");
|
||||
model._set(
|
||||
"A2",
|
||||
"=ACCRINT(DATE(2008, 3, 5), 39691, 39569, 0.1, 1000, 2, 0, FALSE)",
|
||||
);
|
||||
model._set(
|
||||
"A3",
|
||||
"=ACCRINT(DATE(2008, 4, 5), 39691, 39569, 0.1, 1000, 2, 0, TRUE)",
|
||||
);
|
||||
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),
|
||||
}
|
||||
assert_eq!(model._get_text("A1"), *"16.666666667");
|
||||
assert_eq!(model._get_text("A2"), *"15.555555556");
|
||||
assert_eq!(model._get_text("A3"), *"7.222222222");
|
||||
}
|
||||
|
||||
@@ -1,122 +0,0 @@
|
||||
#![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),
|
||||
}
|
||||
}
|
||||
@@ -1,260 +0,0 @@
|
||||
#![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!");
|
||||
}
|
||||
24
base/src/test/test_fn_datevalue_timevalue.rs
Normal file
24
base/src/test/test_fn_datevalue_timevalue.rs
Normal file
@@ -0,0 +1,24 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn datevalue_timevalue_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATEVALUE()");
|
||||
model._set("A2", "=TIMEVALUE()");
|
||||
model._set("A3", "=DATEVALUE("2000-01-01")")
|
||||
model._set("A4", "=TIMEVALUE("12:00:00")")
|
||||
model._set("A5", "=DATEVALUE(1,2)");
|
||||
model._set("A6", "=TIMEVALUE(1,2)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"36526");
|
||||
assert_eq!(model._get_text("A4"), *"0.5");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
|
||||
|
||||
@@ -1,350 +0,0 @@
|
||||
#![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");
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
@@ -26,10 +25,6 @@ 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!");
|
||||
@@ -51,10 +46,6 @@ 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]
|
||||
@@ -477,18 +468,3 @@ 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");
|
||||
}
|
||||
|
||||
@@ -1,615 +0,0 @@
|
||||
#![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);
|
||||
}
|
||||
}
|
||||
@@ -1,127 +0,0 @@
|
||||
#![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!");
|
||||
}
|
||||
@@ -12,7 +12,7 @@ All Date and Time functions are already supported in IronCalc.
|
||||
| ---------------- | ---------------------------------------------- | ------------- |
|
||||
| DATE | <Badge type="tip" text="Available" /> | – |
|
||||
| DATEDIF | <Badge type="tip" text="Available" /> | – |
|
||||
| DATEVALUE | <Badge type="tip" text="Available" /> | – |
|
||||
| DATEVALUE | <Badge type="tip" text="Available" /> | [DATEVALUE](date_and_time/datevalue) |
|
||||
| DAY | <Badge type="tip" text="Available" /> | [DAY](date_and_time/day) |
|
||||
| DAYS | <Badge type="tip" text="Available" /> | – |
|
||||
| DAYS360 | <Badge type="tip" text="Available" /> | – |
|
||||
@@ -27,7 +27,7 @@ All Date and Time functions are already supported in IronCalc.
|
||||
| NOW | <Badge type="tip" text="Available" /> | – |
|
||||
| SECOND | <Badge type="tip" text="Available" /> | – |
|
||||
| TIME | <Badge type="tip" text="Available" /> | – |
|
||||
| TIMEVALUE | <Badge type="tip" text="Available" /> | – |
|
||||
| TIMEVALUE | <Badge type="tip" text="Available" /> | [TIMEVALUE](date_and_time/timevalue) |
|
||||
| TODAY | <Badge type="tip" text="Available" /> | – |
|
||||
| WEEKDAY | <Badge type="tip" text="Available" /> | – |
|
||||
| WEEKNUM | <Badge type="tip" text="Available" /> | – |
|
||||
|
||||
@@ -4,8 +4,41 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DATEVALUE
|
||||
# DATEVALUE function
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
:::
|
||||
## Overview
|
||||
DATEVALUE is a function of the Date and Time category that converts a date stored as text to a [serial number](/features/serial-numbers.md) corresponding to a date value.
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**DATEVALUE(<span title="Text" style="color:#1E88E5">date_text</span>) => <span title="Number" style="color:#1E88E5">datevalue</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *date_text* ([text](/features/value-types#strings), required). A text string that represents a date in a known format. The text must represent a date between December 31, 1899 and December 31, 9999.
|
||||
|
||||
### Additional guidance
|
||||
* If the year portion of the *date_text* argument is omitted, DATEVALUE uses the current year from the system clock.
|
||||
* Time information in the *date_text* argument is ignored. DATEVALUE processes only the date portion.
|
||||
|
||||
### Returned value
|
||||
DATEVALUE returns a [number](/features/value-types#numbers) that represents the date as a [serial number](/features/serial-numbers.md). The serial number corresponds to the number of days since December 31, 1899.
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, DATEVALUE propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then DATEVALUE returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *date_text* argument is not (or cannot be converted to) a [text](/features/value-types#strings) value, then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the *date_text* argument represents a date outside the valid range (before December 31, 1899 or after December 31, 9999), then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the *date_text* argument cannot be recognized as a valid date format, then DATEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
|
||||
<!-- ## Details
|
||||
For more information on how IronCalc processes Date and Time functions and values, visit [Date and Time](/features/serial-numbers.md)
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=datevalue).
|
||||
-->
|
||||
|
||||
## Links
|
||||
* See also IronCalc's [TIMEVALUE](/functions/date_and_time/timevalue.md) function for converting time text to serial numbers.
|
||||
* Visit Microsoft Excel's [DATEVALUE function](https://support.microsoft.com/en-us/office/datevalue-function-df8b07d4-7761-4a93-bc33-b7471bbff252) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093039) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/DATEVALUE) provide versions of the DATEVALUE function.
|
||||
@@ -4,9 +4,42 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# TIMEVALUE
|
||||
# TIMEVALUE function
|
||||
|
||||
::: warning
|
||||
**Note:** This draft page is under construction 🚧
|
||||
The TIMEVALUE function is implemented and available in IronCalc.
|
||||
:::
|
||||
## Overview
|
||||
TIMEVALUE is a function of the Date and Time category that converts a time stored as text to a [serial number](/features/serial-numbers.md) corresponding to a time value. The serial number represents time as a decimal fraction of a 24-hour day (e.g., 0.5 represents 12:00:00 noon).
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**TIMEVALUE(<span title="Text" style="color:#1E88E5">time_text</span>) => <span title="Number" style="color:#1E88E5">timevalue</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *time_text* ([text](/features/value-types#strings), required). A text string that represents a time in a known format. The text must represent a time between 00:00:00 and 23:59:59.
|
||||
|
||||
### Additional guidance
|
||||
* Date information in the *time_text* argument is ignored. TIMEVALUE processes only the time portion.
|
||||
* The function can handle various time formats, including both 12-hour and 24-hour formats, as well as text that includes both date and time information.
|
||||
|
||||
### Returned value
|
||||
TIMEVALUE returns a [number](/features/value-types#numbers) that represents the time as a [serial number](/features/serial-numbers.md). The serial number is a decimal fraction of a 24-hour day, where:
|
||||
* 0.0 represents 00:00:00 (midnight)
|
||||
* 0.5 represents 12:00:00 (midday)
|
||||
* 0.99999... represents 23:59:59 (just before midnight)
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, TIMEVALUE propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then TIMEVALUE returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *time_text* argument is not (or cannot be converted to) a [text](/features/value-types#strings) value, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the *time_text* argument represents a time outside the valid range, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the *time_text* argument cannot be recognized as a valid time format, then TIMEVALUE returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
|
||||
<!--
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=timevalue).
|
||||
-->
|
||||
|
||||
## Links
|
||||
* See also IronCalc's [DATEVALUE](/functions/date_and_time/datevalue.md) function for converting date text to serial numbers.
|
||||
* Visit Microsoft Excel's [TIMEVALUE function](https://support.microsoft.com/en-us/office/timevalue-function-0b615c12-33d8-4431-bf3d-f3eb6d186645) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3267350) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/TIMEVALUE) provide versions of the TIMEVALUE function.
|
||||
@@ -11,32 +11,32 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
|
||||
| Function | Status | Documentation |
|
||||
| ---------- | ---------------------------------------------- | ------------------ |
|
||||
| ACCRINT | <Badge type="tip" text="Available" /> | [ACCRINT](financial/accrint) |
|
||||
| ACCRINTM | <Badge type="tip" text="Available" /> | [ACCRINTM](financial/accrintm) |
|
||||
| ACCRINT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ACCRINTM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| AMORDEGRC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| AMORLINC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPDAYBS | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPDAYS | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPDAYSNC | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPNCD | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPNUM | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPPCD | <Badge type="tip" text="Available" /> | – |
|
||||
| COUPDAYBS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPDAYS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPDAYSNC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPNCD | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPNUM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COUPPCD | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| 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="tip" text="Available" /> | – |
|
||||
| DISC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DOLLARDE | <Badge type="tip" text="Available" /> | – |
|
||||
| DOLLARFR | <Badge type="tip" text="Available" /> | – |
|
||||
| DURATION | <Badge type="tip" text="Available" /> | – |
|
||||
| DURATION | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| EFFECT | <Badge type="tip" text="Available" /> | – |
|
||||
| FV | <Badge type="tip" text="Available" /> | [FV](financial/fv) |
|
||||
| FVSCHEDULE | <Badge type="tip" text="Available" /> | [FVSCHEDULE](financial/fvschedule) |
|
||||
| INTRATE | <Badge type="tip" text="Available" /> | – |
|
||||
| FVSCHEDULE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| INTRATE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| IPMT | <Badge type="tip" text="Available" /> | – |
|
||||
| IRR | <Badge type="tip" text="Available" /> | – |
|
||||
| ISPMT | <Badge type="tip" text="Available" /> | – |
|
||||
| MDURATION | <Badge type="tip" text="Available" /> | – |
|
||||
| MDURATION | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| 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="tip" text="Available" /> | – |
|
||||
| PRICEDISC | <Badge type="tip" text="Available" /> | – |
|
||||
| PRICEMAT | <Badge type="tip" text="Available" /> | – |
|
||||
| PRICE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| PRICEDISC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| PRICEMAT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| PV | <Badge type="tip" text="Available" /> | [PV](financial/pv) |
|
||||
| RATE | <Badge type="tip" text="Available" /> | – |
|
||||
| RECEIVED | <Badge type="tip" text="Available" /> | – |
|
||||
| RECEIVED | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| RRI | <Badge type="tip" text="Available" /> | - |
|
||||
| SLN | <Badge type="tip" text="Available" /> | – |
|
||||
| SYD | <Badge type="tip" text="Available" /> | – |
|
||||
@@ -63,9 +63,6 @@ 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="tip" text="Available" /> | – |
|
||||
| YIELD | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| 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" /> | – |
|
||||
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# ACCRINT
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# ACCRINTM
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPDAYBS
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPDAYS
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPDAYSNC
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPNCD
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPNUM
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# COUPPCD
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# DISC
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# DURATION
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# FVSCHEDULE
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# INTRATE
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# MDURATION
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# PRICE
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# PRICEDISC
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# PRICEMAT
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# RECEIVED
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# YIELD
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# YIELDDISC
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# YIELDMAT
|
||||
|
||||
::: warning
|
||||
🚧 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).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -36,8 +36,8 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| CSC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CSCH | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DECIMAL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DEGREES | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| EVEN | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DEGREES | <Badge type="info" text="Not implemented yet" /> | [DEGREES](math_and_trigonometry/degrees) |
|
||||
| EVEN | <Badge type="info" text="Not implemented yet" /> | [EVEN](math_and_trigonometry/even) |
|
||||
| EXP | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| FACT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| FACTDOUBLE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
@@ -49,9 +49,9 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| ISO.CEILING | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LCM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LET | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LN | <Badge type="info" text="Available" /> | – |
|
||||
| LOG | <Badge type="info" text="Available" /> | – |
|
||||
| LOG10 | <Badge type="info" text="Available" /> | – |
|
||||
| LN | <Badge type="tip" text="Available" /> | – |
|
||||
| LOG | <Badge type="tip" text="Available" /> | – |
|
||||
| LOG10 | <Badge type="tip" text="Available" /> | – |
|
||||
| MDETERM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MINVERSE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MMULT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
@@ -59,12 +59,12 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| MROUND | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MULTINOMIAL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MUNIT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ODD | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ODD | <Badge type="info" text="Not implemented yet" /> | [ODD](math_and_trigonometry/odd) |
|
||||
| PI | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| POWER | <Badge type="tip" text="Available" /> | – |
|
||||
| PRODUCT | <Badge type="tip" text="Available" /> | – |
|
||||
| QUOTIENT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| RADIANS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| RADIANS | <Badge type="info" text="Not implemented yet" /> | [RADIANS](math_and_trigonometry/radians) |
|
||||
| RAND | <Badge type="tip" text="Available" /> | – |
|
||||
| RANDARRAY | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| RANDBETWEEN | <Badge type="tip" text="Available" /> | – |
|
||||
@@ -80,7 +80,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| SIN | <Badge type="tip" text="Available" /> | [SIN](math_and_trigonometry/sin) |
|
||||
| SINH | <Badge type="tip" text="Available" /> | [SINH](math_and_trigonometry/sinh) |
|
||||
| SQRT | <Badge type="tip" text="Available" /> | – |
|
||||
| SQRTPI | <Badge type="info" text="Available" /> | – |
|
||||
| SQRTPI | <Badge type="tip" text="Available" /> | – |
|
||||
| SUBTOTAL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUM | <Badge type="tip" text="Available" /> | – |
|
||||
| SUMIF | <Badge type="tip" text="Available" /> | – |
|
||||
|
||||
@@ -4,9 +4,40 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DEGREES
|
||||
# DEGREES function
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
## Overview
|
||||
DEGREES is a function of the Math and Trigonometry category that converts an angle measured in radians to an equivalent angle measured in degrees.
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**DEGREES(<span title="Number" style="color:#1E88E5">angle</span>) => <span title="Number" style="color:#1E88E5">degrees</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *angle* ([number](/features/value-types#numbers), required). The angle in radians that is to be converted to degrees.
|
||||
|
||||
### Additional guidance
|
||||
The conversion from radians to degrees is based on the relationship:
|
||||
$$
|
||||
1~\:~\text{radian} = \dfrac{180}{\pi}~\text{degrees} \approx 57.29577951~\text{degrees}
|
||||
$$
|
||||
|
||||
### Returned value
|
||||
DEGREES returns a [number](/features/value-types#numbers) that represents the value of the given angle expressed in degrees.
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, DEGREES propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then DEGREES returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *angle* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then DEGREES returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
|
||||
<!--
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=degrees).
|
||||
-->
|
||||
|
||||
## Links
|
||||
* For more information about angle conversions, visit Wikipedia's [Degree (angle)](https://en.wikipedia.org/wiki/Degree_(angle)) page.
|
||||
* See also IronCalc's [RADIANS](/functions/math_and_trigonometry/radians) function for converting degrees to radians.
|
||||
* Visit Microsoft Excel's [DEGREES function](https://support.microsoft.com/en-us/office/degrees-function-4d6ec4db-e694-4b94-ace0-1cc3f61f9ba1) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093481) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/DEGREES) provide versions of the DEGREES function.
|
||||
@@ -4,9 +4,41 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# EVEN
|
||||
# EVEN function
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
## Overview
|
||||
EVEN is a function of the Math and Trigonometry category that rounds a number up (away from zero) to the nearest even integer.
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**EVEN(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">even</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The number that is to be rounded to the nearest even integer.
|
||||
|
||||
### Additional guidance
|
||||
* EVEN rounds away from zero, meaning:
|
||||
* Positive numbers are rounded up to the next even integer.
|
||||
* Negative numbers are rounded down (toward negative infinity) to the next even integer.
|
||||
* If the *number* argument is already an even integer, EVEN returns it unchanged.
|
||||
* Since zero is considered an even number, the EVEN function returns 0 when *number* is 0.
|
||||
|
||||
### Returned value
|
||||
EVEN returns a [number](/features/value-types#numbers) that is the nearest even integer, rounded away from zero.
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, EVEN propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then EVEN returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then EVEN returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
|
||||
<!--
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=even).
|
||||
-->
|
||||
|
||||
## Links
|
||||
* For more information about even and odd numbers, visit Wikipedia's [Parity](https://en.wikipedia.org/wiki/Parity_(mathematics)) page.
|
||||
* See also IronCalc's [ODD](/functions/math_and_trigonometry/odd) function.
|
||||
* Visit Microsoft Excel's [EVEN function](https://support.microsoft.com/en-us/office/even-function-197b5f06-c795-4c1e-8696-3c3b8a646cf9) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093409) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/EVEN) provide versions of the EVEN function.
|
||||
@@ -4,9 +4,41 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ODD
|
||||
# ODD function
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
## Overview
|
||||
ODD is a function of the Math and Trigonometry category that rounds a number up (away from zero) to the nearest odd integer.
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**ODD(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">odd</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The number that is to be rounded to the nearest odd integer.
|
||||
|
||||
### Additional guidance
|
||||
* ODD rounds away from zero, meaning:
|
||||
* Positive numbers are rounded up to the next odd integer.
|
||||
* Negative numbers are rounded down (toward negative infinity) to the next odd integer.
|
||||
* If the *number* argument is already an odd integer, ODD returns it unchanged.
|
||||
* Since zero is considered an even number, the ODD function returns 1 when *number* is 0.
|
||||
|
||||
### Returned value
|
||||
ODD returns a [number](/features/value-types#numbers) that is the nearest odd integer, rounded away from zero.
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ODD propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ODD returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ODD returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
|
||||
<!--
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=odd).
|
||||
-->
|
||||
|
||||
## Links
|
||||
* For more information about even and odd numbers, visit Wikipedia's [Parity](https://en.wikipedia.org/wiki/Parity_(mathematics)) page.
|
||||
* See also IronCalc's [EVEN](/functions/math_and_trigonometry/even) function.
|
||||
* Visit Microsoft Excel's [ODD function](https://support.microsoft.com/en-us/office/odd-function-deae64eb-e08a-4c88-8b40-6d0b42575c98) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093499) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ODD) provide versions of the ODD function.
|
||||
@@ -4,9 +4,38 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# RADIANS
|
||||
# RADIANS function
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
## Overview
|
||||
RADIANS is a function of the Math and Trigonometry category that converts an angle measured in degrees to an equivalent angle measured in radians.
|
||||
|
||||
## Usage
|
||||
### Syntax
|
||||
**RADIANS(<span title="Number" style="color:#1E88E5">angle</span>) => <span title="Number" style="color:#1E88E5">radians</span>**
|
||||
|
||||
### Argument descriptions
|
||||
* *angle* ([number](/features/value-types#numbers), required). The angle in degrees that is to be converted to radians.
|
||||
|
||||
### Additional guidance
|
||||
The conversion from degrees to radians is based on the relationship:
|
||||
$$
|
||||
1~\:~\text{degree} = \dfrac{\pi}{180}~\text{radians} \approx 0.01745329252~\text{radians}
|
||||
$$
|
||||
|
||||
### Returned value
|
||||
RADIANS returns a [number](/features/value-types#numbers) that represents the value of the given angle expressed in radians.
|
||||
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, RADIANS propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then RADIANS returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *angle* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then RADIANS returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
<!--
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=radians).
|
||||
-->
|
||||
## Links
|
||||
* For more information about angle conversions, visit Wikipedia's [Radian](https://en.wikipedia.org/wiki/Radian) page.
|
||||
* See also IronCalc's [DEGREES](/functions/math_and_trigonometry/degrees) function for converting radians to degrees.
|
||||
* Visit Microsoft Excel's [RADIANS function](https://support.microsoft.com/en-us/office/radians-function-907f0ede-ef2e-4f7b-911a-015e2f8ab878) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093481) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/RADIANS) provide versions of the RADIANS function.
|
||||
BIN
xlsx/tests/calc_tests/ACCRINT_ACCRINTM.xlsx
Normal file
BIN
xlsx/tests/calc_tests/ACCRINT_ACCRINTM.xlsx
Normal file
Binary file not shown.
BIN
xlsx/tests/calc_tests/DEGREES_RADIANS.xlsx
Normal file
BIN
xlsx/tests/calc_tests/DEGREES_RADIANS.xlsx
Normal file
Binary file not shown.
BIN
xlsx/tests/calc_tests/EVEN_ODD.xlsx
Normal file
BIN
xlsx/tests/calc_tests/EVEN_ODD.xlsx
Normal file
Binary file not shown.
Reference in New Issue
Block a user