merge duration, mduration #44

merge price, yield #29

merge fvschedule #56

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

merge accrint, accrintm #58

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

fix cursor

refactor

refactor

fix build

Cargo.lock

@@ -414,7 +414,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -430,7 +430,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -447,7 +447,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_nodejs"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "ironcalc",
  "napi",
@@ -782,7 +782,7 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.5.7"
+version = "0.6.0"
 dependencies = [
  "bitcode",
  "ironcalc",
@@ -1075,7 +1075,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "ironcalc_base",
  "serde",

Dockerfile

@@ -0,0 +1,93 @@
+FROM rust:latest AS builder
+
+WORKDIR /app
+COPY . .
+
+# Tools + wasm toolchain + Node via nvm
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      bash curl ca-certificates make \
+    && rustup target add wasm32-unknown-unknown \
+    && cargo install wasm-pack \
+    && bash -lc "curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash -" \
+    && bash -lc '\
+         export NVM_DIR="$HOME/.nvm" && \
+         source "$NVM_DIR/nvm.sh" && \
+         nvm install 22 && nvm alias default 22 && \
+         nroot="$NVM_DIR/versions/node/$(nvm version default)/bin" && \
+         ln -sf "$nroot/node" /usr/local/bin/node && \
+         ln -sf "$nroot/npm"  /usr/local/bin/npm  && \
+         ln -sf "$nroot/npx"  /usr/local/bin/npx \
+       ' \
+    && npm install typescript \
+    && rm -rf /var/lib/apt/lists/*
+
+# build the server
+RUN cargo build --release --manifest-path webapp/app.ironcalc.com/server/Cargo.toml
+
+# build the wasm
+RUN make -C bindings/wasm
+
+# build the widget
+WORKDIR /app/webapp/IronCalc
+RUN npm install && npm run build
+
+# build the frontend app
+WORKDIR /app/webapp/app.ironcalc.com/frontend
+RUN npm install && npm run build
+
+# build the xlsx_2_icalc binary (we don't need the release version here)
+WORKDIR /app/xlsx
+RUN cargo build
+
+WORKDIR /app
+# copy the artifacts to a dist/ directory
+RUN mkdir dist
+RUN mkdir dist/frontend
+RUN cp -r webapp/app.ironcalc.com/frontend/dist/* dist/frontend/
+RUN mkdir dist/server
+RUN cp webapp/app.ironcalc.com/server/target/release/ironcalc_server dist/server/
+RUN cp webapp/app.ironcalc.com/server/Rocket.toml dist/server/
+RUN cp webapp/app.ironcalc.com/server/ironcalc.sqlite dist/server/
+
+# Create ic files in docs
+RUN mkdir -p dist/frontend/models
+
+# Loop over all xlsx files in xlsx/tests/docs & templates and convert them to .ic
+RUN bash -lc 'set -euo pipefail; \
+  mkdir -p dist/frontend/models; \
+  shopt -s nullglob; \
+  for xlsx_file in xlsx/tests/docs/*.xlsx; do \
+    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
+    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
+  done; \
+  for xlsx_file in xlsx/tests/templates/*.xlsx; do \
+    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
+    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
+  done'
+
+# ---------- server runtime ----------
+FROM debian:bookworm-slim AS server-runtime
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+# Copy EVERYTHING you put in dist/server (binary + Rocket.toml + DB)
+COPY --from=builder /app/dist/server/ ./
+# Make sure Rocket binds to the container IP; explicitly point to the config file
+ENV ROCKET_ADDRESS=0.0.0.0 \
+    ROCKET_PORT=8000 \
+    ROCKET_CONFIG=/app/Rocket.toml
+EXPOSE 8000
+# Run from /app so relative paths in Rocket.toml/DB work
+CMD ["./ironcalc_server"]
+
+# ---------- caddy runtime (serves frontend + reverse-proxy /api) ----------
+FROM caddy:latest AS caddy-runtime
+
+WORKDIR /srv
+
+# Copy the frontend build output to /srv
+COPY --from=builder /app/dist/frontend/ /srv/
+
+# Copy the Caddyfile
+COPY --from=builder /app/webapp/app.ironcalc.com/Caddyfile.compose /etc/caddy/Caddyfile
+

README.md

@@ -31,7 +31,17 @@ This repository contains the main engine and the xlsx reader and writer.
 
 Programmed in Rust, you will be able to use it from a variety of programming languages like Python, JavaScript (wasm), nodejs and possibly R, Julia or Go.
 
-We will build different _skins_: in the terminal, as a desktop application or use it in you own web application.
+We will build different _skins_: in the terminal, as a desktop application or use it in your own web application.
+
+# Docker
+
+If you have docker installed just run:
+
+```bash
+docker compose up --build
+```
+
+head over to <http://localhost:2080> to test the application.
 
 # Building
 
@@ -84,7 +94,7 @@ And then use this code in `main.rs`:
 
 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, model::Model},
+    base::{expressions::utils::number_to_column, Model},
     export::save_to_xlsx,
 };
 

base/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ironcalc_base"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"

base/src/expressions/parser/static_analysis.rs

@@ -341,7 +341,8 @@ fn static_analysis_offset(args: &[Node]) -> StaticResult {
         }
         _ => return StaticResult::Unknown,
     };
-    StaticResult::Unknown
+    // Both height and width are explicitly 1, so OFFSET will return a single cell
+    StaticResult::Scalar
 }
 
 // fn static_analysis_choose(_args: &[Node]) -> StaticResult {
@@ -549,6 +550,14 @@ fn args_signature_irr(arg_count: usize) -> Vec<Signature> {
     }
 }
 
+fn args_signature_fvschedule(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Scalar, Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
 fn args_signature_xirr(arg_count: usize) -> Vec<Signature> {
     if arg_count == 2 {
         vec![Signature::Vector; arg_count]
@@ -575,6 +584,37 @@ fn args_signature_xnpv(arg_count: usize) -> Vec<Signature> {
     }
 }
 
+// NETWORKDAYS(start_date, end_date, [holidays])
+// Parameters: start_date (scalar), end_date (scalar), holidays (optional vector)
+fn args_signature_networkdays(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Scalar, Signature::Scalar]
+    } else if arg_count == 3 {
+        vec![Signature::Scalar, Signature::Scalar, Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+// NETWORKDAYS.INTL(start_date, end_date, [weekend], [holidays])
+// Parameters: start_date (scalar), end_date (scalar), weekend (optional scalar), holidays (optional vector)
+fn args_signature_networkdays_intl(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Scalar, Signature::Scalar]
+    } else if arg_count == 3 {
+        vec![Signature::Scalar, Signature::Scalar, Signature::Scalar]
+    } else if arg_count == 4 {
+        vec![
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Vector,
+        ]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
 // FIXME: This is terrible duplications of efforts. We use the signature in at least three different places:
 // 1. When computing the function
 // 2. Checking the arguments to see if we need to insert the implicit intersection operator
@@ -690,13 +730,28 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Maxifs => vec![Signature::Vector; arg_count],
         Function::Minifs => vec![Signature::Vector; arg_count],
         Function::Date => args_signature_scalars(arg_count, 3, 0),
+        Function::Datedif => args_signature_scalars(arg_count, 3, 0),
+        Function::Datevalue => args_signature_scalars(arg_count, 1, 0),
         Function::Day => args_signature_scalars(arg_count, 1, 0),
         Function::Edate => args_signature_scalars(arg_count, 2, 0),
         Function::Eomonth => args_signature_scalars(arg_count, 2, 0),
         Function::Month => args_signature_scalars(arg_count, 1, 0),
+        Function::Time => args_signature_scalars(arg_count, 3, 0),
+        Function::Timevalue => args_signature_scalars(arg_count, 1, 0),
+        Function::Hour => args_signature_scalars(arg_count, 1, 0),
+        Function::Minute => args_signature_scalars(arg_count, 1, 0),
+        Function::Second => args_signature_scalars(arg_count, 1, 0),
         Function::Now => args_signature_no_args(arg_count),
         Function::Today => args_signature_no_args(arg_count),
         Function::Year => args_signature_scalars(arg_count, 1, 0),
+        Function::Days => args_signature_scalars(arg_count, 2, 0),
+        Function::Days360 => args_signature_scalars(arg_count, 2, 1),
+        Function::Weekday => args_signature_scalars(arg_count, 1, 1),
+        Function::Weeknum => args_signature_scalars(arg_count, 1, 1),
+        Function::Workday => args_signature_scalars(arg_count, 2, 1),
+        Function::WorkdayIntl => args_signature_scalars(arg_count, 2, 2),
+        Function::Yearfrac => args_signature_scalars(arg_count, 2, 1),
+        Function::Isoweeknum => args_signature_scalars(arg_count, 1, 0),
         Function::Cumipmt => args_signature_scalars(arg_count, 6, 0),
         Function::Cumprinc => args_signature_scalars(arg_count, 6, 0),
         Function::Db => args_signature_scalars(arg_count, 4, 1),
@@ -705,6 +760,7 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Dollarfr => args_signature_scalars(arg_count, 2, 0),
         Function::Effect => args_signature_scalars(arg_count, 2, 0),
         Function::Fv => args_signature_scalars(arg_count, 3, 2),
+        Function::Fvschedule => args_signature_fvschedule(arg_count),
         Function::Ipmt => args_signature_scalars(arg_count, 4, 2),
         Function::Irr => args_signature_irr(arg_count),
         Function::Ispmt => args_signature_scalars(arg_count, 4, 0),
@@ -712,9 +768,20 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Nominal => args_signature_scalars(arg_count, 2, 0),
         Function::Nper => args_signature_scalars(arg_count, 3, 2),
         Function::Npv => args_signature_npv(arg_count),
+        Function::Duration => args_signature_scalars(arg_count, 5, 1),
+        Function::Mduration => args_signature_scalars(arg_count, 5, 1),
         Function::Pduration => args_signature_scalars(arg_count, 3, 0),
+        Function::Accrint => args_signature_scalars(arg_count, 6, 2),
+        Function::Accrintm => args_signature_scalars(arg_count, 4, 1),
+        Function::Coupdaybs => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupdays => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupdaysnc => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupncd => args_signature_scalars(arg_count, 3, 1),
+        Function::Coupnum => args_signature_scalars(arg_count, 3, 1),
+        Function::Couppcd => args_signature_scalars(arg_count, 3, 1),
         Function::Pmt => args_signature_scalars(arg_count, 3, 2),
         Function::Ppmt => args_signature_scalars(arg_count, 4, 2),
+        Function::Price => args_signature_scalars(arg_count, 6, 1),
         Function::Pv => args_signature_scalars(arg_count, 3, 2),
         Function::Rate => args_signature_scalars(arg_count, 3, 3),
         Function::Rri => args_signature_scalars(arg_count, 3, 0),
@@ -723,6 +790,14 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Tbilleq => args_signature_scalars(arg_count, 3, 0),
         Function::Tbillprice => args_signature_scalars(arg_count, 3, 0),
         Function::Tbillyield => args_signature_scalars(arg_count, 3, 0),
+        Function::Yield => args_signature_scalars(arg_count, 6, 1),
+        Function::Pricedisc => args_signature_scalars(arg_count, 4, 1),
+        Function::Pricemat => args_signature_scalars(arg_count, 5, 1),
+        Function::Yielddisc => args_signature_scalars(arg_count, 4, 1),
+        Function::Yieldmat => args_signature_scalars(arg_count, 5, 1),
+        Function::Disc => args_signature_scalars(arg_count, 4, 1),
+        Function::Received => args_signature_scalars(arg_count, 4, 1),
+        Function::Intrate => args_signature_scalars(arg_count, 4, 1),
         Function::Xirr => args_signature_xirr(arg_count),
         Function::Xnpv => args_signature_xnpv(arg_count),
         Function::Besseli => args_signature_scalars(arg_count, 2, 0),
@@ -785,6 +860,50 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Formulatext => args_signature_scalars(arg_count, 1, 0),
         Function::Unicode => args_signature_scalars(arg_count, 1, 0),
         Function::Geomean => vec![Signature::Vector; arg_count],
+        Function::Networkdays => args_signature_networkdays(arg_count),
+        Function::NetworkdaysIntl => args_signature_networkdays_intl(arg_count),
+        Function::Acot => args_signature_scalars(arg_count, 1, 0),
+        Function::Acoth => args_signature_scalars(arg_count, 1, 0),
+        Function::Cot => args_signature_scalars(arg_count, 1, 0),
+        Function::Coth => args_signature_scalars(arg_count, 1, 0),
+        Function::Csc => args_signature_scalars(arg_count, 1, 0),
+        Function::Csch => args_signature_scalars(arg_count, 1, 0),
+        Function::Sec => args_signature_scalars(arg_count, 1, 0),
+        Function::Sech => args_signature_scalars(arg_count, 1, 0),
+        Function::Exp => args_signature_scalars(arg_count, 1, 0),
+        Function::Fact => args_signature_scalars(arg_count, 1, 0),
+        Function::Factdouble => args_signature_scalars(arg_count, 1, 0),
+        Function::Sign => args_signature_scalars(arg_count, 1, 0),
+        Function::Radians => args_signature_scalars(arg_count, 1, 0),
+        Function::Degrees => args_signature_scalars(arg_count, 1, 0),
+        Function::Int => args_signature_scalars(arg_count, 1, 0),
+        Function::Even => args_signature_scalars(arg_count, 1, 0),
+        Function::Odd => args_signature_scalars(arg_count, 1, 0),
+        Function::Ceiling => args_signature_scalars(arg_count, 2, 0),
+        Function::CeilingMath => args_signature_scalars(arg_count, 1, 2),
+        Function::CeilingPrecise => args_signature_scalars(arg_count, 1, 1),
+        Function::Floor => args_signature_scalars(arg_count, 2, 0),
+        Function::FloorMath => args_signature_scalars(arg_count, 1, 2),
+        Function::FloorPrecise => args_signature_scalars(arg_count, 1, 1),
+        Function::IsoCeiling => args_signature_scalars(arg_count, 1, 1),
+        Function::Mod => args_signature_scalars(arg_count, 2, 0),
+        Function::Quotient => args_signature_scalars(arg_count, 2, 0),
+        Function::Mround => args_signature_scalars(arg_count, 2, 0),
+        Function::Trunc => args_signature_scalars(arg_count, 1, 1),
+        Function::Gcd => vec![Signature::Vector; arg_count],
+        Function::Lcm => vec![Signature::Vector; arg_count],
+        Function::Base => args_signature_scalars(arg_count, 2, 1),
+        Function::Decimal => args_signature_scalars(arg_count, 2, 0),
+        Function::Roman => args_signature_scalars(arg_count, 1, 1),
+        Function::Arabic => args_signature_scalars(arg_count, 1, 0),
+        Function::Combin => args_signature_scalars(arg_count, 2, 0),
+        Function::Combina => args_signature_scalars(arg_count, 2, 0),
+        Function::Sumsq => vec![Signature::Vector; arg_count],
+
+        Function::N => args_signature_scalars(arg_count, 1, 0),
+        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),
     }
 }
 
@@ -896,12 +1015,27 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Maxifs => not_implemented(args),
         Function::Minifs => not_implemented(args),
         Function::Date => not_implemented(args),
+        Function::Datedif => not_implemented(args),
+        Function::Datevalue => not_implemented(args),
         Function::Day => not_implemented(args),
         Function::Edate => not_implemented(args),
         Function::Month => not_implemented(args),
+        Function::Time => not_implemented(args),
+        Function::Timevalue => not_implemented(args),
+        Function::Hour => not_implemented(args),
+        Function::Minute => not_implemented(args),
+        Function::Second => not_implemented(args),
         Function::Now => not_implemented(args),
         Function::Today => not_implemented(args),
         Function::Year => not_implemented(args),
+        Function::Days => not_implemented(args),
+        Function::Days360 => not_implemented(args),
+        Function::Weekday => not_implemented(args),
+        Function::Weeknum => not_implemented(args),
+        Function::Workday => not_implemented(args),
+        Function::WorkdayIntl => not_implemented(args),
+        Function::Yearfrac => not_implemented(args),
+        Function::Isoweeknum => not_implemented(args),
         Function::Cumipmt => not_implemented(args),
         Function::Cumprinc => not_implemented(args),
         Function::Db => not_implemented(args),
@@ -910,6 +1044,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Dollarfr => not_implemented(args),
         Function::Effect => not_implemented(args),
         Function::Fv => not_implemented(args),
+        Function::Fvschedule => not_implemented(args),
         Function::Ipmt => not_implemented(args),
         Function::Irr => not_implemented(args),
         Function::Ispmt => not_implemented(args),
@@ -917,9 +1052,20 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Nominal => not_implemented(args),
         Function::Nper => not_implemented(args),
         Function::Npv => not_implemented(args),
+        Function::Duration => not_implemented(args),
+        Function::Mduration => not_implemented(args),
         Function::Pduration => not_implemented(args),
+        Function::Accrint => not_implemented(args),
+        Function::Accrintm => not_implemented(args),
+        Function::Coupdaybs => not_implemented(args),
+        Function::Coupdays => not_implemented(args),
+        Function::Coupdaysnc => not_implemented(args),
+        Function::Coupncd => not_implemented(args),
+        Function::Coupnum => not_implemented(args),
+        Function::Couppcd => not_implemented(args),
         Function::Pmt => not_implemented(args),
         Function::Ppmt => not_implemented(args),
+        Function::Price => not_implemented(args),
         Function::Pv => not_implemented(args),
         Function::Rate => not_implemented(args),
         Function::Rri => not_implemented(args),
@@ -928,6 +1074,14 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Tbilleq => not_implemented(args),
         Function::Tbillprice => not_implemented(args),
         Function::Tbillyield => not_implemented(args),
+        Function::Yield => not_implemented(args),
+        Function::Pricedisc => not_implemented(args),
+        Function::Pricemat => not_implemented(args),
+        Function::Yielddisc => not_implemented(args),
+        Function::Yieldmat => not_implemented(args),
+        Function::Disc => not_implemented(args),
+        Function::Received => not_implemented(args),
+        Function::Intrate => not_implemented(args),
         Function::Xirr => not_implemented(args),
         Function::Xnpv => not_implemented(args),
         Function::Besseli => scalar_arguments(args),
@@ -990,5 +1144,48 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Eomonth => scalar_arguments(args),
         Function::Formulatext => not_implemented(args),
         Function::Geomean => not_implemented(args),
+        Function::Networkdays => not_implemented(args),
+        Function::NetworkdaysIntl => not_implemented(args),
+        Function::Acot => scalar_arguments(args),
+        Function::Acoth => scalar_arguments(args),
+        Function::Cot => scalar_arguments(args),
+        Function::Coth => scalar_arguments(args),
+        Function::Csc => scalar_arguments(args),
+        Function::Csch => scalar_arguments(args),
+        Function::Sec => scalar_arguments(args),
+        Function::Sech => scalar_arguments(args),
+        Function::Exp => scalar_arguments(args),
+        Function::Fact => scalar_arguments(args),
+        Function::Factdouble => scalar_arguments(args),
+        Function::Sign => scalar_arguments(args),
+        Function::Radians => scalar_arguments(args),
+        Function::Degrees => scalar_arguments(args),
+        Function::Int => scalar_arguments(args),
+        Function::Even => scalar_arguments(args),
+        Function::Odd => scalar_arguments(args),
+        Function::Ceiling => scalar_arguments(args),
+        Function::CeilingMath => scalar_arguments(args),
+        Function::CeilingPrecise => scalar_arguments(args),
+        Function::Floor => scalar_arguments(args),
+        Function::FloorMath => scalar_arguments(args),
+        Function::FloorPrecise => scalar_arguments(args),
+        Function::IsoCeiling => scalar_arguments(args),
+        Function::Mod => scalar_arguments(args),
+        Function::Quotient => scalar_arguments(args),
+        Function::Mround => scalar_arguments(args),
+        Function::Trunc => scalar_arguments(args),
+        Function::Gcd => not_implemented(args),
+        Function::Lcm => not_implemented(args),
+        Function::Base => scalar_arguments(args),
+        Function::Decimal => scalar_arguments(args),
+        Function::Roman => scalar_arguments(args),
+        Function::Arabic => scalar_arguments(args),
+        Function::Combin => scalar_arguments(args),
+        Function::Combina => scalar_arguments(args),
+        Function::Sumsq => StaticResult::Scalar,
+        Function::N => scalar_arguments(args),
+        Function::Sheets => scalar_arguments(args),
+        Function::Cell => scalar_arguments(args),
+        Function::Info => scalar_arguments(args),
     }
 }

base/src/expressions/parser/stringify.rs

@@ -520,6 +520,7 @@ fn stringify(
             let x = match **left {
                 BooleanKind(_)
                 | NumberKind(_)
+                | UnaryKind { .. }
                 | StringKind(_)
                 | ReferenceKind { .. }
                 | RangeKind { .. }
@@ -535,7 +536,6 @@ fn stringify(
                 | FunctionKind { .. }
                 | InvalidFunctionKind { .. }
                 | ArrayKind(_)
-                | UnaryKind { .. }
                 | ErrorKind(_)
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
@@ -630,7 +630,6 @@ fn stringify(
                     | OpRangeKind { .. }
                     | OpConcatenateKind { .. }
                     | OpProductKind { .. }
-                    | OpPowerKind { .. }
                     | FunctionKind { .. }
                     | InvalidFunctionKind { .. }
                     | ArrayKind(_)
@@ -643,7 +642,7 @@ fn stringify(
                     | ParseErrorKind { .. }
                     | EmptyArgKind => false,
 
-                    OpSumKind { .. } | UnaryKind { .. } => true,
+                    OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
                 };
                 if needs_parentheses {
                     format!(

base/src/expressions/parser/tests/mod.rs

@@ -3,6 +3,7 @@ mod test_arrays;
 mod test_general;
 mod test_implicit_intersection;
 mod test_issue_155;
+mod test_issue_483;
 mod test_move_formula;
 mod test_ranges;
 mod test_stringify;

base/src/expressions/parser/tests/test_issue_483.rs

@@ -0,0 +1,27 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_483_parser() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 2,
+        column: 2,
+    };
+    let t = parser.parse("-(A1^1.22)", &cell_reference);
+    assert!(matches!(t, Node::UnaryKind { .. }));
+    assert_eq!(to_string(&t, &cell_reference), "-(A1^1.22)");
+
+    let t = parser.parse("-A1^1.22", &cell_reference);
+    assert!(matches!(t, Node::OpPowerKind { .. }));
+    assert_eq!(to_string(&t, &cell_reference), "-A1^1.22");
+}

base/src/expressions/utils/mod.rs

@@ -259,15 +259,23 @@ pub fn is_valid_identifier(name: &str) -> bool {
 fn name_needs_quoting(name: &str) -> bool {
     let chars = name.chars();
     // it contains any of these characters: ()'$,;-+{} or space
-    for char in chars {
+    for (i, char) in chars.enumerate() {
         if [' ', '(', ')', '\'', '$', ',', ';', '-', '+', '{', '}'].contains(&char) {
             return true;
         }
+        // if it starts with a number
+        if i == 0 && char.is_ascii_digit() {
+            return true;
         }
-    // TODO:
+    }
+    if parse_reference_a1(name).is_some() {
         // cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
+        return true;
+    }
+    if parse_reference_r1c1(name).is_some() {
         // cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
-    // integers
+        return true;
+    }
     false
 }
 
@@ -279,3 +287,32 @@ pub fn quote_name(name: &str) -> String {
     };
     name.to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quote_name() {
+        assert_eq!(quote_name("Sheet1"), "Sheet1");
+        assert_eq!(quote_name("Sheet 1"), "'Sheet 1'");
+        // escape and quote
+        assert_eq!(quote_name("Sheet1'"), "'Sheet1'''");
+        assert_eq!(quote_name("Data(2024)"), "'Data(2024)'");
+        assert_eq!(quote_name("Data$2024"), "'Data$2024'");
+        assert_eq!(quote_name("Data-2024"), "'Data-2024'");
+        assert_eq!(quote_name("Data+2024"), "'Data+2024'");
+        assert_eq!(quote_name("Data,2024"), "'Data,2024'");
+        assert_eq!(quote_name("Data;2024"), "'Data;2024'");
+        assert_eq!(quote_name("Data{2024}"), "'Data{2024}'");
+
+        assert_eq!(quote_name("2024"), "'2024'");
+        assert_eq!(quote_name("1Data"), "'1Data'");
+        assert_eq!(quote_name("A1"), "'A1'");
+        assert_eq!(quote_name("R1C1"), "'R1C1'");
+        assert_eq!(quote_name("MySheet"), "MySheet");
+
+        assert_eq!(quote_name("B1048576"), "'B1048576'");
+        assert_eq!(quote_name("B1048577"), "B1048577");
+    }
+}

base/src/formatter/dates.rs

@@ -8,6 +8,8 @@ use crate::constants::EXCEL_DATE_BASE;
 use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
 use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 
+pub const DATE_OUT_OF_RANGE_MESSAGE: &str = "Out of range parameters for date";
+
 #[inline]
 fn convert_to_serial_number(date: NaiveDate) -> i32 {
     date.num_days_from_ce() - EXCEL_DATE_BASE
@@ -37,7 +39,7 @@ pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
 pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
     match NaiveDate::from_ymd_opt(year, month, day) {
         Some(native_date) => Ok(convert_to_serial_number(native_date)),
-        None => Err("Out of range parameters for date".to_string()),
+        None => Err(DATE_OUT_OF_RANGE_MESSAGE.to_string()),
     }
 }
 
@@ -55,7 +57,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
         return Ok(MINIMUM_DATE_SERIAL_NUMBER);
     }
     let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
-        return Err("Out of range parameters for date".to_string());
+        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
     };
 
     // One thing to note for example is that even if you started with a year out of range
@@ -68,7 +70,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
     // As a result, we have to run range checks as we parse the date from the biggest unit to the
     // smallest unit.
     if !is_date_within_range(date) {
-        return Err("Out of range parameters for date".to_string());
+        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
     }
 
     date = {
@@ -80,7 +82,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
             date = date + Months::new(abs_month);
         }
         if !is_date_within_range(date) {
-            return Err("Out of range parameters for date".to_string());
+            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
         }
         date
     };
@@ -94,7 +96,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
             date = date + Days::new(abs_day);
         }
         if !is_date_within_range(date) {
-            return Err("Out of range parameters for date".to_string());
+            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
         }
         date
     };

base/src/formatter/format.rs

@@ -154,16 +154,11 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Date(p) => {
             let tokens = &p.tokens;
             let mut text = "".to_string();
-            let date = match from_excel_date(value as i64) {
-                Ok(d) => d,
-                Err(e) => {
-                    return Formatted {
-                        text: "#VALUE!".to_owned(),
-                        color: None,
-                        error: Some(e),
-                    }
-                }
-            };
+            let time_fract = value.fract();
+            let hours = (time_fract * 24.0).floor();
+            let minutes = ((time_fract * 24.0 - hours) * 60.0).floor();
+            let seconds = ((((time_fract * 24.0 - hours) * 60.0) - minutes) * 60.0).round();
+            let date = from_excel_date(value as i64).ok();
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
@@ -187,15 +182,44 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     }
                     TextToken::Digit(_) => {}
                     TextToken::Period => {}
-                    TextToken::Day => {
+                    TextToken::Day => match date {
+                        Some(date) => {
                             let day = date.day() as usize;
                             text = format!("{text}{day}");
                         }
+                        None => {
+                            return Formatted {
+                                text: "#VALUE!".to_owned(),
+                                color: None,
+                                error: Some(format!("Invalid date value: '{value}'")),
+                            }
+                        }
+                    },
                     TextToken::DayPadded => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let day = date.day() as usize;
                         text = format!("{text}{day:02}");
                     }
                     TextToken::DayNameShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -203,6 +227,16 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names_short[day]);
                     }
                     TextToken::DayName => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -210,32 +244,144 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names[day]);
                     }
                     TextToken::Month => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{text}{month}");
                     }
                     TextToken::MonthPadded => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{text}{month:02}");
                     }
                     TextToken::MonthNameShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months_short[month - 1]);
                     }
                     TextToken::MonthName => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months[month - 1]);
                     }
                     TextToken::MonthLetter => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         let month = date.month() as usize;
                         let months_letter = &locale.dates.months_letter[month - 1];
                         text = format!("{text}{months_letter}");
                     }
                     TextToken::YearShort => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         text = format!("{}{}", text, date.format("%y"));
                     }
                     TextToken::Year => {
+                        let date = match date {
+                            Some(d) => d,
+                            None => {
+                                return Formatted {
+                                    text: "#VALUE!".to_owned(),
+                                    color: None,
+                                    error: Some(format!("Invalid date value: '{value}'")),
+                                }
+                            }
+                        };
                         text = format!("{}{}", text, date.year());
                     }
+                    TextToken::Hour => {
+                        let mut hour = hours as i32;
+                        if p.use_ampm {
+                            if hour == 0 {
+                                hour = 12;
+                            } else if hour > 12 {
+                                hour -= 12;
+                            }
+                        }
+                        text = format!("{text}{hour}");
+                    }
+                    TextToken::HourPadded => {
+                        let mut hour = hours as i32;
+                        if p.use_ampm {
+                            if hour == 0 {
+                                hour = 12;
+                            } else if hour > 12 {
+                                hour -= 12;
+                            }
+                        }
+                        text = format!("{text}{hour:02}");
+                    }
+                    TextToken::Second => {
+                        let second = seconds as i32;
+                        text = format!("{text}{second}");
+                    }
+                    TextToken::SecondPadded => {
+                        let second = seconds as i32;
+                        text = format!("{text}{second:02}");
+                    }
+                    TextToken::AMPM => {
+                        let ampm = if hours < 12.0 { "AM" } else { "PM" };
+                        text = format!("{text}{ampm}");
+                    }
+                    TextToken::Minute => {
+                        let minute = minutes as i32;
+                        text = format!("{text}{minute}");
+                    }
+                    TextToken::MinutePadded => {
+                        let minute = minutes as i32;
+                        text = format!("{text}{minute:02}");
+                    }
                 }
             }
             Formatted {
@@ -422,6 +568,13 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     TextToken::MonthLetter => {}
                     TextToken::YearShort => {}
                     TextToken::Year => {}
+                    TextToken::Hour => {}
+                    TextToken::HourPadded => {}
+                    TextToken::Minute => {}
+                    TextToken::MinutePadded => {}
+                    TextToken::Second => {}
+                    TextToken::SecondPadded => {}
+                    TextToken::AMPM => {}
                 }
             }
             Formatted {

base/src/formatter/lexer.rs

@@ -26,19 +26,23 @@ pub enum Token {
     Scientific,    // E+
     ScientificMinus, // E-
     General,       // General
-    // Dates
+    // Dates and time
     Day,            // d
     DayPadded,      // dd
     DayNameShort,   // ddd
     DayName,        // dddd+
-    Month,          // m
-    MonthPadded,    // mm
+    Month,          // m (or minute)
+    MonthPadded,    // mm (or minute padded)
     MonthNameShort, // mmm
     MonthName,      // mmmm or mmmmmm+
     MonthLetter,    // mmmmm
     YearShort,      // y or yy
     Year,           // yyy+
-    // TODO: Hours Minutes and Seconds
+    Hour,           // h
+    HourPadded,     // hh
+    Second,         // s
+    SecondPadded,   // ss
+    AMPM,           // AM/PM (or A/P)
     ILLEGAL,
     EOF,
 }
@@ -361,8 +365,8 @@ impl Lexer {
                         self.read_next_char();
                     }
                     match m {
-                        1 => Token::Month,
-                        2 => Token::MonthPadded,
+                        1 => Token::Month,       // (or minute)
+                        2 => Token::MonthPadded, // (or minute padded)
                         3 => Token::MonthNameShort,
                         4 => Token::MonthName,
                         5 => Token::MonthLetter,
@@ -381,6 +385,63 @@ impl Lexer {
                         Token::Year
                     }
                 }
+                'h' => {
+                    let mut h = 1;
+                    while let Some('h') = self.peek_char() {
+                        h += 1;
+                        self.read_next_char();
+                    }
+                    if h == 1 {
+                        Token::Hour
+                    } else if h == 2 {
+                        Token::HourPadded
+                    } else {
+                        self.set_error("Unexpected character after 'h'");
+                        Token::ILLEGAL
+                    }
+                }
+                's' => {
+                    let mut s = 1;
+                    while let Some('s') = self.peek_char() {
+                        s += 1;
+                        self.read_next_char();
+                    }
+                    if s == 1 {
+                        Token::Second
+                    } else if s == 2 {
+                        Token::SecondPadded
+                    } else {
+                        self.set_error("Unexpected character after 's'");
+                        Token::ILLEGAL
+                    }
+                }
+                'A' | 'a' => {
+                    if let Some('M') | Some('m') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'A'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('/') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AM'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('P') | Some('p') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AM'");
+                        return Token::ILLEGAL;
+                    }
+                    if let Some('M') | Some('m') = self.peek_char() {
+                        self.read_next_char();
+                    } else {
+                        self.set_error("Unexpected character after 'AMP'");
+                        return Token::ILLEGAL;
+                    }
+                    Token::AMPM
+                }
                 'g' | 'G' => {
                     for c in "eneral".chars() {
                         let cc = self.read_next_char();

base/src/formatter/parser.rs

@@ -27,6 +27,13 @@ pub enum TextToken {
     MonthLetter,
     YearShort,
     Year,
+    Hour,
+    HourPadded,
+    Minute,
+    MinutePadded,
+    Second,
+    SecondPadded,
+    AMPM,
 }
 pub struct NumberPart {
     pub color: Option<i32>,
@@ -45,6 +52,7 @@ pub struct NumberPart {
 
 pub struct DatePart {
     pub color: Option<i32>,
+    pub use_ampm: bool,
     pub tokens: Vec<TextToken>,
 }
 
@@ -101,6 +109,7 @@ impl Parser {
         let mut digit_count = 0;
         let mut precision = 0;
         let mut is_date = false;
+        let mut use_ampm = false;
         let mut is_number = false;
         let mut found_decimal_dot = false;
         let mut use_thousands = false;
@@ -116,6 +125,7 @@ impl Parser {
         let mut number = 'i';
         let mut index = 0;
         let mut currency = None;
+        let mut is_time = false;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -200,6 +210,9 @@ impl Parser {
                     index += 1;
                 }
                 Token::Literal(value) => {
+                    if value == ':' {
+                        is_time = true;
+                    }
                     tokens.push(TextToken::Literal(value));
                 }
                 Token::Text(value) => {
@@ -236,13 +249,23 @@ impl Parser {
                     tokens.push(TextToken::MonthName);
                 }
                 Token::Month => {
+                    if is_time {
+                        // minute
+                        tokens.push(TextToken::Minute);
+                    } else {
                         is_date = true;
                         tokens.push(TextToken::Month);
                     }
+                }
                 Token::MonthPadded => {
+                    if is_time {
+                        // minute padded
+                        tokens.push(TextToken::MinutePadded);
+                    } else {
                         is_date = true;
                         tokens.push(TextToken::MonthPadded);
                     }
+                }
                 Token::MonthLetter => {
                     is_date = true;
                     tokens.push(TextToken::MonthLetter);
@@ -255,6 +278,32 @@ impl Parser {
                     is_date = true;
                     tokens.push(TextToken::Year);
                 }
+                Token::Hour => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::Hour);
+                }
+                Token::HourPadded => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::HourPadded);
+                }
+                Token::Second => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::Second);
+                }
+                Token::SecondPadded => {
+                    is_date = true;
+                    is_time = true;
+                    tokens.push(TextToken::SecondPadded);
+                }
+
+                Token::AMPM => {
+                    is_date = true;
+                    use_ampm = true;
+                    tokens.push(TextToken::AMPM);
+                }
                 Token::Scientific => {
                     if !is_scientific {
                         index = 0;
@@ -282,7 +331,11 @@ impl Parser {
             if is_number {
                 return ParsePart::Error(ErrorPart {});
             }
-            ParsePart::Date(DatePart { color, tokens })
+            ParsePart::Date(DatePart {
+                color,
+                use_ampm,
+                tokens,
+            })
         } else {
             ParsePart::Number(NumberPart {
                 color,

base/src/formatter/test/mod.rs

@@ -1,2 +1,3 @@
 mod test_general;
 mod test_parse_formatted_number;
+mod test_time;

base/src/formatter/test/test_time.rs

@@ -0,0 +1,32 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    formatter::format::format_number,
+    locale::{get_locale, Locale},
+};
+
+fn get_default_locale() -> &'static Locale {
+    get_locale("en").unwrap()
+}
+
+#[test]
+fn simple_test() {
+    let locale = get_default_locale();
+    let format = "h:mm AM/PM";
+    let value = 16.001_423_611_111_11; // =1/86400 => 12:02 AM
+    let formatted = format_number(value, format, locale);
+    assert_eq!(formatted.text, "12:02 AM");
+}
+
+#[test]
+fn padded_vs_unpadded() {
+    let locale = get_default_locale();
+    let padded_format = "hh:mm:ss AM/PM";
+    let unpadded_format = "h:m:s AM/PM";
+    let value = 0.25351851851851853; // => 6:05:04 AM (21904/(24*60*60)) where 21904 = 6 * 3600 + 5*60 + 4
+    let formatted = format_number(value, padded_format, locale);
+    assert_eq!(formatted.text, "06:05:04 AM");
+
+    let formatted = format_number(value, unpadded_format, locale);
+    assert_eq!(formatted.text, "6:5:4 AM");
+}

base/src/functions/information.rs

@@ -1,6 +1,6 @@
 use crate::{
     calc_result::CalcResult,
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex, utils::number_to_column},
     model::{Model, ParsedDefinedName},
 };
 
@@ -320,4 +320,150 @@ impl Model {
             message: "Invalid name".to_string(),
         }
     }
+
+    pub(crate) fn fn_n(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let value = match self.evaluate_node_in_context(&args[0], cell) {
+            CalcResult::Number(n) => n,
+            CalcResult::String(_) => 0.0,
+            CalcResult::Boolean(f) => {
+                if f {
+                    1.0
+                } else {
+                    0.0
+                }
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
+            error @ CalcResult::Error { .. } => return error,
+            CalcResult::Range { .. } => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
+        };
+
+        CalcResult::Number(value)
+    }
+
+    pub(crate) fn fn_sheets(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count > 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        if arg_count == 1 {
+            return CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Sheets function with an argument is not implemented".to_string(),
+            };
+        }
+        let sheet_count = self.workbook.worksheets.len() as f64;
+        CalcResult::Number(sheet_count)
+    }
+
+    pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let arg_count = args.len();
+        if arg_count == 0 || arg_count > 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let reference = if arg_count == 2 {
+            match self.evaluate_node_with_reference(&args[1], cell) {
+                CalcResult::Range { left, right: _ } => {
+                    // we just take the left cell of the range
+                    left
+                }
+                _ => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Argument must be a reference".to_string(),
+                    }
+                }
+            }
+        } else {
+            CellReferenceIndex {
+                sheet: cell.sheet,
+                row: cell.row,
+                column: cell.column,
+            }
+        };
+        let info_type = match self.get_string(&args[0], cell) {
+            Ok(s) => s.to_uppercase(),
+            Err(e) => return e,
+        };
+        match info_type.as_str() {
+            "ADDRESS" => {
+                if reference.sheet != cell.sheet {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "References to other sheets not implemented".to_string(),
+                    };
+                }
+                let column = match number_to_column(reference.column) {
+                    Some(c) => c,
+                    None => {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Invalid column".to_string(),
+                        }
+                    }
+                };
+                let address = format!("${}${}", column, reference.row);
+                CalcResult::String(address)
+            }
+            "COL" => CalcResult::Number(reference.column as f64),
+            "COLOR" | "FILENAME" | "FORMAT" | "PARENTHESES" | "PREFIX" | "PROTECT" | "WIDTH" => {
+                CalcResult::Error {
+                    error: Error::VALUE,
+                    origin: cell,
+                    message: "info_type not implemented".to_string(),
+                }
+            }
+            "CONTENTS" => self.evaluate_cell(reference),
+            "ROW" => CalcResult::Number(reference.row as f64),
+            "TYPE" => {
+                let cell_type = match self.evaluate_cell(reference) {
+                    CalcResult::EmptyCell => "b",
+                    CalcResult::String(_) => "l",
+                    CalcResult::Number(_) => "v",
+                    CalcResult::Boolean(_) => "v",
+                    CalcResult::Error { .. } => "v",
+                    CalcResult::Range { .. } => "v",
+                    CalcResult::EmptyArg => "v",
+                    CalcResult::Array(_) => "v",
+                };
+                CalcResult::String(cell_type.to_string())
+            }
+            _ => CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "Invalid info_type".to_string(),
+            },
+        }
+    }
+
+    pub(crate) fn fn_info(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() || args.len() > 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        CalcResult::Error {
+            error: Error::NIMPL,
+            origin: cell,
+            message: "Info function not implemented".to_string(),
+        }
+    }
 }

base/src/functions/math_util.rs

@@ -0,0 +1,200 @@
+/// Parse Roman (classic or Excel variants) → number
+pub fn from_roman(s: &str) -> Result<u32, String> {
+    if s.is_empty() {
+        return Err("empty numeral".into());
+    }
+    fn val(c: char) -> Option<u32> {
+        Some(match c {
+            'I' => 1,
+            'V' => 5,
+            'X' => 10,
+            'L' => 50,
+            'C' => 100,
+            'D' => 500,
+            'M' => 1000,
+            _ => return None,
+        })
+    }
+
+    // Accept the union of subtractive pairs used by the tables above (Excel-compatible).
+    fn allowed_subtractive(a: char, b: char) -> bool {
+        matches!(
+            (a, b),
+            // classic:
+            ('I','V')|('I','X')|('X','L')|('X','C')|('C','D')|('C','M')
+            // Excel forms:
+            |('V','L')|('L','D')|('L','M') // VL, LD, LM
+            |('X','D')|('X','M')          // XD, XM
+            |('V','M')                    // VM
+            |('I','L')|('I','C')|('I','D')|('I','M') // IL, IC, ID, IM
+            |('V','D')|('V','C') // VD, VC
+        )
+    }
+
+    let chars: Vec<char> = s.chars().map(|c| c.to_ascii_uppercase()).collect();
+    let mut total = 0u32;
+    let mut i = 0usize;
+
+    // Repetition rules similar to classic Romans:
+    // V, L, D cannot repeat; I, X, C, M max 3 in a row.
+    let mut last_char: Option<char> = None;
+    let mut run_len = 0usize;
+
+    while i < chars.len() {
+        let c = chars[i];
+        let v = val(c).ok_or_else(|| format!("invalid character '{c}'"))?;
+
+        if Some(c) == last_char {
+            run_len += 1;
+            match c {
+                'V' | 'L' | 'D' => return Err(format!("invalid repetition of '{c}'")),
+                _ if run_len >= 3 => return Err(format!("invalid repetition of '{c}'")),
+                _ => {}
+            }
+        } else {
+            last_char = Some(c);
+            run_len = 0;
+        }
+
+        if i + 1 < chars.len() {
+            let c2 = chars[i + 1];
+            let v2 = val(c2).ok_or_else(|| format!("invalid character '{c2}'"))?;
+            if v < v2 {
+                if !allowed_subtractive(c, c2) {
+                    return Err(format!("invalid subtractive pair '{c}{c2}'"));
+                }
+                // Disallow stacked subtractives like IIV, XXL:
+                if run_len > 0 {
+                    return Err(format!("malformed numeral near position {i}"));
+                }
+                total += v2 - v;
+                i += 2;
+                last_char = None;
+                run_len = 0;
+                continue;
+            }
+        }
+
+        total += v;
+        i += 1;
+    }
+    Ok(total)
+}
+
+/// Classic Roman (strict) encoder used as a base for all forms.
+fn to_roman(mut n: u32) -> Result<String, String> {
+    if !(1..=3999).contains(&n) {
+        return Err("value out of range (must be 1..=3999)".into());
+    }
+
+    const MAP: &[(u32, &str)] = &[
+        (1000, "M"),
+        (900, "CM"),
+        (500, "D"),
+        (400, "CD"),
+        (100, "C"),
+        (90, "XC"),
+        (50, "L"),
+        (40, "XL"),
+        (10, "X"),
+        (9, "IX"),
+        (5, "V"),
+        (4, "IV"),
+        (1, "I"),
+    ];
+
+    let mut out = String::with_capacity(15);
+    for &(val, sym) in MAP {
+        while n >= val {
+            out.push_str(sym);
+            n -= val;
+        }
+        if n == 0 {
+            break;
+        }
+    }
+    Ok(out)
+}
+
+/// Excel/Google Sheets compatible ROMAN(number, [form]) encoder.
+/// `form`: 0..=4 (0=Classic, 4=Simplified).
+pub fn to_roman_with_form(n: u32, form: i32) -> Result<String, String> {
+    let mut s = to_roman(n)?;
+    if form == 0 {
+        return Ok(s);
+    }
+    if !(0..=4).contains(&form) {
+        return Err("form must be between 0 and 4".into());
+    }
+
+    // Base rules (apply for all f >= 1)
+    let base_rules: &[(&str, &str)] = &[
+        // C(D|M)XC -> L$1XL
+        ("CDXC", "LDXL"),
+        ("CMXC", "LMXL"),
+        // C(D|M)L -> L$1
+        ("CDL", "LD"),
+        ("CML", "LM"),
+        // X(L|C)IX -> V$1IV
+        ("XLIX", "VLIV"),
+        ("XCIX", "VCIV"),
+        // X(L|C)V -> V$1
+        ("XLV", "VL"),
+        ("XCV", "VC"),
+    ];
+
+    // Level 2 extra rules
+    let lvl2_rules: &[(&str, &str)] = &[
+        // V(L|C)IV -> I$1
+        ("VLIV", "IL"),
+        ("VCIV", "IC"),
+        // L(D|M)XL -> X$1
+        ("LDXL", "XD"),
+        ("LMXL", "XM"),
+        // L(D|M)VL -> X$1V
+        ("LDVL", "XDV"),
+        ("LMVL", "XMV"),
+        // L(D|M)IL -> X$1IX
+        ("LDIL", "XDIX"),
+        ("LMIL", "XMIX"),
+    ];
+
+    // Level 3 extra rules
+    let lvl3_rules: &[(&str, &str)] = &[
+        // X(D|M)V -> V$1
+        ("XDV", "VD"),
+        ("XMV", "VM"),
+        // X(D|M)IX -> V$1IV
+        ("XDIX", "VDIV"),
+        ("XMIX", "VMIV"),
+    ];
+
+    // Level 4 extra rules
+    let lvl4_rules: &[(&str, &str)] = &[
+        // V(D|M)IV -> I$1
+        ("VDIV", "ID"),
+        ("VMIV", "IM"),
+    ];
+
+    // Helper to apply a batch of (from -> to) globally, in order.
+    fn apply_rules(mut t: String, rules: &[(&str, &str)]) -> String {
+        for (from, to) in rules {
+            if t.contains(from) {
+                t = t.replace(from, to);
+            }
+        }
+        t
+    }
+
+    s = apply_rules(s, base_rules);
+    if form >= 2 {
+        s = apply_rules(s, lvl2_rules);
+    }
+    if form >= 3 {
+        s = apply_rules(s, lvl3_rules);
+    }
+    if form >= 4 {
+        s = apply_rules(s, lvl4_rules);
+    }
+    Ok(s)
+}

base/src/functions/mod.rs

@@ -16,6 +16,7 @@ mod information;
 mod logical;
 mod lookup_and_reference;
 mod macros;
+mod math_util;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -76,6 +77,43 @@ pub enum Function {
     Sumifs,
     Tan,
     Tanh,
+    Acot,
+    Acoth,
+    Cot,
+    Coth,
+    Csc,
+    Csch,
+    Sec,
+    Sech,
+    Exp,
+    Fact,
+    Factdouble,
+    Sign,
+    Radians,
+    Degrees,
+    Int,
+    Even,
+    Odd,
+    Ceiling,
+    CeilingMath,
+    CeilingPrecise,
+    Floor,
+    FloorMath,
+    FloorPrecise,
+    IsoCeiling,
+    Mod,
+    Quotient,
+    Mround,
+    Trunc,
+    Gcd,
+    Lcm,
+    Base,
+    Decimal,
+    Roman,
+    Arabic,
+    Combin,
+    Combina,
+    Sumsq,
 
     // Information
     ErrorType,
@@ -96,6 +134,11 @@ pub enum Function {
     Sheet,
     Type,
 
+    Sheets,
+    N,
+    Cell,
+    Info,
+
     // Lookup and reference
     Hlookup,
     Index,
@@ -148,15 +191,40 @@ pub enum Function {
 
     // Date and time
     Date,
+    Datedif,
+    Datevalue,
     Day,
     Edate,
     Eomonth,
     Month,
+    Time,
+    Timevalue,
+    Hour,
+    Minute,
+    Second,
     Now,
     Today,
     Year,
+    Networkdays,
+    NetworkdaysIntl,
+    Days,
+    Days360,
+    Weekday,
+    Weeknum,
+    Workday,
+    WorkdayIntl,
+    Yearfrac,
+    Isoweeknum,
 
     // Financial
+    Accrint,
+    Accrintm,
+    Coupdaybs,
+    Coupdays,
+    Coupdaysnc,
+    Coupncd,
+    Coupnum,
+    Couppcd,
     Cumipmt,
     Cumprinc,
     Db,
@@ -165,6 +233,7 @@ pub enum Function {
     Dollarfr,
     Effect,
     Fv,
+    Fvschedule,
     Ipmt,
     Irr,
     Ispmt,
@@ -172,9 +241,12 @@ pub enum Function {
     Nominal,
     Nper,
     Npv,
+    Duration,
+    Mduration,
     Pduration,
     Pmt,
     Ppmt,
+    Price,
     Pv,
     Rate,
     Rri,
@@ -183,8 +255,16 @@ pub enum Function {
     Tbilleq,
     Tbillprice,
     Tbillyield,
+    Pricedisc,
+    Pricemat,
+    Yielddisc,
+    Yieldmat,
+    Disc,
+    Received,
+    Intrate,
     Xirr,
     Xnpv,
+    Yield,
 
     // Engineering: Bessel and transcendental functions
     Besseli,
@@ -253,7 +333,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 198> {
+    pub fn into_iter() -> IntoIter<Function, 276> {
         [
             Function::And,
             Function::False,
@@ -286,12 +366,44 @@ impl Function {
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
+            Function::Acot,
+            Function::Acoth,
+            Function::Cot,
+            Function::Coth,
+            Function::Csc,
+            Function::Csch,
+            Function::Sec,
+            Function::Sech,
             Function::Power,
+            Function::Exp,
+            Function::Fact,
+            Function::Factdouble,
+            Function::Sign,
+            Function::Int,
+            Function::Even,
+            Function::Odd,
+            Function::Ceiling,
+            Function::CeilingMath,
+            Function::CeilingPrecise,
+            Function::Floor,
+            Function::FloorMath,
+            Function::FloorPrecise,
+            Function::IsoCeiling,
+            Function::Mod,
+            Function::Quotient,
+            Function::Mround,
+            Function::Trunc,
+            Function::Gcd,
+            Function::Lcm,
+            Function::Base,
+            Function::Decimal,
             Function::Max,
             Function::Min,
             Function::Product,
             Function::Rand,
             Function::Randbetween,
+            Function::Radians,
+            Function::Degrees,
             Function::Round,
             Function::Rounddown,
             Function::Roundup,
@@ -362,21 +474,43 @@ impl Function {
             Function::Month,
             Function::Eomonth,
             Function::Date,
+            Function::Datedif,
+            Function::Datevalue,
             Function::Edate,
+            Function::Networkdays,
+            Function::NetworkdaysIntl,
+            Function::Time,
+            Function::Timevalue,
+            Function::Hour,
+            Function::Minute,
+            Function::Second,
             Function::Today,
             Function::Now,
+            Function::Days,
+            Function::Days360,
+            Function::Weekday,
+            Function::Weeknum,
+            Function::Workday,
+            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,
@@ -388,10 +522,25 @@ impl Function {
             Function::Syd,
             Function::Nominal,
             Function::Effect,
+            Function::Duration,
+            Function::Mduration,
             Function::Pduration,
+            Function::Coupdaybs,
+            Function::Coupdays,
+            Function::Coupdaysnc,
+            Function::Coupncd,
+            Function::Coupnum,
+            Function::Couppcd,
             Function::Tbillyield,
             Function::Tbillprice,
             Function::Tbilleq,
+            Function::Pricedisc,
+            Function::Pricemat,
+            Function::Yielddisc,
+            Function::Yieldmat,
+            Function::Disc,
+            Function::Received,
+            Function::Intrate,
             Function::Dollarde,
             Function::Dollarfr,
             Function::Ddb,
@@ -453,6 +602,15 @@ impl Function {
             Function::Delta,
             Function::Gestep,
             Function::Subtotal,
+            Function::Roman,
+            Function::Arabic,
+            Function::Combin,
+            Function::Combina,
+            Function::Sumsq,
+            Function::N,
+            Function::Cell,
+            Function::Info,
+            Function::Sheets,
         ]
         .into_iter()
     }
@@ -494,6 +652,19 @@ impl Function {
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
             Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
+            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
+            Function::Ceiling => "_xlfn.CEILING".to_string(),
+            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
+            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
+            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
+            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
+            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
+            Function::Base => "_xlfn.BASE".to_string(),
+            Function::Decimal => "_xlfn.DECIMAL".to_string(),
+            Function::Arabic => "_xlfn.ARABIC".to_string(),
+            Function::Combina => "_xlfn.COMBINA".to_string(),
+            Function::Sheets => "_xlfn.SHEETS".to_string(),
+
             _ => self.to_string(),
         }
     }
@@ -516,34 +687,61 @@ impl Function {
             "SWITCH" | "_XLFN.SWITCH" => Some(Function::Switch),
             "TRUE" => Some(Function::True),
             "XOR" | "_XLFN.XOR" => Some(Function::Xor),
-
             "SIN" => Some(Function::Sin),
             "COS" => Some(Function::Cos),
             "TAN" => Some(Function::Tan),
-
             "ASIN" => Some(Function::Asin),
             "ACOS" => Some(Function::Acos),
             "ATAN" => Some(Function::Atan),
-
             "SINH" => Some(Function::Sinh),
             "COSH" => Some(Function::Cosh),
             "TANH" => Some(Function::Tanh),
-
             "ASINH" => Some(Function::Asinh),
             "ACOSH" => Some(Function::Acosh),
             "ATANH" => Some(Function::Atanh),
-
+            "ACOT" => Some(Function::Acot),
+            "COTH" => Some(Function::Coth),
+            "COT" => Some(Function::Cot),
+            "CSC" => Some(Function::Csc),
+            "CSCH" => Some(Function::Csch),
+            "SEC" => Some(Function::Sec),
+            "SECH" => Some(Function::Sech),
+            "ACOTH" => Some(Function::Acoth),
+            "FACT" => Some(Function::Fact),
+            "FACTDOUBLE" => Some(Function::Factdouble),
+            "EXP" => Some(Function::Exp),
+            "SIGN" => Some(Function::Sign),
+            "RADIANS" => Some(Function::Radians),
+            "DEGREES" => Some(Function::Degrees),
+            "INT" => Some(Function::Int),
+            "EVEN" => Some(Function::Even),
+            "ODD" => Some(Function::Odd),
+            "CEILING" | "_XLFN.CEILING" => Some(Function::Ceiling),
+            "CEILING.MATH" | "_XLFN.CEILING.MATH" => Some(Function::CeilingMath),
+            "CEILING.PRECISE" | "_XLFN.CEILING.PRECISE" => Some(Function::CeilingPrecise),
+            "FLOOR" => Some(Function::Floor),
+            "FLOOR.MATH" | "_XLFN.FLOOR.MATH" => Some(Function::FloorMath),
+            "FLOOR.PRECISE" | "_XLFN.FLOOR.PRECISE" => Some(Function::FloorPrecise),
+            "ISO.CEILING" | "_XLFN.ISO.CEILING" => Some(Function::IsoCeiling),
+            "MOD" => Some(Function::Mod),
+            "QUOTIENT" => Some(Function::Quotient),
+            "MROUND" => Some(Function::Mround),
+            "TRUNC" => Some(Function::Trunc),
+            "GCD" => Some(Function::Gcd),
+            "LCM" => Some(Function::Lcm),
+            "BASE" | "_XLFN.BASE" => Some(Function::Base),
+            "DECIMAL" | "_XLFN.DECIMAL" => Some(Function::Decimal),
+            "ROMAN" => Some(Function::Roman),
+            "ARABIC" | "_XLFN.ARABIC" => Some(Function::Arabic),
             "PI" => Some(Function::Pi),
             "ABS" => Some(Function::Abs),
             "SQRT" => Some(Function::Sqrt),
             "SQRTPI" => Some(Function::Sqrtpi),
             "POWER" => Some(Function::Power),
             "ATAN2" => Some(Function::Atan2),
-
             "LN" => Some(Function::Ln),
             "LOG" => Some(Function::Log),
             "LOG10" => Some(Function::Log10),
-
             "MAX" => Some(Function::Max),
             "MIN" => Some(Function::Min),
             "PRODUCT" => Some(Function::Product),
@@ -555,6 +753,9 @@ impl Function {
             "SUM" => Some(Function::Sum),
             "SUMIF" => Some(Function::Sumif),
             "SUMIFS" => Some(Function::Sumifs),
+            "COMBIN" => Some(Function::Combin),
+            "COMBINA" | "_XLFN.COMBINA" => Some(Function::Combina),
+            "SUMSQ" => Some(Function::Sumsq),
 
             // Lookup and Reference
             "CHOOSE" => Some(Function::Choose),
@@ -631,19 +832,41 @@ impl Function {
             "EOMONTH" => Some(Function::Eomonth),
             "MONTH" => Some(Function::Month),
             "DATE" => Some(Function::Date),
+            "DATEDIF" => Some(Function::Datedif),
+            "DATEVALUE" => Some(Function::Datevalue),
             "EDATE" => Some(Function::Edate),
+            "NETWORKDAYS" => Some(Function::Networkdays),
+            "NETWORKDAYS.INTL" => Some(Function::NetworkdaysIntl),
+            "TIME" => Some(Function::Time),
+            "TIMEVALUE" => Some(Function::Timevalue),
+            "HOUR" => Some(Function::Hour),
+            "MINUTE" => Some(Function::Minute),
+            "SECOND" => Some(Function::Second),
             "TODAY" => Some(Function::Today),
             "NOW" => Some(Function::Now),
+            "DAYS" | "_XLFN.DAYS" => Some(Function::Days),
+            "DAYS360" => Some(Function::Days360),
+            "WEEKDAY" => Some(Function::Weekday),
+            "WEEKNUM" => Some(Function::Weeknum),
+            "WORKDAY" => Some(Function::Workday),
+            "WORKDAY.INTL" => Some(Function::WorkdayIntl),
+            "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),
@@ -654,11 +877,27 @@ impl Function {
             "SYD" => Some(Function::Syd),
             "NOMINAL" => Some(Function::Nominal),
             "EFFECT" => Some(Function::Effect),
+            "DURATION" => Some(Function::Duration),
+            "MDURATION" => Some(Function::Mduration),
             "PDURATION" | "_XLFN.PDURATION" => Some(Function::Pduration),
 
+            "COUPDAYBS" => Some(Function::Coupdaybs),
+            "COUPDAYS" => Some(Function::Coupdays),
+            "COUPDAYSNC" => Some(Function::Coupdaysnc),
+            "COUPNCD" => Some(Function::Coupncd),
+            "COUPNUM" => Some(Function::Coupnum),
+            "COUPPCD" => Some(Function::Couppcd),
+
             "TBILLYIELD" => Some(Function::Tbillyield),
             "TBILLPRICE" => Some(Function::Tbillprice),
             "TBILLEQ" => Some(Function::Tbilleq),
+            "PRICEDISC" => Some(Function::Pricedisc),
+            "PRICEMAT" => Some(Function::Pricemat),
+            "YIELDDISC" => Some(Function::Yielddisc),
+            "YIELDMAT" => Some(Function::Yieldmat),
+            "DISC" => Some(Function::Disc),
+            "RECEIVED" => Some(Function::Received),
+            "INTRATE" => Some(Function::Intrate),
 
             "DOLLARDE" => Some(Function::Dollarde),
             "DOLLARFR" => Some(Function::Dollarfr),
@@ -725,6 +964,12 @@ impl Function {
             "GESTEP" => Some(Function::Gestep),
 
             "SUBTOTAL" => Some(Function::Subtotal),
+
+            "N" => Some(Function::N),
+            "CELL" => Some(Function::Cell),
+            "INFO" => Some(Function::Info),
+            "SHEETS" | "_XLFN.SHEETS" => Some(Function::Sheets),
+
             _ => None,
         }
     }
@@ -759,6 +1004,14 @@ impl fmt::Display for Function {
             Function::Asinh => write!(f, "ASINH"),
             Function::Acosh => write!(f, "ACOSH"),
             Function::Atanh => write!(f, "ATANH"),
+            Function::Acot => write!(f, "ACOT"),
+            Function::Acoth => write!(f, "ACOTH"),
+            Function::Cot => write!(f, "COT"),
+            Function::Coth => write!(f, "COTH"),
+            Function::Csc => write!(f, "CSC"),
+            Function::Csch => write!(f, "CSCH"),
+            Function::Sec => write!(f, "SEC"),
+            Function::Sech => write!(f, "SECH"),
             Function::Abs => write!(f, "ABS"),
             Function::Pi => write!(f, "PI"),
             Function::Sqrt => write!(f, "SQRT"),
@@ -823,7 +1076,6 @@ impl fmt::Display for Function {
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
-
             Function::Average => write!(f, "AVERAGE"),
             Function::Averagea => write!(f, "AVERAGEA"),
             Function::Averageif => write!(f, "AVERAGEIF"),
@@ -841,21 +1093,43 @@ impl fmt::Display for Function {
             Function::Month => write!(f, "MONTH"),
             Function::Eomonth => write!(f, "EOMONTH"),
             Function::Date => write!(f, "DATE"),
+            Function::Datedif => write!(f, "DATEDIF"),
+            Function::Datevalue => write!(f, "DATEVALUE"),
             Function::Edate => write!(f, "EDATE"),
+            Function::Networkdays => write!(f, "NETWORKDAYS"),
+            Function::NetworkdaysIntl => write!(f, "NETWORKDAYS.INTL"),
+            Function::Time => write!(f, "TIME"),
+            Function::Timevalue => write!(f, "TIMEVALUE"),
+            Function::Hour => write!(f, "HOUR"),
+            Function::Minute => write!(f, "MINUTE"),
+            Function::Second => write!(f, "SECOND"),
             Function::Today => write!(f, "TODAY"),
             Function::Now => write!(f, "NOW"),
+            Function::Days => write!(f, "DAYS"),
+            Function::Days360 => write!(f, "DAYS360"),
+            Function::Weekday => write!(f, "WEEKDAY"),
+            Function::Weeknum => write!(f, "WEEKNUM"),
+            Function::Workday => write!(f, "WORKDAY"),
+            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"),
@@ -867,10 +1141,25 @@ impl fmt::Display for Function {
             Function::Syd => write!(f, "SYD"),
             Function::Nominal => write!(f, "NOMINAL"),
             Function::Effect => write!(f, "EFFECT"),
+            Function::Duration => write!(f, "DURATION"),
+            Function::Mduration => write!(f, "MDURATION"),
             Function::Pduration => write!(f, "PDURATION"),
+            Function::Coupdaybs => write!(f, "COUPDAYBS"),
+            Function::Coupdays => write!(f, "COUPDAYS"),
+            Function::Coupdaysnc => write!(f, "COUPDAYSNC"),
+            Function::Coupncd => write!(f, "COUPNCD"),
+            Function::Coupnum => write!(f, "COUPNUM"),
+            Function::Couppcd => write!(f, "COUPPCD"),
             Function::Tbillyield => write!(f, "TBILLYIELD"),
             Function::Tbillprice => write!(f, "TBILLPRICE"),
             Function::Tbilleq => write!(f, "TBILLEQ"),
+            Function::Pricedisc => write!(f, "PRICEDISC"),
+            Function::Pricemat => write!(f, "PRICEMAT"),
+            Function::Yielddisc => write!(f, "YIELDDISC"),
+            Function::Yieldmat => write!(f, "YIELDMAT"),
+            Function::Disc => write!(f, "DISC"),
+            Function::Received => write!(f, "RECEIVED"),
+            Function::Intrate => write!(f, "INTRATE"),
             Function::Dollarde => write!(f, "DOLLARDE"),
             Function::Dollarfr => write!(f, "DOLLARFR"),
             Function::Ddb => write!(f, "DDB"),
@@ -931,8 +1220,41 @@ impl fmt::Display for Function {
             Function::Convert => write!(f, "CONVERT"),
             Function::Delta => write!(f, "DELTA"),
             Function::Gestep => write!(f, "GESTEP"),
-
             Function::Subtotal => write!(f, "SUBTOTAL"),
+            Function::Exp => write!(f, "EXP"),
+            Function::Fact => write!(f, "FACT"),
+            Function::Factdouble => write!(f, "FACTDOUBLE"),
+            Function::Sign => write!(f, "SIGN"),
+            Function::Radians => write!(f, "RADIANS"),
+            Function::Degrees => write!(f, "DEGREES"),
+            Function::Int => write!(f, "INT"),
+            Function::Even => write!(f, "EVEN"),
+            Function::Odd => write!(f, "ODD"),
+            Function::Ceiling => write!(f, "CEILING"),
+            Function::CeilingMath => write!(f, "CEILING.MATH"),
+            Function::CeilingPrecise => write!(f, "CEILING.PRECISE"),
+            Function::Floor => write!(f, "FLOOR"),
+            Function::FloorMath => write!(f, "FLOOR.MATH"),
+            Function::FloorPrecise => write!(f, "FLOOR.PRECISE"),
+            Function::IsoCeiling => write!(f, "ISO.CEILING"),
+            Function::Mod => write!(f, "MOD"),
+            Function::Quotient => write!(f, "QUOTIENT"),
+            Function::Mround => write!(f, "MROUND"),
+            Function::Trunc => write!(f, "TRUNC"),
+            Function::Gcd => write!(f, "GCD"),
+            Function::Lcm => write!(f, "LCM"),
+            Function::Base => write!(f, "BASE"),
+            Function::Decimal => write!(f, "DECIMAL"),
+            Function::Roman => write!(f, "ROMAN"),
+            Function::Arabic => write!(f, "ARABIC"),
+            Function::Combin => write!(f, "COMBIN"),
+            Function::Combina => write!(f, "COMBINA"),
+            Function::Sumsq => write!(f, "SUMSQ"),
+
+            Function::N => write!(f, "N"),
+            Function::Cell => write!(f, "CELL"),
+            Function::Info => write!(f, "INFO"),
+            Function::Sheets => write!(f, "SHEETS"),
         }
     }
 }
@@ -961,7 +1283,6 @@ impl Model {
         cell: CellReferenceIndex,
     ) -> CalcResult {
         match kind {
-            // Logical
             Function::And => self.fn_and(args, cell),
             Function::False => self.fn_false(args, cell),
             Function::If => self.fn_if(args, cell),
@@ -973,34 +1294,27 @@ impl Model {
             Function::Switch => self.fn_switch(args, cell),
             Function::True => self.fn_true(args, cell),
             Function::Xor => self.fn_xor(args, cell),
-            // Math and trigonometry
             Function::Log => self.fn_log(args, cell),
             Function::Log10 => self.fn_log10(args, cell),
             Function::Ln => self.fn_ln(args, cell),
             Function::Sin => self.fn_sin(args, cell),
             Function::Cos => self.fn_cos(args, cell),
             Function::Tan => self.fn_tan(args, cell),
-
             Function::Asin => self.fn_asin(args, cell),
             Function::Acos => self.fn_acos(args, cell),
             Function::Atan => self.fn_atan(args, cell),
-
             Function::Sinh => self.fn_sinh(args, cell),
             Function::Cosh => self.fn_cosh(args, cell),
             Function::Tanh => self.fn_tanh(args, cell),
-
             Function::Asinh => self.fn_asinh(args, cell),
             Function::Acosh => self.fn_acosh(args, cell),
             Function::Atanh => self.fn_atanh(args, cell),
-
             Function::Pi => self.fn_pi(args, cell),
             Function::Abs => self.fn_abs(args, cell),
-
             Function::Sqrt => self.fn_sqrt(args, cell),
             Function::Sqrtpi => self.fn_sqrtpi(args, cell),
             Function::Atan2 => self.fn_atan2(args, cell),
             Function::Power => self.fn_power(args, cell),
-
             Function::Max => self.fn_max(args, cell),
             Function::Min => self.fn_min(args, cell),
             Function::Product => self.fn_product(args, cell),
@@ -1012,8 +1326,6 @@ impl Model {
             Function::Sum => self.fn_sum(args, cell),
             Function::Sumif => self.fn_sumif(args, cell),
             Function::Sumifs => self.fn_sumifs(args, cell),
-
-            // Lookup and Reference
             Function::Choose => self.fn_choose(args, cell),
             Function::Column => self.fn_column(args, cell),
             Function::Columns => self.fn_columns(args, cell),
@@ -1027,7 +1339,6 @@ impl Model {
             Function::Rows => self.fn_rows(args, cell),
             Function::Vlookup => self.fn_vlookup(args, cell),
             Function::Xlookup => self.fn_xlookup(args, cell),
-            // Text
             Function::Concatenate => self.fn_concatenate(args, cell),
             Function::Exact => self.fn_exact(args, cell),
             Function::Value => self.fn_value(args, cell),
@@ -1045,7 +1356,6 @@ impl Model {
             Function::Trim => self.fn_trim(args, cell),
             Function::Unicode => self.fn_unicode(args, cell),
             Function::Upper => self.fn_upper(args, cell),
-            // Information
             Function::Isnumber => self.fn_isnumber(args, cell),
             Function::Isnontext => self.fn_isnontext(args, cell),
             Function::Istext => self.fn_istext(args, cell),
@@ -1063,7 +1373,6 @@ impl Model {
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
-            // Statistical
             Function::Average => self.fn_average(args, cell),
             Function::Averagea => self.fn_averagea(args, cell),
             Function::Averageif => self.fn_averageif(args, cell),
@@ -1076,28 +1385,49 @@ impl Model {
             Function::Maxifs => self.fn_maxifs(args, cell),
             Function::Minifs => self.fn_minifs(args, cell),
             Function::Geomean => self.fn_geomean(args, cell),
-            // Date and Time
             Function::Year => self.fn_year(args, cell),
             Function::Day => self.fn_day(args, cell),
             Function::Eomonth => self.fn_eomonth(args, cell),
             Function::Month => self.fn_month(args, cell),
             Function::Date => self.fn_date(args, cell),
+            Function::Datedif => self.fn_datedif(args, cell),
+            Function::Datevalue => self.fn_datevalue(args, cell),
             Function::Edate => self.fn_edate(args, cell),
+            Function::Networkdays => self.fn_networkdays(args, cell),
+            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
+            Function::Time => self.fn_time(args, cell),
+            Function::Timevalue => self.fn_timevalue(args, cell),
+            Function::Hour => self.fn_hour(args, cell),
+            Function::Minute => self.fn_minute(args, cell),
+            Function::Second => self.fn_second(args, cell),
             Function::Today => self.fn_today(args, cell),
             Function::Now => self.fn_now(args, cell),
+            Function::Days => self.fn_days(args, cell),
+            Function::Days360 => self.fn_days360(args, cell),
+            Function::Weekday => self.fn_weekday(args, cell),
+            Function::Weeknum => self.fn_weeknum(args, cell),
+            Function::Workday => self.fn_workday(args, cell),
+            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),
@@ -1109,17 +1439,31 @@ 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),
             Function::Db => self.fn_db(args, cell),
             Function::Cumprinc => self.fn_cumprinc(args, cell),
             Function::Cumipmt => self.fn_cumipmt(args, cell),
-            // Engineering
             Function::Besseli => self.fn_besseli(args, cell),
             Function::Besselj => self.fn_besselj(args, cell),
             Function::Besselk => self.fn_besselk(args, cell),
@@ -1174,8 +1518,48 @@ impl Model {
             Function::Convert => self.fn_convert(args, cell),
             Function::Delta => self.fn_delta(args, cell),
             Function::Gestep => self.fn_gestep(args, cell),
-
             Function::Subtotal => self.fn_subtotal(args, cell),
+            Function::Acot => self.fn_acot(args, cell),
+            Function::Acoth => self.fn_acoth(args, cell),
+            Function::Cot => self.fn_cot(args, cell),
+            Function::Coth => self.fn_coth(args, cell),
+            Function::Csc => self.fn_csc(args, cell),
+            Function::Csch => self.fn_csch(args, cell),
+            Function::Sec => self.fn_sec(args, cell),
+            Function::Sech => self.fn_sech(args, cell),
+            Function::Exp => self.fn_exp(args, cell),
+            Function::Fact => self.fn_fact(args, cell),
+            Function::Factdouble => self.fn_factdouble(args, cell),
+            Function::Sign => self.fn_sign(args, cell),
+            Function::Radians => self.fn_radians(args, cell),
+            Function::Degrees => self.fn_degrees(args, cell),
+            Function::Int => self.fn_int(args, cell),
+            Function::Even => self.fn_even(args, cell),
+            Function::Odd => self.fn_odd(args, cell),
+            Function::Ceiling => self.fn_ceiling(args, cell),
+            Function::CeilingMath => self.fn_ceiling_math(args, cell),
+            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
+            Function::Floor => self.fn_floor(args, cell),
+            Function::FloorMath => self.fn_floor_math(args, cell),
+            Function::FloorPrecise => self.fn_floor_precise(args, cell),
+            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
+            Function::Mod => self.fn_mod(args, cell),
+            Function::Quotient => self.fn_quotient(args, cell),
+            Function::Mround => self.fn_mround(args, cell),
+            Function::Trunc => self.fn_trunc(args, cell),
+            Function::Gcd => self.fn_gcd(args, cell),
+            Function::Lcm => self.fn_lcm(args, cell),
+            Function::Base => self.fn_base(args, cell),
+            Function::Decimal => self.fn_decimal(args, cell),
+            Function::Roman => self.fn_roman(args, cell),
+            Function::Arabic => self.fn_arabic(args, cell),
+            Function::Combin => self.fn_combin(args, cell),
+            Function::Combina => self.fn_combina(args, cell),
+            Function::Sumsq => self.fn_sumsq(args, cell),
+            Function::N => self.fn_n(args, cell),
+            Function::Cell => self.fn_cell(args, cell),
+            Function::Info => self.fn_info(args, cell),
+            Function::Sheets => self.fn_sheets(args, cell),
         }
     }
 }

base/src/test/mod.rs

@@ -7,15 +7,23 @@ mod test_column_width;
 mod test_criteria;
 mod test_currency;
 mod test_date_and_time;
+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;
@@ -27,6 +35,7 @@ mod test_fn_sum;
 mod test_fn_sumifs;
 mod test_fn_textbefore;
 mod test_fn_textjoin;
+mod test_fn_time;
 mod test_fn_unicode;
 mod test_frozen_rows_columns;
 mod test_general;
@@ -43,8 +52,11 @@ mod test_sheets;
 mod test_styles;
 mod test_trigonometric;
 mod test_true_false;
+mod test_weekday_return_types;
+mod test_weeknum_return_types;
 mod test_workbook;
 mod test_worksheet;
+mod test_yearfrac_basis;
 pub(crate) mod util;
 
 mod engineering;
@@ -56,17 +68,21 @@ mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;
 mod test_fn_round;
+mod test_fn_fvschedule;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_geomean;
 mod test_get_cell_content;
 mod test_implicit_intersection;
 mod test_issue_155;
+mod test_issue_483;
 mod test_ln;
 mod test_log;
 mod test_log10;
+mod test_networkdays;
 mod test_percentage;
 mod test_set_functions_error_handling;
+mod test_sheet_names;
 mod test_today;
 mod test_types;
 mod user_model;

base/src/test/test_date_and_time.rs

@@ -6,6 +6,11 @@
 /// We can also enter examples that illustrate/document a part of the function
 use crate::{cell::CellValue, test::util::new_empty_model};
 
+// Excel uses a serial date system where Jan 1, 1900 = 1 (though it treats 1900 as a leap year)
+// Most test dates are documented inline, but we define boundary values here:
+const EXCEL_MAX_DATE: f64 = 2958465.0; // Dec 31, 9999 - used in boundary tests
+const EXCEL_INVALID_DATE: f64 = 2958466.0; // One day past max - used in error tests
+
 #[test]
 fn test_fn_date_arguments() {
     let mut model = new_empty_model();
@@ -216,3 +221,382 @@ fn test_date_early_dates() {
         Ok(CellValue::Number(61.0))
     );
 }
+#[test]
+fn test_days_function() {
+    let mut model = new_empty_model();
+
+    // Basic functionality
+    model._set("A1", "=DAYS(44570,44561)");
+    model._set("A2", "=DAYS(44561,44570)"); // Reversed order
+    model._set("A3", "=DAYS(44561,44561)");
+
+    // Edge cases
+    model._set("A4", "=DAYS(1,2)"); // Early dates
+    model._set(
+        "A5",
+        &format!("=DAYS({},{})", EXCEL_MAX_DATE, EXCEL_MAX_DATE - 1.0),
+    ); // Near max date
+
+    // Error cases - wrong argument count
+    model._set("A6", "=DAYS()");
+    model._set("A7", "=DAYS(44561)");
+    model._set("A8", "=DAYS(44561,44570,1)");
+
+    // Error cases - invalid dates
+    model._set("A9", "=DAYS(-1,44561)");
+    model._set("A10", &format!("=DAYS(44561,{EXCEL_INVALID_DATE})"));
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"9");
+    assert_eq!(model._get_text("A2"), *"-9");
+    assert_eq!(model._get_text("A3"), *"0");
+    assert_eq!(model._get_text("A4"), *"-1"); // DAYS(1,2) = 1-2 = -1
+    assert_eq!(model._get_text("A5"), *"1");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+    assert_eq!(model._get_text("A9"), *"#NUM!");
+    assert_eq!(model._get_text("A10"), *"#NUM!");
+}
+
+#[test]
+fn test_days360_function() {
+    let mut model = new_empty_model();
+
+    // Basic functionality with different basis values
+    model._set("A1", "=DAYS360(44196,44560)"); // Default basis (US 30/360)
+    model._set("A2", "=DAYS360(44196,44560,FALSE)"); // US 30/360 explicitly
+    model._set("A3", "=DAYS360(44196,44560,TRUE)"); // European 30/360
+
+    // Same date
+    model._set("A4", "=DAYS360(44561,44561)");
+    model._set("A5", "=DAYS360(44561,44561,TRUE)");
+
+    // Reverse order (negative result)
+    model._set("A6", "=DAYS360(44560,44196)");
+    model._set("A7", "=DAYS360(44560,44196,TRUE)");
+
+    // Edge cases
+    model._set("A8", "=DAYS360(1,2)");
+    model._set("A9", "=DAYS360(1,2,FALSE)");
+
+    // Error cases - wrong argument count
+    model._set("A10", "=DAYS360()");
+    model._set("A11", "=DAYS360(44561)");
+    model._set("A12", "=DAYS360(44561,44570,TRUE,1)");
+
+    // Error cases - invalid dates
+    model._set("A13", "=DAYS360(-1,44561)");
+    model._set("A14", &format!("=DAYS360(44561,{EXCEL_INVALID_DATE})"));
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"360");
+    assert_eq!(model._get_text("A2"), *"360");
+    assert_eq!(model._get_text("A3"), *"360");
+    assert_eq!(model._get_text("A4"), *"0");
+    assert_eq!(model._get_text("A5"), *"0");
+    assert_eq!(model._get_text("A6"), *"-360");
+    assert_eq!(model._get_text("A7"), *"-360");
+    assert_eq!(model._get_text("A8"), *"1");
+    assert_eq!(model._get_text("A9"), *"1");
+    assert_eq!(model._get_text("A10"), *"#ERROR!");
+    assert_eq!(model._get_text("A11"), *"#ERROR!");
+    assert_eq!(model._get_text("A12"), *"#ERROR!");
+    assert_eq!(model._get_text("A13"), *"#NUM!");
+    assert_eq!(model._get_text("A14"), *"#NUM!");
+}
+
+#[test]
+fn test_weekday_function() {
+    let mut model = new_empty_model();
+
+    // Test return_type parameter variations with one known date (Friday 44561)
+    model._set("A1", "=WEEKDAY(44561)"); // Default: Sun=1, Fri=6
+    model._set("A2", "=WEEKDAY(44561,2)"); // Mon=1, Fri=5
+    model._set("A3", "=WEEKDAY(44561,3)"); // Mon=0, Fri=4
+
+    // Test boundary days (Sun/Mon) to verify return_type logic
+    model._set("A4", "=WEEKDAY(44556,1)"); // Sunday: should be 1
+    model._set("A5", "=WEEKDAY(44556,2)"); // Sunday: should be 7
+    model._set("A6", "=WEEKDAY(44557,2)"); // Monday: should be 1
+
+    // Error cases
+    model._set("A7", "=WEEKDAY()"); // Wrong arg count
+    model._set("A8", "=WEEKDAY(44561,0)"); // Invalid return_type
+    model._set("A9", "=WEEKDAY(-1)"); // Invalid date
+
+    model.evaluate();
+
+    // Core functionality
+    assert_eq!(model._get_text("A1"), *"6"); // Friday default
+    assert_eq!(model._get_text("A2"), *"5"); // Friday Mon=1
+    assert_eq!(model._get_text("A3"), *"4"); // Friday Mon=0
+
+    // Boundary verification
+    assert_eq!(model._get_text("A4"), *"1"); // Sunday Sun=1
+    assert_eq!(model._get_text("A5"), *"7"); // Sunday Mon=1
+    assert_eq!(model._get_text("A6"), *"1"); // Monday Mon=1
+
+    // Error cases
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#VALUE!");
+    assert_eq!(model._get_text("A9"), *"#NUM!");
+}
+
+#[test]
+fn test_weeknum_function() {
+    let mut model = new_empty_model();
+
+    // Test different return_type values (1=week starts Sunday, 2=week starts Monday)
+    model._set("A1", "=WEEKNUM(44561)"); // Default return_type=1
+    model._set("A2", "=WEEKNUM(44561,1)"); // Sunday start
+    model._set("A3", "=WEEKNUM(44561,2)"); // Monday start
+
+    // Test year boundaries
+    model._set("A4", "=WEEKNUM(43831,1)"); // Jan 1, 2020 (Wednesday)
+    model._set("A5", "=WEEKNUM(43831,2)"); // Jan 1, 2020 (Wednesday)
+    model._set("A6", "=WEEKNUM(44196,1)"); // Dec 31, 2020 (Thursday)
+    model._set("A7", "=WEEKNUM(44196,2)"); // Dec 31, 2020 (Thursday)
+
+    // Test first and last weeks of year
+    model._set("A8", "=WEEKNUM(44197,1)"); // Jan 1, 2021 (Friday)
+    model._set("A9", "=WEEKNUM(44197,2)"); // Jan 1, 2021 (Friday)
+    model._set("A10", "=WEEKNUM(44561,1)"); // Dec 31, 2021 (Friday)
+    model._set("A11", "=WEEKNUM(44561,2)"); // Dec 31, 2021 (Friday)
+
+    // Error cases - wrong argument count
+    model._set("A12", "=WEEKNUM()");
+    model._set("A13", "=WEEKNUM(44561,1,1)");
+
+    // Error cases - invalid return_type
+    model._set("A14", "=WEEKNUM(44561,0)");
+    model._set("A15", "=WEEKNUM(44561,3)");
+    model._set("A16", "=WEEKNUM(44561,-1)");
+
+    // Error cases - invalid dates
+    model._set("A17", "=WEEKNUM(-1)");
+    model._set("A18", &format!("=WEEKNUM({EXCEL_INVALID_DATE})"));
+
+    model.evaluate();
+
+    // Basic functionality
+    assert_eq!(model._get_text("A1"), *"53"); // Week 53
+    assert_eq!(model._get_text("A2"), *"53"); // Week 53 (Sunday start)
+    assert_eq!(model._get_text("A3"), *"53"); // Week 53 (Monday start)
+
+    // Year boundary tests
+    assert_eq!(model._get_text("A4"), *"1"); // Jan 1, 2020 (Sunday start)
+    assert_eq!(model._get_text("A5"), *"1"); // Jan 1, 2020 (Monday start)
+    assert_eq!(model._get_text("A6"), *"53"); // Dec 31, 2020 (Sunday start)
+    assert_eq!(model._get_text("A7"), *"53"); // Dec 31, 2020 (Monday start)
+
+    // 2021 tests
+    assert_eq!(model._get_text("A8"), *"1"); // Jan 1, 2021 (Sunday start)
+    assert_eq!(model._get_text("A9"), *"1"); // Jan 1, 2021 (Monday start)
+    assert_eq!(model._get_text("A10"), *"53"); // Dec 31, 2021 (Sunday start)
+    assert_eq!(model._get_text("A11"), *"53"); // Dec 31, 2021 (Monday start)
+
+    // Error cases
+    assert_eq!(model._get_text("A12"), *"#ERROR!");
+    assert_eq!(model._get_text("A13"), *"#ERROR!");
+    assert_eq!(model._get_text("A14"), *"#VALUE!");
+    assert_eq!(model._get_text("A15"), *"#VALUE!");
+    assert_eq!(model._get_text("A16"), *"#VALUE!");
+    assert_eq!(model._get_text("A17"), *"#NUM!");
+    assert_eq!(model._get_text("A18"), *"#NUM!");
+}
+
+#[test]
+fn test_workday_function() {
+    let mut model = new_empty_model();
+
+    // Basic functionality
+    model._set("A1", "=WORKDAY(44560,1)");
+    model._set("A2", "=WORKDAY(44561,-1)");
+    model._set("A3", "=WORKDAY(44561,0)");
+    model._set("A4", "=WORKDAY(44560,5)");
+
+    // Test with holidays
+    model._set("B1", "44561");
+    model._set("A5", "=WORKDAY(44560,1,B1)"); // Should skip the holiday
+    model._set("B2", "44562");
+    model._set("B3", "44563");
+    model._set("A6", "=WORKDAY(44560,3,B1:B3)"); // Multiple holidays
+
+    // Test starting on weekend
+    model._set("A7", "=WORKDAY(44562,1)"); // Saturday start
+    model._set("A8", "=WORKDAY(44563,1)"); // Sunday start
+
+    // Test negative workdays
+    model._set("A9", "=WORKDAY(44565,-3)"); // Go backwards 3 days
+    model._set("A10", "=WORKDAY(44565,-5,B1:B3)"); // Backwards with holidays
+
+    // Edge cases
+    model._set("A11", "=WORKDAY(1,1)"); // Early date
+    model._set("A12", "=WORKDAY(100000,10)"); // Large numbers
+
+    // Error cases - wrong argument count
+    model._set("A13", "=WORKDAY()");
+    model._set("A14", "=WORKDAY(44560)");
+    model._set("A15", "=WORKDAY(44560,1,B1,B2)");
+
+    // Error cases - invalid dates
+    model._set("A16", "=WORKDAY(-1,1)");
+    model._set("A17", &format!("=WORKDAY({EXCEL_INVALID_DATE},1)"));
+
+    // Error cases - invalid holiday dates
+    model._set("B4", "-1");
+    model._set("A18", "=WORKDAY(44560,1,B4)");
+
+    model.evaluate();
+
+    // Basic functionality
+    assert_eq!(model._get_text("A1"), *"44561"); // 1 day forward
+    assert_eq!(model._get_text("A2"), *"44560"); // 1 day backward
+    assert_eq!(model._get_text("A3"), *"44561"); // 0 days
+    assert_eq!(model._get_text("A4"), *"44567"); // 5 days forward
+
+    // With holidays
+    assert_eq!(model._get_text("A5"), *"44564"); // Skip holiday, go to Monday
+    assert_eq!(model._get_text("A6"), *"44566"); // Skip multiple holidays
+
+    // Weekend starts
+    assert_eq!(model._get_text("A7"), *"44564"); // From Saturday
+    assert_eq!(model._get_text("A8"), *"44564"); // From Sunday
+
+    // Negative workdays
+    assert_eq!(model._get_text("A9"), *"44560"); // 3 days back
+    assert_eq!(model._get_text("A10"), *"44557"); // 5 days back with holidays
+
+    // Edge cases
+    assert_eq!(model._get_text("A11"), *"2"); // Early date
+    assert_eq!(model._get_text("A12"), *"100014"); // Large numbers
+
+    // Error cases
+    assert_eq!(model._get_text("A13"), *"#ERROR!");
+    assert_eq!(model._get_text("A14"), *"#ERROR!");
+    assert_eq!(model._get_text("A15"), *"#ERROR!");
+    assert_eq!(model._get_text("A16"), *"#NUM!");
+    assert_eq!(model._get_text("A17"), *"#NUM!");
+    assert_eq!(model._get_text("A18"), *"#NUM!"); // Invalid holiday
+}
+
+#[test]
+fn test_workday_intl_function() {
+    let mut model = new_empty_model();
+
+    // Test key weekend mask types
+    model._set("A1", "=WORKDAY.INTL(44560,1,1)"); // Numeric: standard (Sat-Sun)
+    model._set("A2", "=WORKDAY.INTL(44560,1,2)"); // Numeric: Sun-Mon
+    model._set("A3", "=WORKDAY.INTL(44560,1,\"0000001\")"); // String: Sunday only
+    model._set("A4", "=WORKDAY.INTL(44560,1,\"1100000\")"); // String: Mon-Tue
+
+    // Test with holidays
+    model._set("B1", "44561");
+    model._set("A5", "=WORKDAY.INTL(44560,2,1,B1)"); // Standard + holiday
+    model._set("A6", "=WORKDAY.INTL(44560,2,7,B1)"); // Fri-Sat + holiday
+
+    // Basic edge cases
+    model._set("A7", "=WORKDAY.INTL(44561,0,1)"); // Zero days
+    model._set("A8", "=WORKDAY.INTL(44565,-1,1)"); // Negative days
+
+    // Error cases
+    model._set("A9", "=WORKDAY.INTL()"); // Wrong arg count
+    model._set("A10", "=WORKDAY.INTL(44560,1,0)"); // Invalid weekend mask
+    model._set("A11", "=WORKDAY.INTL(44560,1,\"123\")"); // Invalid string mask
+    model._set("A12", "=WORKDAY.INTL(-1,1,1)"); // Invalid date
+
+    model.evaluate();
+
+    // Weekend mask functionality
+    assert_eq!(model._get_text("A1"), *"44561"); // Standard weekend
+    assert_eq!(model._get_text("A2"), *"44561"); // Sun-Mon weekend
+    assert_eq!(model._get_text("A3"), *"44561"); // Sunday only
+    assert_eq!(model._get_text("A4"), *"44561"); // Mon-Tue weekend
+
+    // With holidays
+    assert_eq!(model._get_text("A5"), *"44565"); // Skip holiday + standard weekend
+    assert_eq!(model._get_text("A6"), *"44564"); // Skip holiday + Fri-Sat weekend
+
+    // Edge cases
+    assert_eq!(model._get_text("A7"), *"44561"); // Zero days
+    assert_eq!(model._get_text("A8"), *"44564"); // Negative days
+
+    // Error cases
+    assert_eq!(model._get_text("A9"), *"#ERROR!");
+    assert_eq!(model._get_text("A10"), *"#NUM!");
+    assert_eq!(model._get_text("A11"), *"#VALUE!");
+    assert_eq!(model._get_text("A12"), *"#NUM!");
+}
+
+#[test]
+fn test_yearfrac_function() {
+    let mut model = new_empty_model();
+
+    // Test key basis values (not exhaustive - just verify parameter works)
+    model._set("A1", "=YEARFRAC(44561,44926)"); // Default (30/360)
+    model._set("A2", "=YEARFRAC(44561,44926,1)"); // Actual/actual
+    model._set("A3", "=YEARFRAC(44561,44926,4)"); // European 30/360
+
+    // Edge cases
+    model._set("A4", "=YEARFRAC(44561,44561,1)"); // Same date = 0
+    model._set("A5", "=YEARFRAC(44926,44561,1)"); // Reverse = negative
+    model._set("A6", "=YEARFRAC(44197,44562,1)"); // Exact year (2021)
+
+    // Error cases
+    model._set("A7", "=YEARFRAC()"); // Wrong arg count
+    model._set("A8", "=YEARFRAC(44561,44926,5)"); // Invalid basis
+    model._set("A9", "=YEARFRAC(-1,44926,1)"); // Invalid date
+
+    model.evaluate();
+
+    // Basic functionality (approximate values expected)
+    assert_eq!(model._get_text("A1"), *"1"); // About 1 year
+    assert_eq!(model._get_text("A2"), *"1"); // About 1 year
+    assert_eq!(model._get_text("A3"), *"1"); // About 1 year
+
+    // Edge cases
+    assert_eq!(model._get_text("A4"), *"0"); // Same date
+    assert_eq!(model._get_text("A5"), *"-1"); // Negative
+    assert_eq!(model._get_text("A6"), *"1"); // Exact year
+
+    // Error cases
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#NUM!"); // Invalid basis should return #NUM!
+    assert_eq!(model._get_text("A9"), *"#NUM!");
+}
+
+#[test]
+fn test_isoweeknum_function() {
+    let mut model = new_empty_model();
+
+    // Basic functionality
+    model._set("A1", "=ISOWEEKNUM(44563)"); // Mid-week date
+    model._set("A2", "=ISOWEEKNUM(44561)"); // Year-end date
+
+    // Key ISO week boundaries (just critical cases)
+    model._set("A3", "=ISOWEEKNUM(44197)"); // Jan 1, 2021 (Fri) -> Week 53 of 2020
+    model._set("A4", "=ISOWEEKNUM(44200)"); // Jan 4, 2021 (Mon) -> Week 1 of 2021
+    model._set("A5", "=ISOWEEKNUM(44564)"); // Jan 3, 2022 (Mon) -> Week 1 of 2022
+
+    // Error cases
+    model._set("A6", "=ISOWEEKNUM()"); // Wrong arg count
+    model._set("A7", "=ISOWEEKNUM(-1)"); // Invalid date
+
+    model.evaluate();
+
+    // Basic functionality
+    assert_eq!(model._get_text("A1"), *"52");
+    assert_eq!(model._get_text("A2"), *"52");
+
+    // ISO week boundaries
+    assert_eq!(model._get_text("A3"), *"53"); // Week 53 of previous year
+    assert_eq!(model._get_text("A4"), *"1"); // Week 1 of current year
+    assert_eq!(model._get_text("A5"), *"1"); // Week 1 of next year
+
+    // Error cases
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+    assert_eq!(model._get_text("A7"), *"#NUM!");
+}

base/src/test/test_datedif_leap_month_end.rs

@@ -0,0 +1,33 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_datedif_yd_leap_year_edge_cases() {
+    let mut model = new_empty_model();
+
+    // 29 Feb 2020 → 28 Feb 2021   (should be 0 days)
+    model._set("A1", "=DATEDIF(\"29/2/2020\", \"28/2/2021\", \"YD\")");
+
+    // 29 Feb 2020 → 1 Mar 2021    (should be 1 day)
+    model._set("A2", "=DATEDIF(\"29/2/2020\", \"2021-03-01\", \"YD\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"0");
+    assert_eq!(model._get_text("A2"), *"1");
+}
+
+#[test]
+fn test_datedif_md_month_end_edge_cases() {
+    let mut model = new_empty_model();
+
+    // 31 Jan 2021 → 28 Feb 2021 (non-leap) => 28
+    model._set("B1", "=DATEDIF(\"31/1/2021\", \"28/2/2021\", \"MD\")");
+
+    // 31 Jan 2020 → 29 Feb 2020 (leap) => 29
+    model._set("B2", "=DATEDIF(\"31/1/2020\", \"29/2/2020\", \"MD\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"28");
+    assert_eq!(model._get_text("B2"), *"29");
+}

base/src/test/test_days360_month_end.rs

@@ -0,0 +1,43 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_days360_month_end_us() {
+    let mut model = new_empty_model();
+
+    // 31 Jan 2021 -> 28 Feb 2021 (non-leap)
+    model._set("A1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28))");
+
+    // 31 Jan 2020 -> 28 Feb 2020 (leap year – not last day of Feb)
+    model._set("A2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,28))");
+
+    // 28 Feb 2020 -> 31 Mar 2020 (leap year span crossing month ends)
+    model._set("A3", "=DAYS360(DATE(2020,2,28),DATE(2020,3,31))");
+
+    // 30 Apr 2021 -> 31 May 2021 (end-of-month adjustment rule)
+    model._set("A4", "=DAYS360(DATE(2021,4,30),DATE(2021,5,31))");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"30");
+    assert_eq!(model._get_text("A2"), *"28");
+    assert_eq!(model._get_text("A3"), *"33");
+    assert_eq!(model._get_text("A4"), *"30");
+}
+
+#[test]
+fn test_days360_month_end_european() {
+    let mut model = new_empty_model();
+
+    // European basis = TRUE (or 1)
+    model._set("B1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28),TRUE)");
+
+    model._set("B2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,29),TRUE)");
+
+    model._set("B3", "=DAYS360(DATE(2021,8,31),DATE(2021,9,30),TRUE)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"28");
+    assert_eq!(model._get_text("B2"), *"29");
+    assert_eq!(model._get_text("B3"), *"30");
+}

base/src/test/test_degrees_radians.rs

@@ -0,0 +1,22 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_degrees_radians_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEGREES()");
+    model._set("A2", "=RADIANS()");
+    model._set("A3", "=RADIANS(180)");
+    model._set("A4", "=RADIANS(180, 2)");
+    model._set("A5", "=DEGREES(RADIANS(180))");
+    model._set("A6", "=DEGREES(1, 2)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"3.141592654");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+    assert_eq!(model._get_text("A5"), *"180");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}

base/src/test/test_fn_accrint.rs

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

base/src/test/test_fn_accrintm.rs

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

base/src/test/test_fn_coupon.rs

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

base/src/test/test_fn_datevalue_datedif.rs

@@ -0,0 +1,182 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::types::Cell;
+
+// Helper to evaluate a formula and return the formatted text
+fn eval_formula(formula: &str) -> String {
+    let mut model = new_empty_model();
+    model._set("A1", formula);
+    model.evaluate();
+    model._get_text("A1")
+}
+
+// Helper that evaluates a formula and returns the raw value of A1 as a Result<f64, String>
+fn eval_formula_raw_number(formula: &str) -> Result<f64, String> {
+    let mut model = new_empty_model();
+    model._set("A1", formula);
+    model.evaluate();
+    match model._get_cell("A1") {
+        Cell::NumberCell { v, .. } => Ok(*v),
+        Cell::BooleanCell { v, .. } => Ok(if *v { 1.0 } else { 0.0 }),
+        Cell::ErrorCell { ei, .. } => Err(format!("{}", ei)),
+        _ => Err(model._get_text("A1")),
+    }
+}
+
+#[test]
+fn test_datevalue_basic_numeric() {
+    // DATEVALUE should return the serial number representing the date, **not** a formatted date
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"2/1/2023\")").unwrap(),
+        44958.0
+    );
+}
+
+#[test]
+fn test_datevalue_mmdd_with_leading_zero() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"02/01/2023\")").unwrap(),
+        44958.0
+    ); // 1-Feb-2023
+}
+
+#[test]
+fn test_datevalue_iso() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"2023-01-02\")").unwrap(),
+        44928.0
+    );
+}
+
+#[test]
+fn test_datevalue_month_name() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"2-Jan-23\")").unwrap(),
+        44928.0
+    );
+}
+
+#[test]
+fn test_datevalue_ambiguous_ddmm() {
+    // 01/02/2023 interpreted as MM/DD -> 2-Jan-2023
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"01/02/2023\")").unwrap(),
+        44929.0
+    );
+}
+
+#[test]
+fn test_datevalue_ddmm_unambiguous() {
+    // 15/01/2023 should be 15-Jan-2023 since 15 cannot be month
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"15/01/2023\")").unwrap(),
+        44941.0
+    );
+}
+
+#[test]
+fn test_datevalue_leap_day() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"29/02/2020\")").unwrap(),
+        43890.0
+    );
+}
+
+#[test]
+fn test_datevalue_year_first_text_month() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"2023/Jan/15\")").unwrap(),
+        44941.0
+    );
+}
+
+#[test]
+fn test_datevalue_mmdd_with_day_gt_12() {
+    assert_eq!(
+        eval_formula_raw_number("=DATEVALUE(\"6/15/2021\")").unwrap(),
+        44373.0
+    );
+}
+
+#[test]
+fn test_datevalue_error_conditions() {
+    let cases = [
+        "=DATEVALUE(\"31/04/2023\")",   // invalid day (Apr has 30 days)
+        "=DATEVALUE(\"13/13/2023\")",   // invalid month
+        "=DATEVALUE(\"not a date\")",   // non-date text
+    ];
+    for formula in cases {
+        let result = eval_formula(formula);
+        assert_eq!(result, *"#VALUE!", "Expected #VALUE! for {}", formula);
+    }
+}
+
+// Helper to set and evaluate a single DATEDIF call
+fn eval_datedif(unit: &str) -> String {
+    let mut model = new_empty_model();
+    let formula = format!("=DATEDIF(\"2020-01-01\", \"2021-06-15\", \"{}\")", unit);
+    model._set("A1", &formula);
+    model.evaluate();
+    model._get_text("A1")
+}
+
+#[test]
+fn test_datedif_y() {
+    assert_eq!(eval_datedif("Y"), *"1");
+}
+
+#[test]
+fn test_datedif_m() {
+    assert_eq!(eval_datedif("M"), *"17");
+}
+
+#[test]
+fn test_datedif_d() {
+    assert_eq!(eval_datedif("D"), *"531");
+}
+
+#[test]
+fn test_datedif_ym() {
+    assert_eq!(eval_datedif("YM"), *"5");
+}
+
+#[test]
+fn test_datedif_yd() {
+    assert_eq!(eval_datedif("YD"), *"165");
+}
+
+#[test]
+fn test_datedif_md() {
+    assert_eq!(eval_datedif("MD"), *"14");
+}
+
+#[test]
+fn test_datedif_edge_and_error_cases() {
+    let mut model = new_empty_model();
+    // Leap-year spanning
+    model._set("A1", "=DATEDIF(\"28/2/2020\", \"1/3/2020\", \"D\")");
+    // End date before start date => #NUM!
+    model._set("A2", "=DATEDIF(\"1/2/2021\", \"1/1/2021\", \"D\")");
+    // Invalid unit => #VALUE!
+    model._set("A3", "=DATEDIF(\"1/1/2020\", \"1/1/2021\", \"Z\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"2");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+    assert_eq!(model._get_text("A3"), *"#VALUE!");
+}
+
+#[test]
+fn test_datedif_mixed_case_unit() {
+    assert_eq!(eval_datedif("yD"), *"165"); // mixed-case should work
+}
+
+#[test]
+fn test_datedif_error_propagation() {
+    // Invalid date in arguments should propagate #VALUE!
+    let mut model = new_empty_model();
+    model._set("A1", "=DATEDIF(\"bad\", \"bad\", \"Y\")");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"#VALUE!");
+}

base/src/test/test_fn_duration.rs

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

base/src/test/test_fn_financial.rs

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

base/src/test/test_fn_financial_bonds.rs

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

base/src/test/test_fn_fvschedule.rs

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

base/src/test/test_fn_time.rs

@@ -0,0 +1,520 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+// Helper constants for common time values with detailed documentation
+const MIDNIGHT: &str = "0"; // 00:00:00 = 0/24 = 0
+const NOON: &str = "0.5"; // 12:00:00 = 12/24 = 0.5
+const TIME_14_30: &str = "0.604166667"; // 14:30:00 = 14.5/24 ≈ 0.604166667
+const TIME_14_30_45: &str = "0.6046875"; // 14:30:45 = 14.5125/24 = 0.6046875
+const TIME_14_30_59: &str = "0.604849537"; // 14:30:59 (from floored fractional inputs)
+const TIME_23_59_59: &str = "0.999988426"; // 23:59:59 = 23.99972.../24 ≈ 0.999988426
+
+// Excel documentation test values with explanations
+const TIME_2_24_AM: &str = "0.1"; // 2:24 AM = 2.4/24 = 0.1
+const TIME_2_PM: &str = "0.583333333"; // 2:00 PM = 14/24 ≈ 0.583333333
+const TIME_6_45_PM: &str = "0.78125"; // 6:45 PM = 18.75/24 = 0.78125
+const TIME_6_35_AM: &str = "0.274305556"; // 6:35 AM = 6.583333.../24 ≈ 0.274305556
+const TIME_2_30_AM: &str = "0.104166667"; // 2:30 AM = 2.5/24 ≈ 0.104166667
+const TIME_1_AM: &str = "0.041666667"; // 1:00 AM = 1/24 ≈ 0.041666667
+const TIME_9_PM: &str = "0.875"; // 9:00 PM = 21/24 = 0.875
+const TIME_2_AM: &str = "0.083333333"; // 2:00 AM = 2/24 ≈ 0.083333333
+                                       // Additional helper: 1-second past midnight (00:00:01)
+const TIME_00_00_01: &str = "0.000011574"; // 1 second = 1/86400 ≈ 0.000011574
+
+/// Helper function to set up and evaluate a model with time expressions
+fn test_time_expressions(expressions: &[(&str, &str)]) -> crate::model::Model {
+    let mut model = new_empty_model();
+    for (cell, formula) in expressions {
+        model._set(cell, formula);
+    }
+    model.evaluate();
+    model
+}
+
+/// Helper function to test component extraction for a given time value
+/// Returns (hour, minute, second) as strings
+fn test_component_extraction(time_value: &str) -> (String, String, String) {
+    let model = test_time_expressions(&[
+        ("A1", &format!("=HOUR({time_value})")),
+        ("B1", &format!("=MINUTE({time_value})")),
+        ("C1", &format!("=SECOND({time_value})")),
+    ]);
+    (
+        model._get_text("A1").to_string(),
+        model._get_text("B1").to_string(),
+        model._get_text("C1").to_string(),
+    )
+}
+
+#[test]
+fn test_excel_timevalue_compatibility() {
+    // Test cases based on Excel's official documentation and examples
+    let model = test_time_expressions(&[
+        // Excel documentation examples
+        ("A1", "=TIMEVALUE(\"2:24 AM\")"), // Should be 0.1
+        ("A2", "=TIMEVALUE(\"2 PM\")"),    // Should be 0.583333... (14/24)
+        ("A3", "=TIMEVALUE(\"6:45 PM\")"), // Should be 0.78125 (18.75/24)
+        ("A4", "=TIMEVALUE(\"18:45\")"),   // Same as above, 24-hour format
+        // Date-time format (date should be ignored)
+        ("B1", "=TIMEVALUE(\"22-Aug-2011 6:35 AM\")"), // Should be ~0.2743
+        ("B2", "=TIMEVALUE(\"2023-01-01 14:30:00\")"), // Should be 0.604166667
+        // Edge cases that Excel should support
+        ("C1", "=TIMEVALUE(\"12:00 AM\")"),    // Midnight: 0
+        ("C2", "=TIMEVALUE(\"12:00 PM\")"),    // Noon: 0.5
+        ("C3", "=TIMEVALUE(\"11:59:59 PM\")"), // Almost midnight: 0.999988426
+        // Single digit variations
+        ("D1", "=TIMEVALUE(\"1 AM\")"),  // 1:00 AM
+        ("D2", "=TIMEVALUE(\"9 PM\")"),  // 9:00 PM
+        ("D3", "=TIMEVALUE(\"12 AM\")"), // Midnight
+        ("D4", "=TIMEVALUE(\"12 PM\")"), // Noon
+    ]);
+
+    // Excel documentation examples - verify exact values
+    assert_eq!(model._get_text("A1"), *TIME_2_24_AM); // 2:24 AM
+    assert_eq!(model._get_text("A2"), *TIME_2_PM); // 2 PM = 14:00
+    assert_eq!(model._get_text("A3"), *TIME_6_45_PM); // 6:45 PM = 18:45
+    assert_eq!(model._get_text("A4"), *TIME_6_45_PM); // 18:45 (24-hour)
+
+    // Date-time formats (date ignored, extract time only)
+    assert_eq!(model._get_text("B1"), *TIME_6_35_AM); // 6:35 AM ≈ 0.2743
+    assert_eq!(model._get_text("B2"), *TIME_14_30); // 14:30:00
+
+    // Edge cases
+    assert_eq!(model._get_text("C1"), *MIDNIGHT); // 12:00 AM = 00:00
+    assert_eq!(model._get_text("C2"), *NOON); // 12:00 PM = 12:00
+    assert_eq!(model._get_text("C3"), *TIME_23_59_59); // 11:59:59 PM
+
+    // Single digit hours
+    assert_eq!(model._get_text("D1"), *TIME_1_AM); // 1:00 AM
+    assert_eq!(model._get_text("D2"), *TIME_9_PM); // 9:00 PM = 21:00
+    assert_eq!(model._get_text("D3"), *MIDNIGHT); // 12 AM = 00:00
+    assert_eq!(model._get_text("D4"), *NOON); // 12 PM = 12:00
+}
+
+#[test]
+fn test_time_function_basic_cases() {
+    let model = test_time_expressions(&[
+        ("A1", "=TIME(0,0,0)"),    // Midnight
+        ("A2", "=TIME(12,0,0)"),   // Noon
+        ("A3", "=TIME(14,30,0)"),  // 2:30 PM
+        ("A4", "=TIME(23,59,59)"), // Max time
+    ]);
+
+    assert_eq!(model._get_text("A1"), *MIDNIGHT);
+    assert_eq!(model._get_text("A2"), *NOON);
+    assert_eq!(model._get_text("A3"), *TIME_14_30);
+    assert_eq!(model._get_text("A4"), *TIME_23_59_59);
+}
+
+#[test]
+fn test_time_function_normalization() {
+    let model = test_time_expressions(&[
+        ("A1", "=TIME(25,0,0)"),         // Hours > 24 wrap around
+        ("A2", "=TIME(48,0,0)"),         // 48 hours = 0 (2 full days)
+        ("A3", "=TIME(0,90,0)"),         // 90 minutes = 1.5 hours
+        ("A4", "=TIME(0,0,90)"),         // 90 seconds = 1.5 minutes
+        ("A5", "=TIME(14.9,30.9,59.9)"), // Fractional inputs floored to 14:30:59
+    ]);
+
+    assert_eq!(model._get_text("A1"), *TIME_1_AM); // 1:00:00
+    assert_eq!(model._get_text("A2"), *MIDNIGHT); // 0:00:00
+    assert_eq!(model._get_text("A3"), *"0.0625"); // 1:30:00
+    assert_eq!(model._get_text("A4"), *"0.001041667"); // 0:01:30
+    assert_eq!(model._get_text("A5"), *TIME_14_30_59); // 14:30:59 (floored)
+}
+
+#[test]
+fn test_time_function_precision_edge_cases() {
+    let model = test_time_expressions(&[
+        // High precision fractional seconds
+        ("A1", "=TIME(14,30,45.999)"), // Fractional seconds should be floored
+        ("A2", "=SECOND(TIME(14,30,45.999))"), // Should extract 45, not 46
+        // Very large normalization values
+        ("B1", "=TIME(999,999,999)"), // Extreme normalization test
+        ("B2", "=HOUR(999.5)"),       // Multiple days, extract hour from fractional part
+        ("B3", "=MINUTE(999.75)"),    // Multiple days, extract minute
+        // Boundary conditions at rollover points
+        ("C1", "=TIME(24,60,60)"), // Should normalize to next day (00:01:00)
+        ("C2", "=HOUR(0.999999999)"), // Almost 24 hours should be 23
+        ("C3", "=MINUTE(0.999999999)"), // Almost 24 hours, extract minutes
+        ("C4", "=SECOND(0.999999999)"), // Almost 24 hours, extract seconds
+        // Precision at boundaries
+        ("D1", "=TIME(23,59,59.999)"), // Very close to midnight
+        ("D2", "=TIME(0,0,0.001)"),    // Just after midnight
+    ]);
+
+    // Fractional seconds are floored
+    assert_eq!(model._get_text("A2"), *"45"); // 45.999 floored to 45
+
+    // Multiple days should work with rem_euclid
+    assert_eq!(model._get_text("B2"), *"12"); // 999.5 days, hour = 12 (noon)
+
+    // Boundary normalization
+    assert_eq!(model._get_text("C1"), *"0.042361111"); // 24:60:60 = 01:01:00 (normalized)
+    assert_eq!(model._get_text("C2"), *"23"); // Almost 24 hours = 23:xx:xx
+
+    // High precision should be handled correctly
+    let result_d1 = model._get_text("D1").parse::<f64>().unwrap();
+    assert!(result_d1 < 1.0 && result_d1 > 0.999); // Very close to but less than 1.0
+}
+
+#[test]
+fn test_time_function_errors() {
+    let model = test_time_expressions(&[
+        ("A1", "=TIME()"),          // Wrong arg count
+        ("A2", "=TIME(12)"),        // Wrong arg count
+        ("A3", "=TIME(12,30,0,0)"), // Wrong arg count
+        ("B1", "=TIME(-1,0,0)"),    // Negative hour
+        ("B2", "=TIME(0,-1,0)"),    // Negative minute
+        ("B3", "=TIME(0,0,-1)"),    // Negative second
+    ]);
+
+    // Wrong argument count
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+
+    // Negative values should return #NUM! error
+    assert_eq!(model._get_text("B1"), *"#NUM!");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("B3"), *"#NUM!");
+}
+
+#[test]
+fn test_timevalue_function_formats() {
+    let model = test_time_expressions(&[
+        // Basic formats
+        ("A1", "=TIMEVALUE(\"14:30\")"),
+        ("A2", "=TIMEVALUE(\"14:30:45\")"),
+        ("A3", "=TIMEVALUE(\"00:00:00\")"),
+        // AM/PM formats
+        ("B1", "=TIMEVALUE(\"2:30 PM\")"),
+        ("B2", "=TIMEVALUE(\"2:30 AM\")"),
+        ("B3", "=TIMEVALUE(\"12:00 PM\")"), // Noon
+        ("B4", "=TIMEVALUE(\"12:00 AM\")"), // Midnight
+        // Single hour with AM/PM (now supported!)
+        ("B5", "=TIMEVALUE(\"2 PM\")"),
+        ("B6", "=TIMEVALUE(\"2 AM\")"),
+        // Date-time formats (extract time only)
+        ("C1", "=TIMEVALUE(\"2023-01-01 14:30:00\")"),
+        ("C2", "=TIMEVALUE(\"2023-01-01T14:30:00\")"),
+        // Whitespace handling
+        ("D1", "=TIMEVALUE(\" 14:30 \")"),
+    ]);
+
+    // Basic formats
+    assert_eq!(model._get_text("A1"), *TIME_14_30);
+    assert_eq!(model._get_text("A2"), *TIME_14_30_45);
+    assert_eq!(model._get_text("A3"), *MIDNIGHT);
+
+    // AM/PM formats
+    assert_eq!(model._get_text("B1"), *TIME_14_30); // 2:30 PM = 14:30
+    assert_eq!(model._get_text("B2"), *TIME_2_30_AM); // 2:30 AM
+    assert_eq!(model._get_text("B3"), *NOON); // 12:00 PM = noon
+    assert_eq!(model._get_text("B4"), *MIDNIGHT); // 12:00 AM = midnight
+
+    // Single hour AM/PM formats (now supported!)
+    assert_eq!(model._get_text("B5"), *TIME_2_PM); // 2 PM = 14:00
+    assert_eq!(model._get_text("B6"), *TIME_2_AM); // 2 AM = 02:00
+
+    // Date-time formats
+    assert_eq!(model._get_text("C1"), *TIME_14_30);
+    assert_eq!(model._get_text("C2"), *TIME_14_30);
+
+    // Whitespace
+    assert_eq!(model._get_text("D1"), *TIME_14_30);
+}
+
+#[test]
+fn test_timevalue_function_errors() {
+    let model = test_time_expressions(&[
+        ("A1", "=TIMEVALUE()"),                 // Wrong arg count
+        ("A2", "=TIMEVALUE(\"14:30\", \"x\")"), // Wrong arg count
+        ("B1", "=TIMEVALUE(\"invalid\")"),      // Invalid format
+        ("B2", "=TIMEVALUE(\"25:00\")"),        // Invalid hour
+        ("B3", "=TIMEVALUE(\"14:70\")"),        // Invalid minute
+        ("B4", "=TIMEVALUE(\"\")"),             // Empty string
+        ("B5", "=TIMEVALUE(\"2PM\")"),          // Missing space (still unsupported)
+    ]);
+
+    // Wrong argument count should return #ERROR!
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+
+    // Invalid formats should return #VALUE!
+    assert_eq!(model._get_text("B1"), *"#VALUE!");
+    assert_eq!(model._get_text("B2"), *"#VALUE!");
+    assert_eq!(model._get_text("B3"), *"#VALUE!");
+    assert_eq!(model._get_text("B4"), *"#VALUE!");
+    assert_eq!(model._get_text("B5"), *"#VALUE!"); // "2PM" no space - not supported
+}
+
+#[test]
+fn test_time_component_extraction_comprehensive() {
+    // Test component extraction using helper function for consistency
+
+    // Test basic time values
+    let test_cases = [
+        (MIDNIGHT, ("0", "0", "0")),         // 00:00:00
+        (NOON, ("12", "0", "0")),            // 12:00:00
+        (TIME_14_30, ("14", "30", "0")),     // 14:30:00
+        (TIME_23_59_59, ("23", "59", "59")), // 23:59:59
+    ];
+
+    for (time_value, expected) in test_cases {
+        let (hour, minute, second) = test_component_extraction(time_value);
+        assert_eq!(hour, expected.0, "Hour mismatch for {time_value}");
+        assert_eq!(minute, expected.1, "Minute mismatch for {time_value}");
+        assert_eq!(second, expected.2, "Second mismatch for {time_value}");
+    }
+
+    // Test multiple days (extract from fractional part)
+    let (hour, minute, second) = test_component_extraction("1.5"); // Day 2, 12:00
+    assert_eq!(
+        (hour, minute, second),
+        ("12".to_string(), "0".to_string(), "0".to_string())
+    );
+
+    let (hour, minute, second) = test_component_extraction("100.604166667"); // Day 101, 14:30
+    assert_eq!(
+        (hour, minute, second),
+        ("14".to_string(), "30".to_string(), "0".to_string())
+    );
+
+    // Test precision at boundaries
+    let (hour, _, _) = test_component_extraction("0.041666666"); // Just under 1:00 AM
+    assert_eq!(hour, "0");
+
+    let (hour, _, _) = test_component_extraction("0.041666667"); // Exactly 1:00 AM
+    assert_eq!(hour, "1");
+
+    let (hour, _, _) = test_component_extraction("0.041666668"); // Just over 1:00 AM
+    assert_eq!(hour, "1");
+
+    // Test very large day values
+    let (hour, minute, second) = test_component_extraction("1000000.25"); // Million days + 6 hours
+    assert_eq!(
+        (hour, minute, second),
+        ("6".to_string(), "0".to_string(), "0".to_string())
+    );
+}
+
+#[test]
+fn test_time_component_function_errors() {
+    let model = test_time_expressions(&[
+        // Wrong argument counts
+        ("A1", "=HOUR()"),       // No arguments
+        ("A2", "=MINUTE()"),     // No arguments
+        ("A3", "=SECOND()"),     // No arguments
+        ("A4", "=HOUR(1, 2)"),   // Too many arguments
+        ("A5", "=MINUTE(1, 2)"), // Too many arguments
+        ("A6", "=SECOND(1, 2)"), // Too many arguments
+        // Negative values should return #NUM!
+        ("B1", "=HOUR(-0.5)"),        // Negative value
+        ("B2", "=MINUTE(-1)"),        // Negative value
+        ("B3", "=SECOND(-1)"),        // Negative value
+        ("B4", "=HOUR(-0.000001)"),   // Slightly negative
+        ("B5", "=MINUTE(-0.000001)"), // Slightly negative
+        ("B6", "=SECOND(-0.000001)"), // Slightly negative
+    ]);
+
+    // Wrong argument count should return #ERROR!
+    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("A4"), *"#ERROR!");
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+
+    // Negative values should return #NUM!
+    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!");
+    assert_eq!(model._get_text("B5"), *"#NUM!");
+    assert_eq!(model._get_text("B6"), *"#NUM!");
+}
+
+#[test]
+fn test_time_functions_integration() {
+    // Test how TIME, TIMEVALUE and component extraction functions work together
+    let model = test_time_expressions(&[
+        // Create times with both functions
+        ("A1", "=TIME(14,30,45)"),
+        ("A2", "=TIMEVALUE(\"14:30:45\")"),
+        // Extract components from TIME function results
+        ("B1", "=HOUR(A1)"),
+        ("B2", "=MINUTE(A1)"),
+        ("B3", "=SECOND(A1)"),
+        // Extract components from TIMEVALUE function results
+        ("C1", "=HOUR(A2)"),
+        ("C2", "=MINUTE(A2)"),
+        ("C3", "=SECOND(A2)"),
+        // Test additional TIME variations
+        ("D1", "=TIME(14,0,0)"), // 14:00:00
+        ("E1", "=HOUR(D1)"),     // Extract hour from 14:00:00
+        ("E2", "=MINUTE(D1)"),   // Extract minute from 14:00:00
+        ("E3", "=SECOND(D1)"),   // Extract second from 14:00:00
+    ]);
+
+    // TIME and TIMEVALUE should produce equivalent results
+    assert_eq!(model._get_text("A1"), model._get_text("A2"));
+
+    // Extracting components should work consistently
+    assert_eq!(model._get_text("B1"), *"14");
+    assert_eq!(model._get_text("B2"), *"30");
+    assert_eq!(model._get_text("B3"), *"45");
+    assert_eq!(model._get_text("C1"), *"14");
+    assert_eq!(model._get_text("C2"), *"30");
+    assert_eq!(model._get_text("C3"), *"45");
+
+    // Components from TIME(14,0,0)
+    assert_eq!(model._get_text("E1"), *"14");
+    assert_eq!(model._get_text("E2"), *"0");
+    assert_eq!(model._get_text("E3"), *"0");
+}
+
+#[test]
+fn test_time_function_extreme_values() {
+    // Test missing edge cases: very large fractional inputs
+    let model = test_time_expressions(&[
+        // Extremely large fractional values to TIME function
+        ("A1", "=TIME(999999.9, 999999.9, 999999.9)"), // Very large fractional inputs
+        ("A2", "=TIME(1e6, 1e6, 1e6)"),                // Scientific notation inputs
+        ("A3", "=TIME(0.000001, 0.000001, 0.000001)"), // Very small fractional inputs
+        // Large day values for component extraction (stress test)
+        ("B1", "=HOUR(999999.999)"), // Almost a million days
+        ("B2", "=MINUTE(999999.999)"),
+        ("B3", "=SECOND(999999.999)"),
+        // Edge case: exactly 1.0 (should be midnight of next day)
+        ("C1", "=HOUR(1.0)"),
+        ("C2", "=MINUTE(1.0)"),
+        ("C3", "=SECOND(1.0)"),
+        // Very high precision values
+        ("D1", "=HOUR(0.999999999999)"), // Almost exactly 24:00:00
+        ("D2", "=MINUTE(0.999999999999)"),
+        ("D3", "=SECOND(0.999999999999)"),
+    ]);
+
+    // Large fractional inputs should be floored and normalized
+    let result_a1 = model._get_text("A1").parse::<f64>().unwrap();
+    assert!(
+        (0.0..1.0).contains(&result_a1),
+        "Result should be valid time fraction"
+    );
+
+    // Component extraction should work with very large values
+    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
+    assert!((0..=23).contains(&hour_b1), "Hour should be 0-23");
+
+    // Exactly 1.0 should be midnight (start of next day)
+    assert_eq!(model._get_text("C1"), *"0");
+    assert_eq!(model._get_text("C2"), *"0");
+    assert_eq!(model._get_text("C3"), *"0");
+
+    // Very high precision should still extract valid components
+    let hour_d1 = model._get_text("D1").parse::<i32>().unwrap();
+    assert!((0..=23).contains(&hour_d1), "Hour should be 0-23");
+}
+
+#[test]
+fn test_timevalue_malformed_but_parseable() {
+    // Test missing edge case: malformed but potentially parseable strings
+    let model = test_time_expressions(&[
+        // Test various malformed but potentially parseable time strings
+        ("A1", "=TIMEVALUE(\"14:30:00.123\")"), // Milliseconds (might be truncated)
+        ("A2", "=TIMEVALUE(\"14:30:00.999\")"), // High precision milliseconds
+        ("A3", "=TIMEVALUE(\"02:30:00\")"),     // Leading zero hours
+        ("A4", "=TIMEVALUE(\"2:05:00\")"),      // Single digit hour, zero-padded minute
+        // Boundary cases for AM/PM parsing
+        ("B1", "=TIMEVALUE(\"11:59:59 PM\")"), // Just before midnight
+        ("B2", "=TIMEVALUE(\"12:00:01 AM\")"), // Just after midnight
+        ("B3", "=TIMEVALUE(\"12:00:01 PM\")"), // Just after noon
+        ("B4", "=TIMEVALUE(\"11:59:59 AM\")"), // Just before noon
+        // Test various date-time combinations
+        ("C1", "=TIMEVALUE(\"2023-12-31T23:59:59\")"), // ISO format at year end
+        ("C2", "=TIMEVALUE(\"2023-01-01 00:00:01\")"), // New year, just after midnight
+        // Test potential edge cases that might still be parseable
+        ("D1", "=TIMEVALUE(\"24:00:00\")"), // Should error (invalid hour)
+        ("D2", "=TIMEVALUE(\"23:60:00\")"), // Should error (invalid minute)
+        ("D3", "=TIMEVALUE(\"23:59:60\")"), // Should error (invalid second)
+    ]);
+
+    // Milliseconds are not supported, should return a #VALUE! error like Excel
+    assert_eq!(model._get_text("A1"), *"#VALUE!");
+    assert_eq!(model._get_text("A2"), *"#VALUE!");
+
+    // Leading zeros should work fine
+    assert_eq!(model._get_text("A3"), *TIME_2_30_AM); // 02:30:00 should parse as 2:30:00
+
+    // AM/PM boundary cases should work
+    let result_b1 = model._get_text("B1").parse::<f64>().unwrap();
+    assert!(
+        result_b1 > 0.99 && result_b1 < 1.0,
+        "11:59:59 PM should be very close to 1.0"
+    );
+
+    let result_b2 = model._get_text("B2").parse::<f64>().unwrap();
+    assert!(
+        result_b2 > 0.0 && result_b2 < 0.01,
+        "12:00:01 AM should be very close to 0.0"
+    );
+
+    // ISO 8601 format with "T" separator should be parsed correctly
+    assert_eq!(model._get_text("C1"), *TIME_23_59_59); // 23:59:59 → almost midnight
+    assert_eq!(model._get_text("C2"), *TIME_00_00_01); // 00:00:01 → one second past midnight
+
+    // Time parser normalizes edge cases to midnight (Excel compatibility)
+    assert_eq!(model._get_text("D1"), *"0"); // 24:00:00 = midnight of next day
+    assert_eq!(model._get_text("D2"), *"0"); // 23:60:00 normalizes to 24:00:00 = midnight
+    assert_eq!(model._get_text("D3"), *"0"); // 23:59:60 normalizes to 24:00:00 = midnight
+}
+
+#[test]
+fn test_performance_stress_with_extreme_values() {
+    // Test performance/stress cases with extreme values
+    let model = test_time_expressions(&[
+        // Very large numbers that should still work
+        ("A1", "=TIME(2147483647, 0, 0)"), // Max i32 hours
+        ("A2", "=TIME(0, 2147483647, 0)"), // Max i32 minutes
+        ("A3", "=TIME(0, 0, 2147483647)"), // Max i32 seconds
+        // Component extraction with extreme day values
+        ("B1", "=HOUR(1e15)"), // Very large day number
+        ("B2", "=MINUTE(1e15)"),
+        ("B3", "=SECOND(1e15)"),
+        // Edge of floating point precision
+        ("C1", "=HOUR(1.7976931348623157e+308)"), // Near max f64
+        ("C2", "=HOUR(2.2250738585072014e-308)"), // Near min positive f64
+        // Multiple TIME function calls with large values
+        ("D1", "=TIME(1000000, 1000000, 1000000)"), // Large normalized values
+        ("D2", "=HOUR(D1)"),                        // Extract from large TIME result
+        ("D3", "=MINUTE(D1)"),
+        ("D4", "=SECOND(D1)"),
+    ]);
+
+    // All results should be valid (not errors) even with extreme inputs
+    for cell in ["A1", "A2", "A3", "B1", "B2", "B3", "D1", "D2", "D3", "D4"] {
+        let result = model._get_text(cell);
+        assert!(
+            result != *"#ERROR!" && result != *"#NUM!" && result != *"#VALUE!",
+            "Cell {cell} should not error with extreme values: {result}",
+        );
+    }
+
+    // Results should be mathematically valid
+    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
+    let minute_b2 = model._get_text("B2").parse::<i32>().unwrap();
+    let second_b3 = model._get_text("B3").parse::<i32>().unwrap();
+
+    assert!((0..=23).contains(&hour_b1));
+    assert!((0..=59).contains(&minute_b2));
+    assert!((0..=59).contains(&second_b3));
+
+    // TIME function results should be valid time fractions
+    let time_d1 = model._get_text("D1").parse::<f64>().unwrap();
+    assert!(
+        (0.0..1.0).contains(&time_d1),
+        "TIME result should be valid fraction"
+    );
+}

base/src/test/test_issue_483.rs

@@ -0,0 +1,13 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "123");
+    model._set("D2", "=-(A1^1.22)");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("D2"), "=-(A1^1.22)".to_string());
+}

base/src/test/test_networkdays.rs

@@ -0,0 +1,347 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+// Test data: Jan 1-10, 2023 week
+const JAN_1_2023: i32 = 44927; // Sunday
+const JAN_2_2023: i32 = 44928; // Monday
+const JAN_6_2023: i32 = 44932; // Friday
+const JAN_9_2023: i32 = 44935; // Monday
+const JAN_10_2023: i32 = 44936; // Tuesday
+
+#[test]
+fn networkdays_calculates_weekdays_excluding_weekends() {
+    let mut model = new_empty_model();
+
+    model._set("A1", &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023})"));
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "7",
+        "Should count 7 weekdays in 10-day span"
+    );
+}
+
+#[test]
+fn networkdays_handles_reverse_date_order() {
+    let mut model = new_empty_model();
+
+    model._set("A1", &format!("=NETWORKDAYS({JAN_10_2023},{JAN_1_2023})"));
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "-7",
+        "Reversed dates should return negative count"
+    );
+}
+
+#[test]
+fn networkdays_excludes_holidays_from_weekdays() {
+    let mut model = new_empty_model();
+
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},{JAN_9_2023})"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "6",
+        "Should exclude Monday holiday from 7 weekdays"
+    );
+}
+
+#[test]
+fn networkdays_handles_same_start_end_date() {
+    let mut model = new_empty_model();
+
+    model._set("A1", &format!("=NETWORKDAYS({JAN_9_2023},{JAN_9_2023})"));
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "1",
+        "Same weekday date should count as 1 workday"
+    );
+}
+
+#[test]
+fn networkdays_accepts_holiday_ranges() {
+    let mut model = new_empty_model();
+
+    model._set("B1", &JAN_2_2023.to_string());
+    model._set("B2", &JAN_6_2023.to_string());
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1:B2)"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "5",
+        "Should exclude 2 holidays from 7 weekdays"
+    );
+}
+
+#[test]
+fn networkdays_intl_uses_standard_weekend_by_default() {
+    let mut model = new_empty_model();
+
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023})"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "7",
+        "Default should be Saturday-Sunday weekend"
+    );
+}
+
+#[test]
+fn networkdays_intl_supports_numeric_weekend_patterns() {
+    let mut model = new_empty_model();
+
+    // Pattern 2 = Sunday-Monday weekend
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},2)"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "6",
+        "Sunday-Monday weekend should give 6 workdays"
+    );
+}
+
+#[test]
+fn networkdays_intl_supports_single_day_weekends() {
+    let mut model = new_empty_model();
+
+    // Pattern 11 = Sunday only weekend
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},11)"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "8",
+        "Sunday-only weekend should give 8 workdays"
+    );
+}
+
+#[test]
+fn networkdays_intl_supports_string_weekend_patterns() {
+    let mut model = new_empty_model();
+
+    // "0000110" = Friday-Saturday weekend
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000110\")"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "8",
+        "Friday-Saturday weekend should give 8 workdays"
+    );
+}
+
+#[test]
+fn networkdays_intl_no_weekends_counts_all_days() {
+    let mut model = new_empty_model();
+
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000000\")"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "10",
+        "No weekends should count all 10 days"
+    );
+}
+
+#[test]
+fn networkdays_intl_combines_custom_weekends_with_holidays() {
+    let mut model = new_empty_model();
+
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000110\",{JAN_9_2023})"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "7",
+        "Should exclude both weekend and holiday"
+    );
+}
+
+#[test]
+fn networkdays_validates_argument_count() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NETWORKDAYS()");
+    model._set("A2", "=NETWORKDAYS(1,2,3,4)");
+    model._set("A3", "=NETWORKDAYS.INTL()");
+    model._set("A4", "=NETWORKDAYS.INTL(1,2,3,4,5)");
+
+    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("A4"), "#ERROR!");
+}
+
+#[test]
+fn networkdays_rejects_invalid_dates() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NETWORKDAYS(-1,100)");
+    model._set("A2", "=NETWORKDAYS(1,3000000)");
+    model._set("A3", "=NETWORKDAYS(\"text\",100)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "#NUM!");
+    assert_eq!(model._get_text("A2"), "#NUM!");
+    assert_eq!(model._get_text("A3"), "#VALUE!");
+}
+
+#[test]
+fn networkdays_intl_rejects_invalid_weekend_patterns() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NETWORKDAYS.INTL(1,10,99)");
+    model._set("A2", "=NETWORKDAYS.INTL(1,10,\"111110\")");
+    model._set("A3", "=NETWORKDAYS.INTL(1,10,\"11111000\")");
+    model._set("A4", "=NETWORKDAYS.INTL(1,10,\"1111102\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "#NUM!");
+    assert_eq!(model._get_text("A2"), "#VALUE!");
+    assert_eq!(model._get_text("A3"), "#VALUE!");
+    assert_eq!(model._get_text("A4"), "#VALUE!");
+}
+
+#[test]
+fn networkdays_rejects_invalid_holidays() {
+    let mut model = new_empty_model();
+
+    model._set("B1", "invalid");
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1)"),
+    );
+    model._set(
+        "A2",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},-1)"),
+    );
+
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "#VALUE!",
+        "Should reject non-numeric holidays"
+    );
+    assert_eq!(
+        model._get_text("A2"),
+        "#NUM!",
+        "Should reject out-of-range holidays"
+    );
+}
+
+#[test]
+fn networkdays_handles_weekend_only_periods() {
+    let mut model = new_empty_model();
+
+    let saturday = JAN_1_2023 - 1;
+    model._set("A1", &format!("=NETWORKDAYS({saturday},{JAN_1_2023})"));
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "0",
+        "Weekend-only period should count 0 workdays"
+    );
+}
+
+#[test]
+fn networkdays_ignores_holidays_outside_date_range() {
+    let mut model = new_empty_model();
+
+    let future_holiday = JAN_10_2023 + 100;
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},{future_holiday})"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "7",
+        "Out-of-range holidays should be ignored"
+    );
+}
+
+#[test]
+fn networkdays_handles_empty_holiday_ranges() {
+    let mut model = new_empty_model();
+
+    model._set(
+        "A1",
+        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1:B3)"),
+    );
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "7",
+        "Empty holiday range should be treated as no holidays"
+    );
+}
+
+#[test]
+fn networkdays_handles_minimum_valid_dates() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NETWORKDAYS(1,7)");
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "5",
+        "Should handle earliest Excel dates correctly"
+    );
+}
+
+#[test]
+fn networkdays_handles_large_date_ranges_efficiently() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=NETWORKDAYS(1,365)");
+    model.evaluate();
+
+    assert!(
+        !model._get_text("A1").starts_with('#'),
+        "Large ranges should not error"
+    );
+}

base/src/test/test_sheet_names.rs

@@ -0,0 +1,16 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn sheet_number_name() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    model._set("A1", "7");
+    model._set("A2", "=Sheet2!C3");
+    model.evaluate();
+    model.rename_sheet("Sheet2", "2024").unwrap();
+    model.evaluate();
+    assert_eq!(model.workbook.get_worksheet_names(), ["Sheet1", "2024"]);
+    assert_eq!(model._get_text("A2"), "0");
+}

base/src/test/test_weekday_return_types.rs

@@ -0,0 +1,26 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_weekday_return_types_11_to_17() {
+    let mut model = new_empty_model();
+
+    // Test date: 44561 corresponds to a Friday (2021-12-31). We verify the
+    // numeric result for each custom week start defined by return_type 11-17.
+    model._set("A1", "=WEEKDAY(44561,11)"); // Monday start
+    model._set("A2", "=WEEKDAY(44561,12)"); // Tuesday start
+    model._set("A3", "=WEEKDAY(44561,13)"); // Wednesday start
+    model._set("A4", "=WEEKDAY(44561,14)"); // Thursday start
+    model._set("A5", "=WEEKDAY(44561,15)"); // Friday start
+    model._set("A6", "=WEEKDAY(44561,16)"); // Saturday start
+    model._set("A7", "=WEEKDAY(44561,17)"); // Sunday start
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"5"); // Mon=1 .. Sun=7 ⇒ Fri=5
+    assert_eq!(model._get_text("A2"), *"4"); // Tue start ⇒ Fri=4
+    assert_eq!(model._get_text("A3"), *"3"); // Wed start ⇒ Fri=3
+    assert_eq!(model._get_text("A4"), *"2"); // Thu start ⇒ Fri=2
+    assert_eq!(model._get_text("A5"), *"1"); // Fri start ⇒ Fri=1
+    assert_eq!(model._get_text("A6"), *"7"); // Sat start ⇒ Fri=7
+    assert_eq!(model._get_text("A7"), *"6"); // Sun start ⇒ Fri=6
+}

base/src/test/test_weeknum_return_types.rs

@@ -0,0 +1,31 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_weeknum_return_types_11_to_17_and_21() {
+    let mut model = new_empty_model();
+
+    // Date 44561 -> 2021-12-31 (Friday). Previously verified as week 53 (Sunday/Monday start).
+    // We verify that custom week-start codes 11-17 all map to week 53 and ISO variant (21) maps to 52.
+    let formulas = [
+        ("A1", "=WEEKNUM(44561,11)"),
+        ("A2", "=WEEKNUM(44561,12)"),
+        ("A3", "=WEEKNUM(44561,13)"),
+        ("A4", "=WEEKNUM(44561,14)"),
+        ("A5", "=WEEKNUM(44561,15)"),
+        ("A6", "=WEEKNUM(44561,16)"),
+        ("A7", "=WEEKNUM(44561,17)"),
+        ("A8", "=WEEKNUM(44561,21)"), // ISO week numbering
+    ];
+    for (cell, formula) in formulas {
+        model._set(cell, formula);
+    }
+
+    model.evaluate();
+
+    // All 11-17 variations should yield 53
+    for cell in ["A1", "A2", "A3", "A4", "A5", "A6", "A7"] {
+        assert_eq!(model._get_text(cell), *"53", "{cell} should be 53");
+    }
+    // ISO week (return_type 21)
+    assert_eq!(model._get_text("A8"), *"52");
+}

base/src/test/test_yearfrac_basis.rs

@@ -0,0 +1,60 @@
+#![allow(clippy::panic)]
+use crate::{cell::CellValue, test::util::new_empty_model};
+
+#[test]
+fn test_yearfrac_basis_2_actual_360() {
+    let mut model = new_empty_model();
+
+    // Non-leap span of exactly 360 days should result in 1.0
+    model._set("A1", "=YEARFRAC(44561,44921,2)");
+
+    // Leap-year span of 366 days: Jan 1 2020 → Jan 1 2021
+    model._set("A2", "=YEARFRAC(43831,44197,2)");
+
+    // Reverse order should yield negative value
+    model._set("A3", "=YEARFRAC(44921,44561,2)");
+
+    model.evaluate();
+
+    // 360/360
+    assert_eq!(model._get_text("A1"), *"1");
+
+    // 366/360 ≈ 1.0166666667 (tolerance 1e-10)
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!A2") {
+        assert!((v - 1.016_666_666_7).abs() < 1e-10);
+    } else {
+        panic!("Expected numeric value in A2");
+    }
+
+    // Negative symmetric of A1
+    assert_eq!(model._get_text("A3"), *"-1");
+}
+
+#[test]
+fn test_yearfrac_basis_3_actual_365() {
+    let mut model = new_empty_model();
+
+    // Non-leap span of exactly 365 days should result in 1.0
+    model._set("B1", "=YEARFRAC(44561,44926,3)");
+
+    // Leap-year span of 366 days
+    model._set("B2", "=YEARFRAC(43831,44197,3)");
+
+    // Same date should be 0
+    model._set("B3", "=YEARFRAC(44561,44561,3)");
+
+    model.evaluate();
+
+    // 365/365
+    assert_eq!(model._get_text("B1"), *"1");
+
+    // 366/365 ≈ 1.002739726 (tolerance 1e-10)
+    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B2") {
+        assert!((v - 1.002_739_726).abs() < 1e-10);
+    } else {
+        panic!("Expected numeric value in B2");
+    }
+
+    // Same date
+    assert_eq!(model._get_text("B3"), *"0");
+}

base/src/test/user_model/test_clear_cells.rs

@@ -89,3 +89,67 @@ fn clear_all_empty_cell() {
     model.undo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
 }
+
+#[test]
+fn issue_454() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model
+        .set_user_input(
+            0,
+            1,
+            1,
+            "Le presbytère n'a rien perdu de son charme, ni le jardin de son éclat.",
+        )
+        .unwrap();
+    model.set_user_input(0, 1, 2, "=ISTEXT(A1)").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("TRUE".to_string())
+    );
+    model
+        .range_clear_contents(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("FALSE".to_string())
+    );
+    model.undo().unwrap();
+}
+
+#[test]
+fn issue_454b() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model
+        .set_user_input(
+            0,
+            1,
+            1,
+            "Le presbytère n'a rien perdu de son charme, ni le jardin de son éclat.",
+        )
+        .unwrap();
+    model.set_user_input(0, 1, 2, "=ISTEXT(A1)").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("TRUE".to_string())
+    );
+    model
+        .range_clear_all(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("FALSE".to_string())
+    );
+    model.undo().unwrap();
+}

base/src/user_model/common.rs

@@ -627,6 +627,7 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
+        self.evaluate_if_not_paused();
         Ok(())
     }
 
@@ -656,6 +657,7 @@ impl UserModel {
             }
         }
         self.push_diff_list(diff_list);
+        self.evaluate_if_not_paused();
         Ok(())
     }
 

bindings/nodejs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "ironcalc_nodejs"
-version = "0.5.0"
+version = "0.6.0"
 
 [lib]
 crate-type = ["cdylib"]
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
 napi = { version = "2.12.2", default-features = false, features = ["napi4", "serde-json"] }
 napi-derive = "2.12.2"
-ironcalc = { path = "../../xlsx", version = "0.5.0" }
+ironcalc = { path = "../../xlsx", version = "0.6.0" }
 serde = { version = "1.0", features = ["derive"] }
 
 [build-dependencies]

bindings/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyroncalc"
-version = "0.5.7"
+version = "0.6.0"
 edition = "2021"
 
 
@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.5.0" }
+xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.6.0" }
 pyo3 = { version = "0.25", features = ["extension-module"] }
 bitcode = "0.6.3"
 

bindings/python/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ironcalc"
-version = "0.5.7"
+version = "0.6.0"
 description = "Create, edit and evaluate Excel spreadsheets"
 requires-python = ">=3.10"
 keywords = [

bindings/wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wasm"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["Nicolas Hatcher <nicolas@theuniverse.today>"]
 description = "IronCalc Web bindings"
 license = "MIT/Apache-2.0"
@@ -14,7 +14,7 @@ crate-type = ["cdylib"]
 # Uses `../ironcalc/base` when used locally, and uses
 # the inicated version from crates.io when published.
 # https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#multiple-locations
-ironcalc_base = { path = "../../base", version = "0.5", features = ["use_regex_lite"] }
+ironcalc_base = { path = "../../base", version = "0.6", features = ["use_regex_lite"] }
 serde = { version = "1.0", features = ["derive"] }
 wasm-bindgen = "0.2.100"
 serde-wasm-bindgen = "0.4"

bindings/wasm/src/lib.rs

@@ -5,7 +5,11 @@ use wasm_bindgen::{
 };
 
 use ironcalc_base::{
-    expressions::{lexer::util::get_tokens as tokenizer, types::Area, utils::number_to_column},
+    expressions::{
+        lexer::util::get_tokens as tokenizer,
+        types::Area,
+        utils::{number_to_column, quote_name as quote_name_ic},
+    },
     types::{CellType, Style},
     worksheet::NavigationDirection,
     BorderArea, ClipboardData, UserModel as BaseModel,
@@ -31,6 +35,11 @@ pub fn column_name_from_number(column: i32) -> Result<String, JsError> {
     }
 }
 
+#[wasm_bindgen(js_name = "quoteName")]
+pub fn quote_name(name: &str) -> String {
+    quote_name_ic(name)
+}
+
 #[derive(Serialize)]
 struct DefinedName {
     name: String,

docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  server:
+    image: ghcr.io/ironcalc/ironcalc-server:0.6.0
+    build:
+      context: .
+      target: server-runtime
+
+  caddy:
+    image: ghcr.io/ironcalc/ironcalc-caddy:0.6.0
+    build:
+      context: .
+      target: caddy-runtime
+    ports:
+      - "2080:2080"

docs/package.json

@@ -6,7 +6,7 @@
   },
   "devDependencies": {
     "markdown-it-mathjax3": "^4.3.2",
-    "vitepress": "^v2.0.0-alpha.8",
+    "vitepress": "^v2.0.0-alpha.12",
     "vue": "^3.5.17"
   }
 }

docs/src/features/value-types.md

@@ -68,6 +68,8 @@ Using IronCalc, a complex number is a string of the form "1+j3".
 
 ## Arrays
 
+## Ranges
+
 ## References
 
 A reference is a pointer to a single cell or a range of cells. The reference can either be entered manually, for example "A4", or as the result of a calculation, such as the OFFSET Function or the INDIRECT Function. A reference can also be built, for example with the Colon (\:) Operator. 

docs/src/functions/date-and-time.md

@@ -6,33 +6,32 @@ lang: en-US
 
 # Date and Time functions
 
-At the moment IronCalc only supports a few function in this section.  
-You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/48).
+All Date and Time functions are already supported in IronCalc.
 
 | Function         | Status                                         | Documentation |
 | ---------------- | ---------------------------------------------- | ------------- |
 | DATE             | <Badge type="tip" text="Available" />          | –             |
-| DATEDIF          | <Badge type="info" text="Not implemented yet" /> | –             |
-| DATEVALUE        | <Badge type="info" text="Not implemented yet" /> | –             |
+| DATEDIF          | <Badge type="tip" text="Available" />          | –             |
+| DATEVALUE        | <Badge type="tip" text="Available" />          | –             |
 | DAY              | <Badge type="tip" text="Available" />          | [DAY](date_and_time/day) |
-| DAYS             | <Badge type="info" text="Not implemented yet" /> | –             |
-| DAYS360          | <Badge type="info" text="Not implemented yet" /> | –             |
+| DAYS             | <Badge type="tip" text="Available" />          | –             |
+| DAYS360          | <Badge type="tip" text="Available" />          | –             |
 | EDATE            | <Badge type="tip" text="Available" />          | –             |
 | EOMONTH          | <Badge type="tip" text="Available" />          | –             |
-| HOUR             | <Badge type="info" text="Not implemented yet" /> | –             |
-| ISOWEEKNUM       | <Badge type="info" text="Not implemented yet" /> | –             |
-| MINUTE           | <Badge type="info" text="Not implemented yet" /> | –             |
+| HOUR             | <Badge type="tip" text="Available" />          | –             |
+| ISOWEEKNUM       | <Badge type="tip" text="Available" />          | –             |
+| MINUTE           | <Badge type="tip" text="Available" />          | –             |
 | MONTH            | <Badge type="tip" text="Available" />          | [MONTH](date_and_time/month) |
-| NETWORKDAYS      | <Badge type="info" text="Not implemented yet" /> | –             |
-| NETWORKDAYS.INTL | <Badge type="info" text="Not implemented yet" /> | –             |
+| NETWORKDAYS      | <Badge type="tip" text="Available" />          | [NETWORKDAYS](date_and_time/networkdays) |
+| NETWORKDAYS.INTL | <Badge type="tip" text="Available" />          | [NETWORKDAYS.INTL](date_and_time/networkdays.intl) |
 | NOW              | <Badge type="tip" text="Available" />          | –             |
-| SECOND           | <Badge type="info" text="Not implemented yet" /> | –             |
-| TIME             | <Badge type="info" text="Not implemented yet" /> | –             |
-| TIMEVALUE        | <Badge type="info" text="Not implemented yet" /> | –             |
+| SECOND           | <Badge type="tip" text="Available" />          | –             |
+| TIME             | <Badge type="tip" text="Available" />          | –             |
+| TIMEVALUE        | <Badge type="tip" text="Available" />          | –             |
 | TODAY            | <Badge type="tip" text="Available" />          | –             |
-| WEEKDAY          | <Badge type="info" text="Not implemented yet" /> | –             |
-| WEEKNUM          | <Badge type="info" text="Not implemented yet" /> | –             |
-| WORKDAY          | <Badge type="info" text="Not implemented yet" /> | –             |
-| WORKDAY.INTL     | <Badge type="info" text="Not implemented yet" /> | –             |
+| WEEKDAY          | <Badge type="tip" text="Available" />          | –             |
+| WEEKNUM          | <Badge type="tip" text="Available" />          | –             |
+| WORKDAY          | <Badge type="tip" text="Available" />          | –             |
+| WORKDAY.INTL     | <Badge type="tip" text="Available" />          | –             |
 | YEAR             | <Badge type="tip" text="Available" />          | [YEAR](date_and_time/year) |
-| YEARFRAC         | <Badge type="info" text="Not implemented yet" /> | –             |
+| YEARFRAC         | <Badge type="tip" text="Available" />          | –             |

docs/src/functions/date_and_time/datedif.md

@@ -7,6 +7,5 @@ lang: en-US
 # DATEDIF
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/datevalue.md

@@ -7,6 +7,5 @@ lang: en-US
 # DATEVALUE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/days.md

@@ -7,6 +7,5 @@ lang: en-US
 # DAYS
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/days360.md

@@ -7,6 +7,5 @@ lang: en-US
 # DAYS360
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/hour.md

@@ -7,6 +7,6 @@ lang: en-US
 # HOUR
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
+The HOUR function is implemented and available in IronCalc.
 :::

docs/src/functions/date_and_time/isoweeknum.md

@@ -7,6 +7,5 @@ lang: en-US
 # ISOWEEKNUM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/minute.md

@@ -7,6 +7,6 @@ lang: en-US
 # MINUTE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
+The MINUTE function is implemented and available in IronCalc.
 :::

docs/src/functions/date_and_time/networkdays.intl.md

@@ -4,9 +4,73 @@ outline: deep
 lang: en-US
 ---
 
-# NETWORKDAYS.INTL
+# NETWORKDAYS.INTL function
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
 :::
+
+## Overview
+NETWORKDAYS.INTL is a function of the Date and Time category that calculates the number of working days between two dates, with customizable weekend definitions and optionally specified holidays.
+
+## Usage
+
+### Syntax
+**NETWORKDAYS.INTL(<span title="Number" style="color:#1E88E5">start_date</span>, <span title="Number" style="color:#1E88E5">end_date</span>, [<span title="Number or String" style="color:#4CAF50">weekend</span>], [<span title="Array" style="color:#E91E63">holidays</span>]) => <span title="Number" style="color:#1E88E5">workdays</span>**
+
+### Argument descriptions
+* *start_date* ([number](/features/value-types#numbers), required). The start date expressed as a [serial number](/features/serial-numbers.md).
+* *end_date* ([number](/features/value-types#numbers), required). The end date expressed as a [serial number](/features/serial-numbers.md).
+* *weekend* ([number](/features/value-types#numbers) or [string](/features/value-types#strings), optional). Defines which days are considered weekends. Default is 1 (Saturday-Sunday).
+* *holidays* ([array](/features/value-types#arrays) or [range](/features/value-types#ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
+
+### Weekend parameter options
+The _weekend_ parameter can be specified in two ways:
+
+**Numeric codes:**
+- 1 (default): Saturday and Sunday
+- 2: Sunday and Monday
+- 3: Monday and Tuesday
+- 4: Tuesday and Wednesday
+- 5: Wednesday and Thursday
+- 6: Thursday and Friday
+- 7: Friday and Saturday
+- 11: Sunday only
+- 12: Monday only
+- 13: Tuesday only
+- 14: Wednesday only
+- 15: Thursday only
+- 16: Friday only
+- 17: Saturday only
+
+**String pattern:** A 7-character string of "0" and "1" where "1" indicates a weekend day. The string represents Monday through Sunday. For example, "0000011" means Saturday and Sunday are weekends.
+
+### Additional guidance
+- If the supplied _start_date_ and _end_date_ arguments have fractional parts, NETWORKDAYS.INTL uses their [floor values](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions).
+- If _start_date_ is later than _end_date_, the function returns a negative number.
+- Empty cells in the _holidays_ array are ignored.
+- The calculation includes both the start and end dates if they are workdays.
+
+### Returned value
+NETWORKDAYS.INTL returns a [number](/features/value-types#numbers) representing the count of working days between the two dates.
+
+### Error conditions
+* In common with many other IronCalc functions, NETWORKDAYS.INTL propagates errors that are found in its arguments.
+* If fewer than 2 or more than 4 arguments are supplied, then NETWORKDAYS.INTL returns the [`#ERROR!`](/features/error-types.md#error) error.
+* If the *start_date* or *end_date* arguments are not (or cannot be converted to) [numbers](/features/value-types#numbers), then NETWORKDAYS.INTL returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *start_date* or *end_date* values are outside the valid date range, then NETWORKDAYS.INTL returns the [`#NUM!`](/features/error-types.md#num) error.
+* If the *weekend* parameter is an invalid numeric code or an improperly formatted string, then NETWORKDAYS.INTL returns the [`#NUM!`](/features/error-types.md#num) or [`#VALUE!`](/features/error-types.md#value) error.
+* If the *holidays* array contains non-numeric values, then NETWORKDAYS.INTL returns the [`#VALUE!`](/features/error-types.md#value) error.
+
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+
+## Details
+IronCalc utilizes Rust's [chrono](https://docs.rs/chrono/latest/chrono/) crate to implement the NETWORKDAYS.INTL function. This function provides more flexibility than NETWORKDAYS by allowing custom weekend definitions.
+
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=networkdays-intl).
+
+## Links
+* See also IronCalc's [NETWORKDAYS](/functions/date_and_time/networkdays.md) function for the basic version with fixed weekends.
+* Visit Microsoft Excel's [NETWORKDAYS.INTL function](https://support.microsoft.com/en-us/office/networkdays-intl-function-a9b26239-4f20-46a1-9ab8-4e925bfd5e28) page.
+* Both [Google Sheets](https://support.google.com/docs/answer/3093019) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/NETWORKDAYS.INTL) provide versions of the NETWORKDAYS.INTL function.

docs/src/functions/date_and_time/networkdays.md

@@ -4,9 +4,51 @@ outline: deep
 lang: en-US
 ---
 
-# NETWORKDAYS
+# NETWORKDAYS function
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
 :::
+
+## Overview
+NETWORKDAYS is a function of the Date and Time category that calculates the number of working days between two dates, excluding weekends (Saturday and Sunday by default) and optionally specified holidays.
+
+## Usage
+
+### Syntax
+**NETWORKDAYS(<span title="Number" style="color:#1E88E5">start_date</span>, <span title="Number" style="color:#1E88E5">end_date</span>, [<span title="Array" style="color:#E91E63">holidays</span>]) => <span title="Number" style="color:#1E88E5">workdays</span>**
+
+### Argument descriptions
+* *start_date* ([number](/features/value-types#numbers), required). The start date expressed as a [serial number](/features/serial-numbers.md).
+* *end_date* ([number](/features/value-types#numbers), required). The end date expressed as a [serial number](/features/serial-numbers.md).
+* *holidays* ([array](/features/value-types#arrays) or [range](/features/value-types#ranges), optional). A list of dates to exclude from the calculation, expressed as serial numbers.
+
+### Additional guidance
+- If the supplied _start_date_ and _end_date_ arguments have fractional parts, NETWORKDAYS uses their [floor values](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions).
+- If _start_date_ is later than _end_date_, the function returns a negative number.
+- Weekend days are Saturday and Sunday by default. Use [NETWORKDAYS.INTL](networkdays.intl) for custom weekend definitions.
+- Empty cells in the _holidays_ array are ignored.
+- The calculation includes both the start and end dates if they are workdays.
+
+### Returned value
+NETWORKDAYS returns a [number](/features/value-types#numbers) representing the count of working days between the two dates.
+
+### Error conditions
+* In common with many other IronCalc functions, NETWORKDAYS propagates errors that are found in its arguments.
+* If fewer than 2 or more than 3 arguments are supplied, then NETWORKDAYS returns the [`#ERROR!`](/features/error-types.md#error) error.
+* If the *start_date* or *end_date* arguments are not (or cannot be converted to) [numbers](/features/value-types#numbers), then NETWORKDAYS returns the [`#VALUE!`](/features/error-types.md#value) error.
+* If the *start_date* or *end_date* values are outside the valid date range, then NETWORKDAYS returns the [`#NUM!`](/features/error-types.md#num) error.
+* If the *holidays* array contains non-numeric values, then NETWORKDAYS returns the [`#VALUE!`](/features/error-types.md#value) error.
+
+<!--@include: ../markdown-snippets/error-type-details.txt-->
+
+## Details
+IronCalc utilizes Rust's [chrono](https://docs.rs/chrono/latest/chrono/) crate to implement the NETWORKDAYS function. The function treats Saturday and Sunday as weekend days.
+
+## Examples
+[See some examples in IronCalc](https://app.ironcalc.com/?example=networkdays).
+
+## Links
+* See also IronCalc's [NETWORKDAYS.INTL](/functions/date_and_time/networkdays.intl.md) function for custom weekend definitions.
+* Visit Microsoft Excel's [NETWORKDAYS function](https://support.microsoft.com/en-us/office/networkdays-function-48e717bf-a7a3-495f-969e-5005e3eb18e7) page.
+* Both [Google Sheets](https://support.google.com/docs/answer/3093018) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/NETWORKDAYS) provide versions of the NETWORKDAYS function.

docs/src/functions/date_and_time/second.md

@@ -7,6 +7,6 @@ lang: en-US
 # SECOND
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
+The SECOND function is implemented and available in IronCalc.
 :::

docs/src/functions/date_and_time/time.md

@@ -7,6 +7,6 @@ lang: en-US
 # TIME
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
+The TIME function is implemented and available in IronCalc.
 :::

docs/src/functions/date_and_time/timevalue.md

@@ -7,6 +7,6 @@ lang: en-US
 # TIMEVALUE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+**Note:** This draft page is under construction 🚧
+The TIMEVALUE function is implemented and available in IronCalc.
 :::

docs/src/functions/date_and_time/weekday.md

@@ -7,6 +7,5 @@ lang: en-US
 # WEEKDAY
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/weeknum.md

@@ -7,6 +7,5 @@ lang: en-US
 # WEEKNUM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/workday.intl.md

@@ -7,6 +7,5 @@ lang: en-US
 # WORKDAY.INTL
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/workday.md

@@ -7,6 +7,5 @@ lang: en-US
 # WORKDAY
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/date_and_time/yearfrac.md

@@ -7,6 +7,5 @@ lang: en-US
 # YEARFRAC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial.md

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

docs/src/functions/financial/accrint.md

@@ -7,6 +7,5 @@ lang: en-US
 # ACCRINT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/accrintm.md

@@ -7,6 +7,5 @@ lang: en-US
 # ACCRINTM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/coupdaybs.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYBS
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/coupdays.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYS
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/coupdaysnc.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPDAYSNC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/coupncd.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPNCD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/coupnum.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPNUM
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/couppcd.md

@@ -7,6 +7,5 @@ lang: en-US
 # COUPPCD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/disc.md

@@ -7,6 +7,5 @@ lang: en-US
 # DISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/duration.md

@@ -7,6 +7,5 @@ lang: en-US
 # DURATION
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/fvschedule.md

@@ -7,6 +7,5 @@ lang: en-US
 # FVSCHEDULE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/intrate.md

@@ -7,6 +7,5 @@ lang: en-US
 # INTRATE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/mduration.md

@@ -7,6 +7,5 @@ lang: en-US
 # MDURATION
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/price.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICE
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/pricedisc.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICEDISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/pricemat.md

@@ -7,6 +7,5 @@ lang: en-US
 # PRICEMAT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/received.md

@@ -7,6 +7,5 @@ lang: en-US
 # RECEIVED
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/yield.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELD
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/yielddisc.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELDDISC
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/functions/financial/yieldmat.md

@@ -7,6 +7,5 @@ lang: en-US
 # YIELDMAT
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
+🚧 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).
 :::

docs/src/web-application/managing-workbooks.md

@@ -0,0 +1,18 @@
+---
+layout: doc
+outline: deep
+lang: en-US
+---
+
+# Managing Workbooks
+
+All your created sheets can be accessed from the **Workbook Sidebar**. To display it, click the button in the top-left corner of the window. From there, you can:
+
+- View all existing workbooks, ordered by date (today, last 30 days, and older)
+- Create new blank workbooks
+- Download the existing workbook as .xlsx
+- Pin workbooks to the top of the list
+- Duplicate workbooks
+- Delete workbooks
+
+This helps you keep your workbooks organized and makes sharing simple and straightforward.

docs/src/web-application/sharing-files.md

@@ -26,12 +26,3 @@ IronCalc makes it easy to share your files with others. Follow these steps to sh
 
 - **Changes in the Shared Version**:  
   Any modifications made in the shared sheet (even if it’s an existing sheet) will **not** overwrite or affect the original sheet.
-
-## Managing Sheets
-
-All your created sheets can be accessed from the **"File"** section in the top-left corner of the window. From here, you can:
-
-- View all existing sheets.
-- Delete sheets as needed.
-
-This helps you keep your files organized and makes sharing simple and straightforward.