fix: mobile adjustments

update: add data-storage warnings to the app

.github/workflows/pypi.yml

@@ -32,9 +32,9 @@ jobs:
           manylinux: auto
           working-directory: bindings/python
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
           path: bindings/python/dist
 
   windows:
@@ -56,9 +56,9 @@ jobs:
           sccache: 'true'
           working-directory: bindings/python
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
           path: bindings/python/dist
 
   macos:
@@ -79,9 +79,9 @@ jobs:
           sccache: 'true'
           working-directory: bindings/python
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
           path: bindings/python/dist
 
   sdist:
@@ -95,9 +95,9 @@ jobs:
           args: --out dist
           working-directory: bindings/python
       - name: Upload sdist
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ runner.os }}-sdist
           path: bindings/python/dist
 
   publish-to-test-pypi:
@@ -107,9 +107,8 @@ jobs:
     runs-on: ubuntu-latest
     needs: [linux, windows, macos, sdist]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: wheels
           path: bindings/python/
       - name: Publish distribution 📦 to Test PyPI
         uses: PyO3/maturin-action@v1
@@ -118,7 +117,7 @@ jobs:
           MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
         with:
           command: upload
-          args: --skip-existing *
+          args: "--skip-existing **/*.whl **/*.tar.gz"
           working-directory: bindings/python
 
   publish-pypi:
@@ -128,9 +127,8 @@ jobs:
     runs-on: ubuntu-latest
     needs: [linux, windows, macos, sdist]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: wheels
           path: bindings/python/
       - name: Publish distribution 📦 to PyPI
         uses: PyO3/maturin-action@v1
@@ -139,5 +137,5 @@ jobs:
           MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
         with:
           command: upload
-          args: --skip-existing *
+          args: "--skip-existing **/*.whl **/*.tar.gz"
           working-directory: bindings/python

Cargo.lock

@@ -43,6 +43,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -414,7 +423,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.3.0"
+version = "0.6.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -430,25 +439,25 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.3.0"
+version = "0.6.0"
 dependencies = [
  "bitcode",
  "chrono",
  "chrono-tz",
  "csv",
  "js-sys",
- "once_cell",
  "rand",
  "regex",
  "regex-lite",
  "ryu",
  "serde",
  "serde_json",
+ "statrs",
 ]
 
 [[package]]
 name = "ironcalc_nodejs"
-version = "0.3.1"
+version = "0.6.0"
 dependencies = [
  "ironcalc",
  "napi",
@@ -721,11 +730,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
+checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -739,9 +747,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
+checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -749,9 +757,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
+checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -759,9 +767,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
+checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -771,9 +779,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
+checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -784,8 +792,9 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.3.0"
+version = "0.6.0"
 dependencies = [
+ "bitcode",
  "ironcalc",
  "pyo3",
  "serde",
@@ -872,6 +881,12 @@ version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
 
+[[package]]
+name = "rustversion"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
+
 [[package]]
 name = "ryu"
 version = "1.0.17"
@@ -960,6 +975,16 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
+[[package]]
+name = "statrs"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e"
+dependencies = [
+ "approx",
+ "num-traits",
+]
+
 [[package]]
 name = "subtle"
 version = "2.5.0"
@@ -979,9 +1004,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "thiserror"
@@ -1070,7 +1095,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.3.2"
+version = "0.6.0"
 dependencies = [
  "ironcalc_base",
  "serde",
@@ -1081,23 +1106,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -1118,9 +1144,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1128,9 +1154,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1141,9 +1167,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasm-bindgen-test"

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
 
@@ -77,14 +87,14 @@ And visit <http://0.0.0.0:8000/ironcalc/>
 Add the dependency to `Cargo.toml`:
 ```toml
 [dependencies]
-ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
+ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.5"}
 ```
 
 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.3.0"
+version = "0.6.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
@@ -17,9 +17,9 @@ chrono = "0.4"
 chrono-tz = "0.10"
 regex = { version = "1.0", optional = true}
 regex-lite = { version = "0.1.6", optional = true}
-once_cell = "1.16.0"
 bitcode = "0.6.3"
 csv = "1.3.0"
+statrs = { version = "0.18.0", default-features = false, features = [] }
 
 [features]
 default = ["use_regex_full"]

base/src/actions.rs

@@ -1,5 +1,6 @@
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::stringify::DisplaceData;
+use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
+use crate::expressions::types::CellReferenceRC;
 use crate::model::Model;
 
 // NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
@@ -8,16 +9,45 @@ use crate::model::Model;
 // I feel this is unimportant for now.
 
 impl Model {
+    fn shift_cell_formula(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        displace_data: &DisplaceData,
+    ) -> Result<(), String> {
+        if let Some(f) = self
+            .workbook
+            .worksheet(sheet)?
+            .cell(row, column)
+            .and_then(|c| c.get_formula())
+        {
+            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
+            let cell_reference = CellReferenceRC {
+                sheet: self.workbook.worksheets[sheet as usize].get_name(),
+                row,
+                column,
+            };
+            // FIXME: This is not a very performant way if the formula has changed :S.
+            let formula = to_string(node, &cell_reference);
+            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
+            if formula != formula_displaced {
+                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
+            }
+        }
+        Ok(())
+    }
     /// This function iterates over all cells in the model and shifts their formulas according to the displacement data.
     ///
     /// # Arguments
     ///
     /// * `displace_data` - A reference to `DisplaceData` describing the displacement's direction and magnitude.
-    fn displace_cells(&mut self, displace_data: &DisplaceData) {
+    fn displace_cells(&mut self, displace_data: &DisplaceData) -> Result<(), String> {
         let cells = self.get_all_cells();
         for cell in cells {
-            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data);
+            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data)?;
         }
+        Ok(())
     }
 
     /// Retrieves the column indices for a specific row in a given sheet, sorted in ascending or descending order.
@@ -134,7 +164,7 @@ impl Model {
                 column,
                 delta: column_count,
             }),
-        );
+        )?;
 
         // In the list of columns:
         // * Keep all the columns to the left
@@ -182,6 +212,12 @@ impl Model {
         if column_count <= 0 {
             return Err("Please use insert columns instead".to_string());
         }
+        if !(1..=LAST_COLUMN).contains(&column) {
+            return Err(format!("Column number '{column}' is not valid."));
+        }
+        if column + column_count - 1 > LAST_COLUMN {
+            return Err("Cannot delete columns beyond the last column of the sheet".to_string());
+        }
 
         // first column being deleted
         let column_start = column;
@@ -214,7 +250,7 @@ impl Model {
                 column,
                 delta: -column_count,
             }),
-        );
+        )?;
         let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
 
         // deletes all the column styles
@@ -338,7 +374,7 @@ impl Model {
                 row,
                 delta: row_count,
             }),
-        );
+        )?;
 
         Ok(())
     }
@@ -354,6 +390,13 @@ impl Model {
         if row_count <= 0 {
             return Err("Please use insert rows instead".to_string());
         }
+        if !(1..=LAST_ROW).contains(&row) {
+            return Err(format!("Row number '{row}' is not valid."));
+        }
+        if row + row_count - 1 > LAST_ROW {
+            return Err("Cannot delete rows beyond the last row of the sheet".to_string());
+        }
+
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -399,7 +442,7 @@ impl Model {
                 row,
                 delta: -row_count,
             }),
-        );
+        )?;
         Ok(())
     }
 
@@ -414,23 +457,86 @@ impl Model {
     ///    * Column is one of the extremes of the range. The new extreme would be target_column.
     ///      Range is then normalized
     ///    * Any other case, range is left unchanged.
-    ///      NOTE: This does NOT move the data in the columns or move the colum styles
+    ///      NOTE: This moves the data and column styles along with the formulas
     pub fn move_column_action(
         &mut self,
         sheet: u32,
         column: i32,
         delta: i32,
-    ) -> Result<(), &'static str> {
+    ) -> Result<(), String> {
         // Check boundaries
         let target_column = column + delta;
         if !(1..=LAST_COLUMN).contains(&target_column) {
-            return Err("Target column out of boundaries");
+            return Err("Target column out of boundaries".to_string());
         }
         if !(1..=LAST_COLUMN).contains(&column) {
-            return Err("Initial column out of boundaries");
+            return Err("Initial column out of boundaries".to_string());
         }
 
-        // TODO: Add the actual displacement of data and styles
+        if delta == 0 {
+            return Ok(());
+        }
+
+        // Preserve cell contents, width and style of the column being moved
+        let original_refs = self
+            .workbook
+            .worksheet(sheet)?
+            .column_cell_references(column)?;
+        let mut original_cells = Vec::new();
+        for r in &original_refs {
+            let cell = self
+                .workbook
+                .worksheet(sheet)?
+                .cell(r.row, column)
+                .ok_or("Expected Cell to exist")?;
+            let style_idx = cell.get_style();
+            let formula_or_value = self
+                .get_cell_formula(sheet, r.row, column)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
+            original_cells.push((r.row, formula_or_value, style_idx));
+            self.cell_clear_all(sheet, r.row, column)?;
+        }
+
+        let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
+        let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
+
+        if delta > 0 {
+            for c in column + 1..=target_column {
+                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
+                for r in refs {
+                    self.move_cell(sheet, r.row, c, r.row, c - 1)?;
+                }
+
+                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
+                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .set_column_width_and_style(c - 1, w, s)?;
+            }
+        } else {
+            for c in (target_column..=column - 1).rev() {
+                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
+                for r in refs {
+                    self.move_cell(sheet, r.row, c, r.row, c + 1)?;
+                }
+
+                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
+                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .set_column_width_and_style(c + 1, w, s)?;
+            }
+        }
+
+        for (r, value, style_idx) in original_cells {
+            self.set_user_input(sheet, r, target_column, value)?;
+            self.workbook
+                .worksheet_mut(sheet)?
+                .set_cell_style(r, target_column, style_idx)?;
+        }
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_column_width_and_style(target_column, width, style)?;
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -439,7 +545,91 @@ impl Model {
                 column,
                 delta,
             }),
-        );
+        )?;
+
+        Ok(())
+    }
+
+    /// Displaces cells due to a move row action
+    /// from initial_row to target_row = initial_row + row_delta
+    /// References will be updated following the same rules as move_column_action
+    /// NOTE: This moves the data and row styles along with the formulas
+    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
+        // Check boundaries
+        let target_row = row + delta;
+        if !(1..=LAST_ROW).contains(&target_row) {
+            return Err("Target row out of boundaries".to_string());
+        }
+        if !(1..=LAST_ROW).contains(&row) {
+            return Err("Initial row out of boundaries".to_string());
+        }
+
+        if delta == 0 {
+            return Ok(());
+        }
+
+        let original_cols = self.get_columns_for_row(sheet, row, false)?;
+        let mut original_cells = Vec::new();
+        for c in &original_cols {
+            let cell = self
+                .workbook
+                .worksheet(sheet)?
+                .cell(row, *c)
+                .ok_or("Expected Cell to exist")?;
+            let style_idx = cell.get_style();
+            let formula_or_value = self
+                .get_cell_formula(sheet, row, *c)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
+            original_cells.push((*c, formula_or_value, style_idx));
+            self.cell_clear_all(sheet, row, *c)?;
+        }
+
+        if delta > 0 {
+            for r in row + 1..=target_row {
+                let cols = self.get_columns_for_row(sheet, r, false)?;
+                for c in cols {
+                    self.move_cell(sheet, r, c, r - 1, c)?;
+                }
+            }
+        } else {
+            for r in (target_row..=row - 1).rev() {
+                let cols = self.get_columns_for_row(sheet, r, false)?;
+                for c in cols {
+                    self.move_cell(sheet, r, c, r + 1, c)?;
+                }
+            }
+        }
+
+        for (c, value, style_idx) in original_cells {
+            self.set_user_input(sheet, target_row, c, value)?;
+            self.workbook
+                .worksheet_mut(sheet)?
+                .set_cell_style(target_row, c, style_idx)?;
+        }
+
+        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
+        let mut new_rows = Vec::new();
+        for r in worksheet.rows.iter() {
+            if r.r == row {
+                let mut nr = r.clone();
+                nr.r = target_row;
+                new_rows.push(nr);
+            } else if delta > 0 && r.r > row && r.r <= target_row {
+                let mut nr = r.clone();
+                nr.r -= 1;
+                new_rows.push(nr);
+            } else if delta < 0 && r.r < row && r.r >= target_row {
+                let mut nr = r.clone();
+                nr.r += 1;
+                new_rows.push(nr);
+            } else {
+                new_rows.push(r.clone());
+            }
+        }
+        worksheet.rows = new_rows;
+
+        // Update all formulas in the workbook
+        self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
 
         Ok(())
     }

base/src/arithmetic.rs

@@ -0,0 +1,158 @@
+use crate::{
+    calc_result::CalcResult,
+    cast::NumberOrArray,
+    expressions::{
+        parser::{ArrayNode, Node},
+        token::Error,
+        types::CellReferenceIndex,
+    },
+    model::Model,
+};
+
+/// Unify how we map booleans/strings to f64
+fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
+    match value {
+        ArrayNode::Number(f) => Ok(*f),
+        ArrayNode::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
+        ArrayNode::String(s) => match s.parse::<f64>() {
+            Ok(f) => Ok(f),
+            Err(_) => Err(Error::VALUE),
+        },
+        ArrayNode::Error(err) => Err(err.clone()),
+    }
+}
+
+impl Model {
+    /// Applies `op` element‐wise for arrays/numbers.
+    pub(crate) fn handle_arithmetic(
+        &mut self,
+        left: &Node,
+        right: &Node,
+        cell: CellReferenceIndex,
+        op: &dyn Fn(f64, f64) -> Result<f64, Error>,
+    ) -> CalcResult {
+        let l = match self.get_number_or_array(left, cell) {
+            Ok(f) => f,
+            Err(s) => {
+                return s;
+            }
+        };
+        let r = match self.get_number_or_array(right, cell) {
+            Ok(f) => f,
+            Err(s) => {
+                return s;
+            }
+        };
+        match (l, r) {
+            // -----------------------------------------------------
+            // Case 1: Both are numbers
+            // -----------------------------------------------------
+            (NumberOrArray::Number(f1), NumberOrArray::Number(f2)) => match op(f1, f2) {
+                Ok(x) => CalcResult::Number(x),
+                Err(Error::DIV) => CalcResult::Error {
+                    error: Error::DIV,
+                    origin: cell,
+                    message: "Divide by 0".to_string(),
+                },
+                Err(Error::VALUE) => CalcResult::Error {
+                    error: Error::VALUE,
+                    origin: cell,
+                    message: "Invalid number".to_string(),
+                },
+                Err(e) => CalcResult::Error {
+                    error: e,
+                    origin: cell,
+                    message: "Unknown error".to_string(),
+                },
+            },
+
+            // -----------------------------------------------------
+            // Case 2: left is Number, right is Array
+            // -----------------------------------------------------
+            (NumberOrArray::Number(f1), NumberOrArray::Array(a2)) => {
+                let mut array = Vec::new();
+                for row in a2 {
+                    let mut data_row = Vec::new();
+                    for node in row {
+                        match to_f64(&node) {
+                            Ok(f2) => match op(f1, f2) {
+                                Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
+                                Err(e) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            Err(err) => data_row.push(ArrayNode::Error(err)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+
+            // -----------------------------------------------------
+            // Case 3: left is Array, right is Number
+            // -----------------------------------------------------
+            (NumberOrArray::Array(a1), NumberOrArray::Number(f2)) => {
+                let mut array = Vec::new();
+                for row in a1 {
+                    let mut data_row = Vec::new();
+                    for node in row {
+                        match to_f64(&node) {
+                            Ok(f1) => match op(f1, f2) {
+                                Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
+                                Err(e) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            Err(err) => data_row.push(ArrayNode::Error(err)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+
+            // -----------------------------------------------------
+            // Case 4: Both are arrays
+            // -----------------------------------------------------
+            (NumberOrArray::Array(a1), NumberOrArray::Array(a2)) => {
+                let n1 = a1.len();
+                let m1 = a1.first().map(|r| r.len()).unwrap_or(0);
+                let n2 = a2.len();
+                let m2 = a2.first().map(|r| r.len()).unwrap_or(0);
+                let n = n1.max(n2);
+                let m = m1.max(m2);
+
+                let mut array = Vec::new();
+                for i in 0..n {
+                    let row1 = a1.get(i);
+                    let row2 = a2.get(i);
+
+                    let mut data_row = Vec::new();
+                    for j in 0..m {
+                        let val1 = row1.and_then(|r| r.get(j));
+                        let val2 = row2.and_then(|r| r.get(j));
+
+                        match (val1, val2) {
+                            (Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
+                                (Ok(f1), Ok(f2)) => match op(f1, f2) {
+                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                    Err(Error::VALUE) => {
+                                        data_row.push(ArrayNode::Error(Error::VALUE))
+                                    }
+                                    Err(e) => data_row.push(ArrayNode::Error(e)),
+                                },
+                                (Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            // Mismatched dimensions => #VALUE!
+                            _ => data_row.push(ArrayNode::Error(Error::VALUE)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+        }
+    }
+}

base/src/calc_result.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 
-use crate::expressions::{token::Error, types::CellReferenceIndex};
+use crate::expressions::{parser::ArrayNode, token::Error, types::CellReferenceIndex};
 
 #[derive(Clone)]
 pub struct Range {
@@ -24,6 +24,7 @@ pub(crate) enum CalcResult {
     },
     EmptyCell,
     EmptyArg,
+    Array(Vec<Vec<ArrayNode>>),
 }
 
 impl CalcResult {

base/src/cast.rs

@@ -1,11 +1,103 @@
 use crate::{
     calc_result::{CalcResult, Range},
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
-    implicit_intersection::implicit_intersection,
+    expressions::{
+        parser::{ArrayNode, Node},
+        token::Error,
+        types::CellReferenceIndex,
+    },
+    formatter::format::parse_formatted_number,
     model::Model,
 };
 
+pub(crate) enum NumberOrArray {
+    Number(f64),
+    Array(Vec<Vec<ArrayNode>>),
+}
+
 impl Model {
+    pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
+        match s.trim().parse::<f64>() {
+            Ok(f) => Some(f),
+            _ => {
+                let currency = &self.locale.currency.symbol;
+                let mut currencies = vec!["$", "€"];
+                if !currencies.iter().any(|e| *e == currency) {
+                    currencies.push(currency);
+                }
+                // Try to parse as a formatted number (e.g., dates, currencies, percentages)
+                if let Ok((v, _number_format)) = parse_formatted_number(s, &currencies) {
+                    return Some(v);
+                }
+                None
+            }
+        }
+    }
+    pub(crate) fn get_number_or_array(
+        &mut self,
+        node: &Node,
+        cell: CellReferenceIndex,
+    ) -> Result<NumberOrArray, CalcResult> {
+        match self.evaluate_node_in_context(node, cell) {
+            CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
+            CalcResult::String(s) => match self.cast_number(&s) {
+                Some(f) => Ok(NumberOrArray::Number(f)),
+                None => Err(CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Expecting number".to_string(),
+                )),
+            },
+            CalcResult::Boolean(f) => {
+                if f {
+                    Ok(NumberOrArray::Number(1.0))
+                } else {
+                    Ok(NumberOrArray::Number(0.0))
+                }
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(NumberOrArray::Number(0.0)),
+            CalcResult::Range { left, right } => {
+                let sheet = left.sheet;
+                if sheet != right.sheet {
+                    return Err(CalcResult::Error {
+                        error: Error::ERROR,
+                        origin: cell,
+                        message: "3D ranges are not allowed".to_string(),
+                    });
+                }
+                // we need to convert the range into an array
+                let mut array = Vec::new();
+                for row in left.row..=right.row {
+                    let mut row_data = Vec::new();
+                    for column in left.column..=right.column {
+                        let value =
+                            match self.evaluate_cell(CellReferenceIndex { sheet, column, row }) {
+                                CalcResult::String(s) => ArrayNode::String(s),
+                                CalcResult::Number(f) => ArrayNode::Number(f),
+                                CalcResult::Boolean(b) => ArrayNode::Boolean(b),
+                                CalcResult::Error { error, .. } => ArrayNode::Error(error),
+                                CalcResult::Range { .. } => {
+                                    // if we do things right this can never happen.
+                                    // the evaluation of a cell should never return a range
+                                    ArrayNode::Number(0.0)
+                                }
+                                CalcResult::EmptyCell => ArrayNode::Number(0.0),
+                                CalcResult::EmptyArg => ArrayNode::Number(0.0),
+                                CalcResult::Array(_) => {
+                                    // if we do things right this can never happen.
+                                    // the evaluation of a cell should never return an array
+                                    ArrayNode::Number(0.0)
+                                }
+                            };
+                        row_data.push(value);
+                    }
+                    array.push(row_data);
+                }
+                Ok(NumberOrArray::Array(array))
+            }
+            CalcResult::Array(s) => Ok(NumberOrArray::Array(s)),
+            error @ CalcResult::Error { .. } => Err(error),
+        }
+    }
     pub(crate) fn get_number(
         &mut self,
         node: &Node,
@@ -15,16 +107,16 @@ impl Model {
         self.cast_to_number(result, cell)
     }
 
-    fn cast_to_number(
+    pub(crate) fn cast_to_number(
         &mut self,
         result: CalcResult,
         cell: CellReferenceIndex,
     ) -> Result<f64, CalcResult> {
         match result {
             CalcResult::Number(f) => Ok(f),
-            CalcResult::String(s) => match s.parse::<f64>() {
-                Ok(f) => Ok(f),
-                _ => Err(CalcResult::new_error(
+            CalcResult::String(s) => match self.cast_number(&s) {
+                Some(f) => Ok(f),
+                None => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),
@@ -39,19 +131,16 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_number(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (number)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 
@@ -88,7 +177,7 @@ impl Model {
         // FIXME: I think when casting a number we should convert it to_precision(x, 15)
         // See function Exact
         match result {
-            CalcResult::Number(f) => Ok(format!("{}", f)),
+            CalcResult::Number(f) => Ok(format!("{f}")),
             CalcResult::String(s) => Ok(s),
             CalcResult::Boolean(f) => {
                 if f {
@@ -99,19 +188,16 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_string(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (string)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 
@@ -151,19 +237,16 @@ impl Model {
             CalcResult::Boolean(b) => Ok(b),
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_bool(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (bool)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 

base/src/diffs.rs

@@ -1,138 +0,0 @@
-use crate::{
-    expressions::{
-        parser::{
-            move_formula::ref_is_in_area,
-            stringify::{to_string, to_string_displaced, DisplaceData},
-            walk::forward_references,
-        },
-        types::{Area, CellReferenceIndex, CellReferenceRC},
-    },
-    model::Model,
-};
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-#[serde(untagged, deny_unknown_fields)]
-pub enum CellValue {
-    Value(String),
-    None,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct SetCellValue {
-    cell: CellReferenceIndex,
-    new_value: CellValue,
-    old_value: CellValue,
-}
-
-impl Model {
-    #[allow(clippy::expect_used)]
-    pub(crate) fn shift_cell_formula(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        displace_data: &DisplaceData,
-    ) {
-        if let Some(f) = self
-            .workbook
-            .worksheet(sheet)
-            .expect("Worksheet must exist")
-            .cell(row, column)
-            .expect("Cell must exist")
-            .get_formula()
-        {
-            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
-            let cell_reference = CellReferenceRC {
-                sheet: self.workbook.worksheets[sheet as usize].get_name(),
-                row,
-                column,
-            };
-            // FIXME: This is not a very performant way if the formula has changed :S.
-            let formula = to_string(node, &cell_reference);
-            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
-            if formula != formula_displaced {
-                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))
-                    .expect("Failed to shift cell formula");
-            }
-        }
-    }
-
-    #[allow(clippy::expect_used)]
-    pub fn forward_references(
-        &mut self,
-        source_area: &Area,
-        target: &CellReferenceIndex,
-    ) -> Result<Vec<SetCellValue>, String> {
-        let mut diff_list: Vec<SetCellValue> = Vec::new();
-        let target_area = &Area {
-            sheet: target.sheet,
-            row: target.row,
-            column: target.column,
-            width: source_area.width,
-            height: source_area.height,
-        };
-        // Walk over every formula
-        let cells = self.get_all_cells();
-        for cell in cells {
-            if let Some(f) = self
-                .workbook
-                .worksheet(cell.index)
-                .expect("Worksheet must exist")
-                .cell(cell.row, cell.column)
-                .expect("Cell must exist")
-                .get_formula()
-            {
-                let sheet = cell.index;
-                let row = cell.row;
-                let column = cell.column;
-
-                // If cell is in the source or target area, skip
-                if ref_is_in_area(sheet, row, column, source_area)
-                    || ref_is_in_area(sheet, row, column, target_area)
-                {
-                    continue;
-                }
-
-                // Get the formula
-                // Get a copy of the AST
-                let node = &mut self.parsed_formulas[sheet as usize][f as usize].clone();
-                let cell_reference = CellReferenceRC {
-                    sheet: self.workbook.worksheets[sheet as usize].get_name(),
-                    column: cell.column,
-                    row: cell.row,
-                };
-                let context = CellReferenceIndex { sheet, column, row };
-                let formula = to_string(node, &cell_reference);
-                let target_sheet_name = &self.workbook.worksheets[target.sheet as usize].name;
-                forward_references(
-                    node,
-                    &context,
-                    source_area,
-                    target.sheet,
-                    target_sheet_name,
-                    target.row,
-                    target.column,
-                );
-
-                // If the string representation of the formula has changed update the cell
-                let updated_formula = to_string(node, &cell_reference);
-                if formula != updated_formula {
-                    self.update_cell_with_formula(
-                        sheet,
-                        row,
-                        column,
-                        format!("={updated_formula}"),
-                    )?;
-                    // Update the diff list
-                    diff_list.push(SetCellValue {
-                        cell: CellReferenceIndex { sheet, column, row },
-                        new_value: CellValue::Value(format!("={}", updated_formula)),
-                        old_value: CellValue::Value(format!("={}", formula)),
-                    });
-                }
-            }
-        }
-        Ok(diff_list)
-    }
-}

base/src/expressions/lexer/mod.rs

@@ -142,7 +142,7 @@ impl Lexer {
     pub fn expect(&mut self, tk: TokenType) -> Result<()> {
         let nt = self.next_token();
         if mem::discriminant(&nt) != mem::discriminant(&tk) {
-            return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
+            return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position));
         }
         Ok(())
     }
@@ -187,6 +187,7 @@ impl Lexer {
                     ']' => TokenType::RightBracket,
                     ':' => TokenType::Colon,
                     ';' => TokenType::Semicolon,
+                    '@' => TokenType::At,
                     ',' => {
                         if self.locale.numbers.symbols.decimal == "," {
                             match self.consume_number(',') {
@@ -313,6 +314,9 @@ impl Lexer {
                             } else if name_upper == self.language.booleans.r#false {
                                 return TokenType::Boolean(false);
                             }
+                            if self.peek_char() == Some('(') {
+                                return TokenType::Ident(name);
+                            }
                             if self.mode == LexerMode::A1 {
                                 let parsed_reference = utils::parse_reference_a1(&name_upper);
                                 if parsed_reference.is_some()
@@ -510,7 +514,7 @@ impl Lexer {
         self.position = position;
         chars.parse::<i32>().map_err(|_| LexerError {
             position,
-            message: format!("Failed to parse to int: {}", chars),
+            message: format!("Failed to parse to int: {chars}"),
         })
     }
 
@@ -571,9 +575,7 @@ impl Lexer {
         }
         self.position = position;
         match chars.parse::<f64>() {
-            Err(_) => {
-                Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
-            }
+            Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
             Ok(v) => Ok(v),
         }
     }

base/src/expressions/lexer/ranges.rs

@@ -148,15 +148,16 @@ impl Lexer {
                     let row_left = match row_left.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
-                            return Err(self
-                                .set_error(&format!("Failed parsing row {}", row_left), position))
+                            return Err(
+                                self.set_error(&format!("Failed parsing row {row_left}"), position)
+                            )
                         }
                     };
                     let row_right = match row_right.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
                             return Err(self
-                                .set_error(&format!("Failed parsing row {}", row_right), position))
+                                .set_error(&format!("Failed parsing row {row_right}"), position))
                         }
                     };
                     if row_left > LAST_ROW {

base/src/expressions/lexer/structured_references.rs

@@ -23,19 +23,19 @@ impl Lexer {
             // TODO(TD): There are better ways of doing this :)
             let rest_of_formula: String = self.chars[self.position..self.len].iter().collect();
             let specifier = if rest_of_formula.starts_with("#This Row]") {
-                self.position += "#This Row]".bytes().len();
+                self.position += "#This Row]".len();
                 TableSpecifier::ThisRow
             } else if rest_of_formula.starts_with("#All]") {
-                self.position += "#All]".bytes().len();
+                self.position += "#All]".len();
                 TableSpecifier::All
             } else if rest_of_formula.starts_with("#Data]") {
-                self.position += "#Data]".bytes().len();
+                self.position += "#Data]".len();
                 TableSpecifier::Data
             } else if rest_of_formula.starts_with("#Headers]") {
-                self.position += "#Headers]".bytes().len();
+                self.position += "#Headers]".len();
                 TableSpecifier::Headers
             } else if rest_of_formula.starts_with("#Totals]") {
-                self.position += "#Totals]".bytes().len();
+                self.position += "#Totals]".len();
                 TableSpecifier::Totals
             } else {
                 return Err(LexerError {

base/src/expressions/lexer/test/mod.rs

@@ -1,4 +1,5 @@
 mod test_common;
+mod test_implicit_intersection;
 mod test_language;
 mod test_locale;
 mod test_ranges;

base/src/expressions/lexer/test/test_common.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -685,3 +686,29 @@ fn test_comparisons() {
     assert_eq!(lx.next_token(), Number(7.0));
     assert_eq!(lx.next_token(), EOF);
 }
+
+#[test]
+fn test_log10_is_cell_reference() {
+    let mut lx = new_lexer("LOG10", true);
+    assert_eq!(
+        lx.next_token(),
+        Reference {
+            sheet: None,
+            column: column_to_number("LOG").unwrap(),
+            row: 10,
+            absolute_column: false,
+            absolute_row: false,
+        }
+    );
+    assert_eq!(lx.next_token(), EOF);
+}
+
+#[test]
+fn test_log10_is_function() {
+    let mut lx = new_lexer("LOG10(100)", true);
+    assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
+    assert_eq!(lx.next_token(), LeftParenthesis);
+    assert_eq!(lx.next_token(), Number(100.0));
+    assert_eq!(lx.next_token(), RightParenthesis);
+    assert_eq!(lx.next_token(), EOF);
+}

base/src/expressions/lexer/test/test_implicit_intersection.rs

@@ -0,0 +1,25 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::expressions::{
+    lexer::{Lexer, LexerMode},
+    token::TokenType::*,
+};
+use crate::language::get_language;
+use crate::locale::get_locale;
+
+fn new_lexer(formula: &str) -> Lexer {
+    let locale = get_locale("en").unwrap();
+    let language = get_language("en").unwrap();
+    Lexer::new(formula, LexerMode::A1, locale, language)
+}
+
+#[test]
+fn sum_implicit_intersection() {
+    let mut lx = new_lexer("sum(@A1:A3)");
+    assert_eq!(lx.next_token(), Ident("sum".to_string()));
+    assert_eq!(lx.next_token(), LeftParenthesis);
+    assert_eq!(lx.next_token(), At);
+    assert!(matches!(lx.next_token(), Range { .. }));
+    assert_eq!(lx.next_token(), RightParenthesis);
+    assert_eq!(lx.next_token(), EOF);
+}

base/src/expressions/parser/mod.rs

@@ -1,5 +1,5 @@
 /*!
-# GRAMAR
+# GRAMMAR
 
 <pre class="rust">
 opComp   => '=' | '<' | '>' | '<=' } '>=' | '<>'
@@ -12,7 +12,8 @@ term    => factor (opFactor factor)*
 factor  => prod (opProd prod)*
 prod    => power ('^' power)*
 power   => (unaryOp)* range '%'*
-range   => primary (':' primary)?
+range   => implicit (':' primary)?
+implicit=> '@' primary | primary
 primary => '(' expr ')'
         => number
         => function '(' f_args ')'
@@ -45,8 +46,8 @@ use super::utils::number_to_column;
 use token::OpCompare;
 
 pub mod move_formula;
+pub mod static_analysis;
 pub mod stringify;
-pub mod walk;
 
 #[cfg(test)]
 mod tests;
@@ -81,6 +82,9 @@ fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i3
     None
 }
 
+// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
+pub type DefinedNameS = (String, Option<u32>, String);
+
 pub(crate) struct Reference<'a> {
     sheet_name: &'a Option<String>,
     sheet_index: u32,
@@ -90,6 +94,14 @@ pub(crate) struct Reference<'a> {
     column: i32,
 }
 
+#[derive(PartialEq, Clone, Debug)]
+pub enum ArrayNode {
+    Boolean(bool),
+    Number(f64),
+    String(String),
+    Error(token::Error),
+}
+
 #[derive(PartialEq, Clone, Debug)]
 pub enum Node {
     BooleanKind(bool),
@@ -163,10 +175,14 @@ pub enum Node {
         name: String,
         args: Vec<Node>,
     },
-    ArrayKind(Vec<Node>),
-    DefinedNameKind((String, Option<u32>)),
+    ArrayKind(Vec<Vec<ArrayNode>>),
+    DefinedNameKind(DefinedNameS),
     TableNameKind(String),
     WrongVariableKind(String),
+    ImplicitIntersection {
+        automatic: bool,
+        child: Box<Node>,
+    },
     CompareKind {
         kind: OpCompare,
         left: Box<Node>,
@@ -189,7 +205,7 @@ pub enum Node {
 pub struct Parser {
     lexer: lexer::Lexer,
     worksheets: Vec<String>,
-    defined_names: Vec<(String, Option<u32>)>,
+    defined_names: Vec<DefinedNameS>,
     context: CellReferenceRC,
     tables: HashMap<String, Table>,
 }
@@ -197,7 +213,7 @@ pub struct Parser {
 impl Parser {
     pub fn new(
         worksheets: Vec<String>,
-        defined_names: Vec<(String, Option<u32>)>,
+        defined_names: Vec<DefinedNameS>,
         tables: HashMap<String, Table>,
     ) -> Parser {
         let lexer = lexer::Lexer::new(
@@ -228,7 +244,7 @@ impl Parser {
     pub fn set_worksheets_and_names(
         &mut self,
         worksheets: Vec<String>,
-        defined_names: Vec<(String, Option<u32>)>,
+        defined_names: Vec<DefinedNameS>,
     ) {
         self.worksheets = worksheets;
         self.defined_names = defined_names;
@@ -252,17 +268,17 @@ impl Parser {
 
     // Returns:
     //  * None: If there is no defined name by that name
-    //  * Some(Some(index)): If there is a defined name local to that sheet
+    //  * Some((Some(index), formula)): If there is a defined name local to that sheet
     //  * Some(None): If there is a global defined name
-    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<Option<u32>> {
-        for (df_name, df_scope) in &self.defined_names {
+    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<(Option<u32>, String)> {
+        for (df_name, df_scope, df_formula) in &self.defined_names {
             if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
-                return Some(*df_scope);
+                return Some((*df_scope, df_formula.to_owned()));
             }
         }
-        for (df_name, df_scope) in &self.defined_names {
+        for (df_name, df_scope, df_formula) in &self.defined_names {
             if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
-                return Some(None);
+                return Some((None, df_formula.to_owned()));
             }
         }
         None
@@ -411,7 +427,7 @@ impl Parser {
     }
 
     fn parse_range(&mut self) -> Node {
-        let t = self.parse_primary();
+        let t = self.parse_implicit();
         if let Node::ParseErrorKind { .. } = t {
             return t;
         }
@@ -430,6 +446,65 @@ impl Parser {
         t
     }
 
+    fn parse_implicit(&mut self) -> Node {
+        let next_token = self.lexer.peek_token();
+        if next_token == TokenType::At {
+            self.lexer.advance_token();
+            let t = self.parse_primary();
+            if let Node::ParseErrorKind { .. } = t {
+                return t;
+            }
+            return Node::ImplicitIntersection {
+                automatic: false,
+                child: Box::new(t),
+            };
+        }
+        self.parse_primary()
+    }
+
+    fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
+        let mut row = Vec::new();
+        // and array can only have numbers, string or booleans
+        // otherwise it is a syntax error
+        let first_element = match self.parse_expr() {
+            Node::BooleanKind(s) => ArrayNode::Boolean(s),
+            Node::NumberKind(s) => ArrayNode::Number(s),
+            Node::StringKind(s) => ArrayNode::String(s),
+            Node::ErrorKind(kind) => ArrayNode::Error(kind),
+            error @ Node::ParseErrorKind { .. } => return Err(error),
+            _ => {
+                return Err(Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    message: "Invalid value in array".to_string(),
+                    position: self.lexer.get_position() as usize,
+                });
+            }
+        };
+        row.push(first_element);
+        let mut next_token = self.lexer.peek_token();
+        // FIXME: this is not respecting the locale
+        while next_token == TokenType::Comma {
+            self.lexer.advance_token();
+            let value = match self.parse_expr() {
+                Node::BooleanKind(s) => ArrayNode::Boolean(s),
+                Node::NumberKind(s) => ArrayNode::Number(s),
+                Node::StringKind(s) => ArrayNode::String(s),
+                Node::ErrorKind(kind) => ArrayNode::Error(kind),
+                error @ Node::ParseErrorKind { .. } => return Err(error),
+                _ => {
+                    return Err(Node::ParseErrorKind {
+                        formula: self.lexer.get_formula(),
+                        message: "Invalid value in array".to_string(),
+                        position: self.lexer.get_position() as usize,
+                    });
+                }
+            };
+            row.push(value);
+            next_token = self.lexer.peek_token();
+        }
+        Ok(row)
+    }
+
     fn parse_primary(&mut self) -> Node {
         let next_token = self.lexer.next_token();
         match next_token {
@@ -451,21 +526,35 @@ impl Parser {
             TokenType::Number(s) => Node::NumberKind(s),
             TokenType::String(s) => Node::StringKind(s),
             TokenType::LeftBrace => {
-                let t = self.parse_expr();
-                if let Node::ParseErrorKind { .. } = t {
-                    return t;
-                }
+                // It's an array. It's a collection of rows all of the same dimension
+
+                let first_row = match self.parse_array_row() {
+                    Ok(s) => s,
+                    Err(error) => return error,
+                };
+                let length = first_row.len();
+
+                let mut matrix = Vec::new();
+                matrix.push(first_row);
+                // FIXME: this is not respecting the locale
                 let mut next_token = self.lexer.peek_token();
-                let mut args: Vec<Node> = vec![t];
                 while next_token == TokenType::Semicolon {
                     self.lexer.advance_token();
-                    let p = self.parse_expr();
-                    if let Node::ParseErrorKind { .. } = p {
-                        return p;
-                    }
+                    let row = match self.parse_array_row() {
+                        Ok(s) => s,
+                        Err(error) => return error,
+                    };
                     next_token = self.lexer.peek_token();
-                    args.push(p);
+                    if row.len() != length {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: self.lexer.get_position() as usize,
+                            message: "All rows in an array should be the same length".to_string(),
+                        };
+                    }
+                    matrix.push(row);
                 }
+
                 if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
                     return Node::ParseErrorKind {
                         formula: self.lexer.get_formula(),
@@ -473,7 +562,7 @@ impl Parser {
                         message: err.message,
                     };
                 }
-                Node::ArrayKind(args)
+                Node::ArrayKind(matrix)
             }
             TokenType::Reference {
                 sheet,
@@ -604,6 +693,20 @@ impl Parser {
                             args,
                         };
                     }
+                    if &name == "_xlfn.SINGLE" {
+                        if args.len() != 1 {
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: self.lexer.get_position() as usize,
+                                message: "Implicit Intersection requires just one argument"
+                                    .to_string(),
+                            };
+                        }
+                        return Node::ImplicitIntersection {
+                            automatic: false,
+                            child: Box::new(args[0].clone()),
+                        };
+                    }
                     return Node::InvalidFunctionKind { name, args };
                 }
                 let context = &self.context;
@@ -614,14 +717,14 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: "sheet not found".to_string(),
+                            message: format!("sheet not found: {}", context.sheet),
                         };
                     }
                 };
 
                 // Could be a defined name or a table
-                if let Some(scope) = self.get_defined_name(&name, context_sheet_index) {
-                    return Node::DefinedNameKind((name, scope));
+                if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
+                    return Node::DefinedNameKind((name, scope, formula));
                 }
                 let name_lower = name.to_lowercase();
                 for table_name in self.tables.keys() {
@@ -706,6 +809,14 @@ impl Parser {
                     message: "Unexpected token: 'POWER'".to_string(),
                 }
             }
+            TokenType::At => {
+                // A primary Node cannot start with an operator
+                Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    position: 0,
+                    message: "Unexpected token: '@'".to_string(),
+                }
+            }
             TokenType::RightParenthesis
             | TokenType::RightBracket
             | TokenType::Colon
@@ -717,7 +828,7 @@ impl Parser {
             | TokenType::Percent => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
                 position: 0,
-                message: format!("Unexpected token: '{:?}'", next_token),
+                message: format!("Unexpected token: '{next_token:?}'"),
             },
             TokenType::LeftBracket => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
@@ -739,7 +850,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: "sheet not found".to_string(),
+                            message: format!("sheet not found: {}", context.sheet),
                         };
                     }
                 };
@@ -767,7 +878,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: "sheet not found".to_string(),
+                            message: format!("table sheet not found: {}", table.sheet_name),
                         };
                     }
                 };

base/src/expressions/parser/move_formula.rs

@@ -1,6 +1,6 @@
 use super::{
     stringify::{stringify_reference, DisplaceData},
-    Node, Reference,
+    ArrayNode, Node, Reference,
 };
 use crate::{
     constants::{LAST_COLUMN, LAST_ROW},
@@ -53,15 +53,24 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
             arguments = to_string_moved(el, move_context);
         }
     }
-    format!("{}({})", name, arguments)
+    format!("{name}({arguments})")
+}
+
+pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
+    match node {
+        ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
+        ArrayNode::Number(number) => to_excel_precision_str(*number),
+        ArrayNode::String(value) => format!("\"{value}\""),
+        ArrayNode::Error(kind) => format!("{kind}"),
+    }
 }
 
 fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
+        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{}\"", value),
+        StringKind(value) => format!("\"{value}\""),
         ReferenceKind {
             sheet_name,
             sheet_index,
@@ -232,7 +241,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         WrongReferenceKind {
             sheet_name,
@@ -316,7 +325,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
@@ -349,7 +358,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 }
                 _ => to_string_moved(right, move_context),
             };
-            format!("{}{}{}", x, kind, y)
+            format!("{x}{kind}{y}")
         }
         OpPowerKind { left, right } => format!(
             "{}^{}",
@@ -362,20 +371,41 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             move_function(name, args, move_context)
         }
         ArrayKind(args) => {
-            // This code is a placeholder. Arrays are not yet implemented
-            let mut first = true;
-            let mut arguments = "".to_string();
-            for el in args {
-                if !first {
-                    arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
+            let mut first_row = true;
+            let mut matrix_string = String::new();
+
+            // Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
+            for row in args {
+                if !first_row {
+                    matrix_string.push(',');
                 } else {
-                    first = false;
-                    arguments = to_string_moved(el, move_context);
+                    first_row = false;
                 }
+
+                // Build the string for the current row
+                let mut first_col = true;
+                let mut row_string = String::new();
+                for el in row {
+                    if !first_col {
+                        row_string.push(',');
+                    } else {
+                        first_col = false;
+                    }
+
+                    // Reuse your existing element-stringification function
+                    row_string.push_str(&to_string_array_node(el));
+                }
+
+                // Enclose the row in braces
+                matrix_string.push('{');
+                matrix_string.push_str(&row_string);
+                matrix_string.push('}');
             }
-            format!("{{{}}}", arguments)
+
+            // Enclose the whole matrix in braces
+            format!("{{{matrix_string}}}")
         }
-        DefinedNameKind((name, _)) => name.to_string(),
+        DefinedNameKind((name, ..)) => name.to_string(),
         TableNameKind(name) => name.to_string(),
         WrongVariableKind(name) => name.to_string(),
         CompareKind { kind, left, right } => format!(
@@ -388,12 +418,18 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
             OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
         },
-        ErrorKind(kind) => format!("{}", kind),
+        ErrorKind(kind) => format!("{kind}"),
         ParseErrorKind {
             formula,
             message: _,
             position: _,
         } => formula.to_string(),
         EmptyArgKind => "".to_string(),
+        ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            format!("@{}", to_string_moved(child, move_context))
+        }
     }
 }

base/src/expressions/parser/stringify.rs

@@ -1,6 +1,8 @@
 use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::token::OpUnary;
+use crate::expressions::parser::move_formula::to_string_array_node;
+use crate::expressions::parser::static_analysis::add_implicit_intersection;
+use crate::expressions::token::{OpSum, OpUnary};
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -26,6 +28,11 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
+    RowMove {
+        sheet: u32,
+        row: i32,
+        delta: i32,
+    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -34,10 +41,21 @@ pub enum DisplaceData {
     None,
 }
 
+/// This is the internal mode in IronCalc
 pub fn to_rc_format(node: &Node) -> String {
     stringify(node, None, &DisplaceData::None, false)
 }
 
+/// This is the mode used to display the formula in the UI
+pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, false)
+}
+
+/// This is the mode used to export the formula to Excel
+pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, true)
+}
+
 pub fn to_string_displaced(
     node: &Node,
     context: &CellReferenceRC,
@@ -46,18 +64,10 @@ pub fn to_string_displaced(
     stringify(node, Some(context), displace_data, false)
 }
 
-pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, false)
-}
-
-pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, true)
-}
-
 /// Converts a local reference to a string applying some displacement if needed.
 /// It uses A1 style if context is not None. If context is None it uses R1C1 style
 /// If full_row is true then the row details will be omitted in the A1 case
-/// If full_colum is true then column details will be omitted.
+/// If full_column is true then column details will be omitted.
 pub(crate) fn stringify_reference(
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
@@ -154,6 +164,29 @@ pub(crate) fn stringify_reference(
                         }
                     }
                 }
+                DisplaceData::RowMove {
+                    sheet,
+                    row: move_row,
+                    delta,
+                } => {
+                    if sheet_index == *sheet {
+                        if row == *move_row {
+                            row += *delta;
+                        } else if *delta > 0 {
+                            // Moving the row downwards
+                            if row > *move_row && row <= *move_row + *delta {
+                                // Intermediate rows move up by one position
+                                row -= 1;
+                            }
+                        } else if *delta < 0 {
+                            // Moving the row upwards
+                            if row < *move_row && row >= *move_row + *delta {
+                                // Intermediate rows move down by one position
+                                row += 1;
+                            }
+                        }
+                    }
+                }
                 DisplaceData::ColumnMove {
                     sheet,
                     column: move_column,
@@ -162,14 +195,18 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             column += *delta;
-                        } else if (*delta > 0
-                            && column > *move_column
-                            && column <= *move_column + *delta)
-                            || (*delta < 0
-                                && column < *move_column
-                                && column >= *move_column + *delta)
-                        {
-                            column -= *delta;
+                        } else if *delta > 0 {
+                            // Moving the column to the right
+                            if column > *move_column && column <= *move_column + *delta {
+                                // Intermediate columns move left by one position
+                                column -= 1;
+                            }
+                        } else if *delta < 0 {
+                            // Moving the column to the left
+                            if column < *move_column && column >= *move_column + *delta {
+                                // Intermediate columns move right by one position
+                                column += 1;
+                            }
                         }
                     }
                 }
@@ -179,16 +216,16 @@ pub(crate) fn stringify_reference(
                 return "#REF!".to_string();
             }
             let mut row_abs = if absolute_row {
-                format!("${}", row)
+                format!("${row}")
             } else {
-                format!("{}", row)
+                format!("{row}")
             };
             let column = match crate::expressions::utils::number_to_column(column) {
                 Some(s) => s,
                 None => return "#REF!".to_string(),
             };
             let mut col_abs = if absolute_column {
-                format!("${}", column)
+                format!("${column}")
             } else {
                 column
             };
@@ -203,27 +240,27 @@ pub(crate) fn stringify_reference(
                     format!("{}!{}{}", quote_name(name), col_abs, row_abs)
                 }
                 None => {
-                    format!("{}{}", col_abs, row_abs)
+                    format!("{col_abs}{row_abs}")
                 }
             }
         }
         None => {
             let row_abs = if absolute_row {
-                format!("R{}", row)
+                format!("R{row}")
             } else {
-                format!("R[{}]", row)
+                format!("R[{row}]")
             };
             let col_abs = if absolute_column {
-                format!("C{}", column)
+                format!("C{column}")
             } else {
-                format!("C[{}]", column)
+                format!("C[{column}]")
             };
             match &sheet_name {
                 Some(name) => {
                     format!("{}!{}{}", quote_name(name), row_abs, col_abs)
                 }
                 None => {
-                    format!("{}{}", row_abs, col_abs)
+                    format!("{row_abs}{col_abs}")
                 }
             }
         }
@@ -235,7 +272,7 @@ fn format_function(
     args: &Vec<Node>,
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
-    use_original_name: bool,
+    export_to_excel: bool,
 ) -> String {
     let mut first = true;
     let mut arguments = "".to_string();
@@ -244,27 +281,52 @@ fn format_function(
             arguments = format!(
                 "{},{}",
                 arguments,
-                stringify(el, context, displace_data, use_original_name)
+                stringify(el, context, displace_data, export_to_excel)
             );
         } else {
             first = false;
-            arguments = stringify(el, context, displace_data, use_original_name);
+            arguments = stringify(el, context, displace_data, export_to_excel);
         }
     }
-    format!("{}({})", name, arguments)
+    format!("{name}({arguments})")
 }
 
+// There is just one representation in the AST (Abstract Syntax Tree) of a formula.
+// But three different ways to convert it to a string.
+//
+// To stringify a formula we need a "context", that is in which cell are we doing the "stringifying"
+//
+// But there are three ways to stringify a formula:
+//
+// * To show it to the IronCalc user
+// * To store internally
+// * To export to Excel
+//
+// There are, of course correspondingly three "modes" when parsing a formula.
+//
+// The internal representation is the more different as references are stored in the RC representation.
+// The the AST of the formula is kept close to this representation we don't need a context
+//
+// In the export to Excel representation certain things are different:
+// * We add a _xlfn. in front of some (more modern) functions
+// * We remove the Implicit Intersection operator when it is automatic and add _xlfn.SINGLE when it is not
+//
+// Examples:
+// * =A1+B2
+// * =RC+R1C1
+// * =A1+B1
+
 fn stringify(
     node: &Node,
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
-    use_original_name: bool,
+    export_to_excel: bool,
 ) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
+        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{}\"", value),
+        StringKind(value) => format!("\"{value}\""),
         WrongReferenceKind {
             sheet_name,
             column,
@@ -354,7 +416,7 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         WrongRangeKind {
             sheet_name,
@@ -403,63 +465,62 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         OpConcatenateKind { left, right } => format!(
             "{}&{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
-            stringify(left, context, displace_data, use_original_name),
+            stringify(left, context, displace_data, export_to_excel),
             kind,
-            stringify(right, context, displace_data, use_original_name)
-        ),
-        OpSumKind { kind, left, right } => format!(
-            "{}{}{}",
-            stringify(left, context, displace_data, use_original_name),
-            kind,
-            stringify(right, context, displace_data, use_original_name)
+            stringify(right, context, displace_data, export_to_excel)
         ),
+        OpSumKind { kind, left, right } => {
+            let left_str = stringify(left, context, displace_data, export_to_excel);
+            // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
+            let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
+                | matches!(**right, CompareKind { .. })
+            {
+                format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                )
+            } else {
+                stringify(right, context, displace_data, export_to_excel)
+            };
+
+            format!("{left_str}{kind}{right_str}")
+        }
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } => format!(
                     "({})",
-                    stringify(left, context, displace_data, use_original_name)
+                    stringify(left, context, displace_data, export_to_excel)
                 ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    stringify(left, context, displace_data, use_original_name)
-                ),
-                _ => stringify(left, context, displace_data, use_original_name),
+                _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
-                OpSumKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
                     "({})",
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, use_original_name)
-                ),
-                OpProductKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, use_original_name)
-                ),
-                _ => stringify(right, context, displace_data, use_original_name),
+                _ => stringify(right, context, displace_data, export_to_excel),
             };
-            format!("{}{}{}", x, kind, y)
+            format!("{x}{kind}{y}")
         }
         OpPowerKind { left, right } => {
             let x = match **left {
                 BooleanKind(_)
                 | NumberKind(_)
+                | UnaryKind { .. }
                 | StringKind(_)
                 | ReferenceKind { .. }
                 | RangeKind { .. }
@@ -467,9 +528,7 @@ fn stringify(
                 | DefinedNameKind(_)
                 | TableNameKind(_)
                 | WrongVariableKind(_)
-                | WrongRangeKind { .. } => {
-                    stringify(left, context, displace_data, use_original_name)
-                }
+                | WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
                 | OpProductKind { .. }
@@ -477,14 +536,14 @@ fn stringify(
                 | FunctionKind { .. }
                 | InvalidFunctionKind { .. }
                 | ArrayKind(_)
-                | UnaryKind { .. }
                 | ErrorKind(_)
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
                 | CompareKind { .. }
+                | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(left, context, displace_data, use_original_name)
+                    stringify(left, context, displace_data, export_to_excel)
                 ),
             };
             let y = match **right {
@@ -498,7 +557,7 @@ fn stringify(
                 | TableNameKind(_)
                 | WrongVariableKind(_)
                 | WrongRangeKind { .. } => {
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 }
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
@@ -512,65 +571,128 @@ fn stringify(
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
                 | CompareKind { .. }
+                | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 ),
             };
-            format!("{}^{}", x, y)
+            format!("{x}^{y}")
         }
         InvalidFunctionKind { name, args } => {
-            format_function(name, args, context, displace_data, use_original_name)
+            format_function(name, args, context, displace_data, export_to_excel)
         }
         FunctionKind { kind, args } => {
-            let name = if use_original_name {
+            let name = if export_to_excel {
                 kind.to_xlsx_string()
             } else {
                 kind.to_string()
             };
-            format_function(&name, args, context, displace_data, use_original_name)
+            format_function(&name, args, context, displace_data, export_to_excel)
         }
         ArrayKind(args) => {
-            let mut first = true;
-            let mut arguments = "".to_string();
-            for el in args {
-                if !first {
-                    arguments = format!(
-                        "{},{}",
-                        arguments,
-                        stringify(el, context, displace_data, use_original_name)
-                    );
+            let mut first_row = true;
+            let mut matrix_string = String::new();
+
+            for row in args {
+                if !first_row {
+                    matrix_string.push(';');
                 } else {
-                    first = false;
-                    arguments = stringify(el, context, displace_data, use_original_name);
+                    first_row = false;
                 }
+                let mut first_column = true;
+                let mut row_string = String::new();
+                for el in row {
+                    if !first_column {
+                        row_string.push(',');
+                    } else {
+                        first_column = false;
+                    }
+                    row_string.push_str(&to_string_array_node(el));
+                }
+                matrix_string.push_str(&row_string);
             }
-            format!("{{{}}}", arguments)
+            format!("{{{matrix_string}}}")
         }
         TableNameKind(value) => value.to_string(),
-        DefinedNameKind((name, _)) => name.to_string(),
+        DefinedNameKind((name, ..)) => name.to_string(),
         WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                format!(
-                    "-{}",
-                    stringify(right, context, displace_data, use_original_name)
-                )
+                let needs_parentheses = match **right {
+                    BooleanKind(_)
+                    | NumberKind(_)
+                    | StringKind(_)
+                    | ReferenceKind { .. }
+                    | RangeKind { .. }
+                    | WrongReferenceKind { .. }
+                    | WrongRangeKind { .. }
+                    | OpRangeKind { .. }
+                    | OpConcatenateKind { .. }
+                    | OpProductKind { .. }
+                    | FunctionKind { .. }
+                    | InvalidFunctionKind { .. }
+                    | ArrayKind(_)
+                    | DefinedNameKind(_)
+                    | TableNameKind(_)
+                    | WrongVariableKind(_)
+                    | ImplicitIntersection { .. }
+                    | CompareKind { .. }
+                    | ErrorKind(_)
+                    | ParseErrorKind { .. }
+                    | EmptyArgKind => false,
+
+                    OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
+                };
+                if needs_parentheses {
+                    format!(
+                        "-({})",
+                        stringify(right, context, displace_data, export_to_excel)
+                    )
+                } else {
+                    format!(
+                        "-{}",
+                        stringify(right, context, displace_data, export_to_excel)
+                    )
+                }
             }
             OpUnary::Percentage => {
                 format!(
                     "{}%",
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 )
             }
         },
-        ErrorKind(kind) => format!("{}", kind),
+        ErrorKind(kind) => format!("{kind}"),
         ParseErrorKind {
             formula,
             position: _,
             message: _,
         } => formula.to_string(),
         EmptyArgKind => "".to_string(),
+        ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            if export_to_excel {
+                // We need to check wether the II can be automatic or not
+                let mut new_node = child.as_ref().clone();
+
+                add_implicit_intersection(&mut new_node, true);
+                if matches!(&new_node, Node::ImplicitIntersection { .. }) {
+                    return stringify(child, context, displace_data, export_to_excel);
+                }
+
+                return format!(
+                    "_xlfn.SINGLE({})",
+                    stringify(child, context, displace_data, export_to_excel)
+                );
+            }
+            format!(
+                "@{}",
+                stringify(child, context, displace_data, export_to_excel)
+            )
+        }
     }
 }
 
@@ -658,6 +780,12 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
         Node::UnaryKind { kind: _, right } => {
             rename_sheet_in_node(right, sheet_index, new_name);
         }
+        Node::ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            rename_sheet_in_node(child, sheet_index, new_name);
+        }
 
         // Do nothing
         Node::BooleanKind(_) => {}
@@ -681,7 +809,7 @@ pub(crate) fn rename_defined_name_in_node(
 ) {
     match node {
         // Rename
-        Node::DefinedNameKind((n, s)) => {
+        Node::DefinedNameKind((n, s, _)) => {
             if name.to_lowercase() == n.to_lowercase() && *s == scope {
                 *n = new_name.to_string();
             }
@@ -736,6 +864,12 @@ pub(crate) fn rename_defined_name_in_node(
         Node::UnaryKind { kind: _, right } => {
             rename_defined_name_in_node(right, name, scope, new_name);
         }
+        Node::ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            rename_defined_name_in_node(child, name, scope, new_name);
+        }
 
         // Do nothing
         Node::BooleanKind(_) => {}

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

@@ -1,5 +1,9 @@
+mod test_add_implicit_intersection;
+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_add_implicit_intersection.rs

@@ -0,0 +1,80 @@
+use std::collections::HashMap;
+
+use crate::expressions::{
+    parser::{
+        stringify::{to_excel_string, to_string},
+        Parser,
+    },
+    types::CellReferenceRC,
+};
+
+use crate::expressions::parser::static_analysis::add_implicit_intersection;
+
+#[test]
+fn simple_test() {
+    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: 1,
+        column: 1,
+    };
+    let cases = vec![
+        ("A1:A10*SUM(A1:A10)", "@A1:A10*SUM(A1:A10)"),
+        ("A1:A10", "@A1:A10"),
+        // Math and trigonometry functions
+        ("SUM(A1:A10)", "SUM(A1:A10)"),
+        ("SIN(A1:A10)", "SIN(@A1:A10)"),
+        ("COS(A1:A10)", "COS(@A1:A10)"),
+        ("TAN(A1:A10)", "TAN(@A1:A10)"),
+        ("ASIN(A1:A10)", "ASIN(@A1:A10)"),
+        ("ACOS(A1:A10)", "ACOS(@A1:A10)"),
+        ("ATAN(A1:A10)", "ATAN(@A1:A10)"),
+        ("SINH(A1:A10)", "SINH(@A1:A10)"),
+        ("COSH(A1:A10)", "COSH(@A1:A10)"),
+        ("TANH(A1:A10)", "TANH(@A1:A10)"),
+        ("ASINH(A1:A10)", "ASINH(@A1:A10)"),
+        ("ACOSH(A1:A10)", "ACOSH(@A1:A10)"),
+        ("ATANH(A1:A10)", "ATANH(@A1:A10)"),
+        ("ATAN2(A1:A10,B1:B10)", "ATAN2(@A1:A10,@B1:B10)"),
+        ("ATAN2(A1:A10,A1)", "ATAN2(@A1:A10,A1)"),
+        ("SQRT(A1:A10)", "SQRT(@A1:A10)"),
+        ("SQRTPI(A1:A10)", "SQRTPI(@A1:A10)"),
+        ("POWER(A1:A10,A1)", "POWER(@A1:A10,A1)"),
+        ("POWER(A1:A10,B1:B10)", "POWER(@A1:A10,@B1:B10)"),
+        ("MAX(A1:A10)", "MAX(A1:A10)"),
+        ("MIN(A1:A10)", "MIN(A1:A10)"),
+        ("ABS(A1:A10)", "ABS(@A1:A10)"),
+        ("FALSE()", "FALSE()"),
+        ("TRUE()", "TRUE()"),
+        // Defined names
+        ("BADNMAE", "@BADNMAE"),
+        // Logical
+        ("AND(A1:A10)", "AND(A1:A10)"),
+        ("OR(A1:A10)", "OR(A1:A10)"),
+        ("NOT(A1:A10)", "NOT(@A1:A10)"),
+        ("IF(A1:A10,B1:B10,C1:C10)", "IF(@A1:A10,@B1:B10,@C1:C10)"),
+        // Information
+        // ("ISBLANK(A1:A10)", "ISBLANK(A1:A10)"),
+        // ("ISERR(A1:A10)", "ISERR(A1:A10)"),
+        // ("ISERROR(A1:A10)", "ISERROR(A1:A10)"),
+        // ("ISEVEN(A1:A10)", "ISEVEN(A1:A10)"),
+        // ("ISLOGICAL(A1:A10)", "ISLOGICAL(A1:A10)"),
+        // ("ISNA(A1:A10)", "ISNA(A1:A10)"),
+        // ("ISNONTEXT(A1:A10)", "ISNONTEXT(A1:A10)"),
+        // ("ISNUMBER(A1:A10)", "ISNUMBER(A1:A10)"),
+        // ("ISODD(A1:A10)", "ISODD(A1:A10)"),
+        // ("ISREF(A1:A10)", "ISREF(A1:A10)"),
+        // ("ISTEXT(A1:A10)", "ISTEXT(A1:A10)"),
+    ];
+    for (formula, expected) in cases {
+        let mut t = parser.parse(formula, &cell_reference);
+        add_implicit_intersection(&mut t, true);
+        let r = to_string(&t, &cell_reference);
+        assert_eq!(r, expected);
+        let excel_formula = to_excel_string(&t, &cell_reference);
+        assert_eq!(excel_formula, formula);
+    }
+}

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

@@ -0,0 +1,92 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::{ArrayNode, Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn simple_horizontal() {
+    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: 1,
+        column: 1,
+    };
+    let horizontal = parser.parse("{1, 2, 3}", &cell_reference);
+    assert_eq!(
+        horizontal,
+        Node::ArrayKind(vec![vec![
+            ArrayNode::Number(1.0),
+            ArrayNode::Number(2.0),
+            ArrayNode::Number(3.0)
+        ]])
+    );
+
+    assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
+    assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
+}
+
+#[test]
+fn simple_vertical() {
+    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: 1,
+        column: 1,
+    };
+    let vertical = parser.parse("{1;2; 3}", &cell_reference);
+    assert_eq!(
+        vertical,
+        Node::ArrayKind(vec![
+            vec![ArrayNode::Number(1.0)],
+            vec![ArrayNode::Number(2.0)],
+            vec![ArrayNode::Number(3.0)]
+        ])
+    );
+    assert_eq!(to_rc_format(&vertical), "{1;2;3}");
+    assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
+}
+
+#[test]
+fn simple_matrix() {
+    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: 1,
+        column: 1,
+    };
+    let matrix = parser.parse("{1,2,3; 4, 5, 6; 7,8,9}", &cell_reference);
+    assert_eq!(
+        matrix,
+        Node::ArrayKind(vec![
+            vec![
+                ArrayNode::Number(1.0),
+                ArrayNode::Number(2.0),
+                ArrayNode::Number(3.0)
+            ],
+            vec![
+                ArrayNode::Number(4.0),
+                ArrayNode::Number(5.0),
+                ArrayNode::Number(6.0)
+            ],
+            vec![
+                ArrayNode::Number(7.0),
+                ArrayNode::Number(8.0),
+                ArrayNode::Number(9.0)
+            ]
+        ])
+    );
+    assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
+    assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
+}

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

@@ -0,0 +1,75 @@
+#![allow(clippy::panic)]
+
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+use std::collections::HashMap;
+
+#[test]
+fn simple() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!B3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 3,
+        column: 2,
+    };
+    let t = parser.parse("@A1:A10", &cell_reference);
+    let child = Node::RangeKind {
+        sheet_name: None,
+        sheet_index: 0,
+        absolute_row1: false,
+        absolute_column1: false,
+        row1: -2,
+        column1: -1,
+        absolute_row2: false,
+        absolute_column2: false,
+        row2: 7,
+        column2: -1,
+    };
+    assert_eq!(
+        t,
+        Node::ImplicitIntersection {
+            automatic: false,
+            child: Box::new(child)
+        }
+    )
+}
+
+#[test]
+fn simple_add() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!B3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 3,
+        column: 2,
+    };
+    let t = parser.parse("@A1:A10+12", &cell_reference);
+    let child = Node::RangeKind {
+        sheet_name: None,
+        sheet_index: 0,
+        absolute_row1: false,
+        absolute_column1: false,
+        row1: -2,
+        column1: -1,
+        absolute_row2: false,
+        absolute_column2: false,
+        row2: 7,
+        column2: -1,
+    };
+    assert_eq!(
+        t,
+        Node::OpSumKind {
+            kind: crate::expressions::token::OpSum::Add,
+            left: Box::new(Node::ImplicitIntersection {
+                automatic: false,
+                child: Box::new(child)
+            }),
+            right: Box::new(Node::NumberKind(12.0))
+        }
+    )
+}

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/parser/tests/test_move_formula.rs

@@ -387,7 +387,7 @@ fn test_move_formula_misc() {
         width: 4,
         height: 5,
     };
-    let node = parser.parse("X9^C2-F4*H2", context);
+    let node = parser.parse("X9^C2-F4*H2+SUM(F2:H4)+SUM(C2:F6)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -400,7 +400,7 @@ fn test_move_formula_misc() {
             column_delta: 10,
         },
     );
-    assert_eq!(t, "X9^M12-P14*H2");
+    assert_eq!(t, "X9^M12-P14*H2+SUM(F2:H4)+SUM(M12:P16)");
 
     let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
     let t = move_formula(
@@ -475,3 +475,77 @@ fn test_move_formula_another_sheet() {
         "Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
     );
 }
+
+#[test]
+fn move_formula_implicit_intersetion() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)", context);
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)");
+}
+
+#[test]
+fn move_formula_implicit_intersetion_with_ranges() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)+SUM(@A1, @X9, @$D$5)", context);
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)+SUM(@A1,@X9,@$N$15)");
+}

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

@@ -32,3 +32,39 @@ fn exp_order() {
     let t = parser.parse("(5)^(4)", &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "5^4");
 }
+
+#[test]
+fn correct_parenthesis() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("-(1 + 1)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
+
+    let t = parser.parse("1 - (3 + 4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
+
+    let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
+    assert_eq!(
+        to_string(&t, &cell_reference),
+        "-(1.05*(0.0284+0.0046)-0.0284)"
+    );
+
+    let t = parser.parse("1 + (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
+
+    let t = parser.parse("1 - (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
+
+    let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
+
+    let t = parser.parse("1 + (3<5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
+}

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

@@ -3,11 +3,10 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::stringify::to_string;
-use crate::expressions::utils::{number_to_column, parse_reference_a1};
-use crate::types::{Table, TableColumn, TableStyleInfo};
-
 use crate::expressions::parser::Parser;
 use crate::expressions::types::CellReferenceRC;
+use crate::expressions::utils::{number_to_column, parse_reference_a1};
+use crate::types::{Table, TableColumn, TableStyleInfo};
 
 fn create_test_table(
     table_name: &str,

base/src/expressions/parser/walk.rs

@@ -1,278 +0,0 @@
-use super::{move_formula::ref_is_in_area, Node};
-
-use crate::expressions::types::{Area, CellReferenceIndex};
-
-pub(crate) fn forward_references(
-    node: &mut Node,
-    context: &CellReferenceIndex,
-    source_area: &Area,
-    target_sheet: u32,
-    target_sheet_name: &str,
-    target_row: i32,
-    target_column: i32,
-) {
-    match node {
-        Node::ReferenceKind {
-            sheet_name,
-            sheet_index: reference_sheet,
-            absolute_row,
-            absolute_column,
-            row: reference_row,
-            column: reference_column,
-        } => {
-            let reference_row_absolute = if *absolute_row {
-                *reference_row
-            } else {
-                *reference_row + context.row
-            };
-            let reference_column_absolute = if *absolute_column {
-                *reference_column
-            } else {
-                *reference_column + context.column
-            };
-            if ref_is_in_area(
-                *reference_sheet,
-                reference_row_absolute,
-                reference_column_absolute,
-                source_area,
-            ) {
-                if *reference_sheet != target_sheet {
-                    *sheet_name = Some(target_sheet_name.to_string());
-                    *reference_sheet = target_sheet;
-                }
-                *reference_row = target_row + *reference_row - source_area.row;
-                *reference_column = target_column + *reference_column - source_area.column;
-            }
-        }
-        Node::RangeKind {
-            sheet_name,
-            sheet_index,
-            absolute_row1,
-            absolute_column1,
-            row1,
-            column1,
-            absolute_row2,
-            absolute_column2,
-            row2,
-            column2,
-        } => {
-            let reference_row1 = if *absolute_row1 {
-                *row1
-            } else {
-                *row1 + context.row
-            };
-            let reference_column1 = if *absolute_column1 {
-                *column1
-            } else {
-                *column1 + context.column
-            };
-
-            let reference_row2 = if *absolute_row2 {
-                *row2
-            } else {
-                *row2 + context.row
-            };
-            let reference_column2 = if *absolute_column2 {
-                *column2
-            } else {
-                *column2 + context.column
-            };
-            if ref_is_in_area(*sheet_index, reference_row1, reference_column1, source_area)
-                && ref_is_in_area(*sheet_index, reference_row2, reference_column2, source_area)
-            {
-                if *sheet_index != target_sheet {
-                    *sheet_index = target_sheet;
-                    *sheet_name = Some(target_sheet_name.to_string());
-                }
-                *row1 = target_row + *row1 - source_area.row;
-                *column1 = target_column + *column1 - source_area.column;
-                *row2 = target_row + *row2 - source_area.row;
-                *column2 = target_column + *column2 - source_area.column;
-            }
-        }
-        // Recurse
-        Node::OpRangeKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpConcatenateKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpSumKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpProductKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpPowerKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::FunctionKind { kind: _, args } => {
-            for arg in args {
-                forward_references(
-                    arg,
-                    context,
-                    source_area,
-                    target_sheet,
-                    target_sheet_name,
-                    target_row,
-                    target_column,
-                );
-            }
-        }
-        Node::InvalidFunctionKind { name: _, args } => {
-            for arg in args {
-                forward_references(
-                    arg,
-                    context,
-                    source_area,
-                    target_sheet,
-                    target_sheet_name,
-                    target_row,
-                    target_column,
-                );
-            }
-        }
-        Node::CompareKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::UnaryKind { kind: _, right } => {
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        // TODO: Not implemented
-        Node::ArrayKind(_) => {}
-        // Do nothing. Note: we could do a blanket _ => {}
-        Node::DefinedNameKind(_) => {}
-        Node::TableNameKind(_) => {}
-        Node::WrongVariableKind(_) => {}
-        Node::ErrorKind(_) => {}
-        Node::ParseErrorKind { .. } => {}
-        Node::EmptyArgKind => {}
-        Node::BooleanKind(_) => {}
-        Node::NumberKind(_) => {}
-        Node::StringKind(_) => {}
-        Node::WrongReferenceKind { .. } => {}
-        Node::WrongRangeKind { .. } => {}
-    }
-}

base/src/expressions/token.rs

@@ -197,7 +197,7 @@ pub fn is_english_error_string(name: &str) -> bool {
         "#REF!", "#NAME?", "#VALUE!", "#DIV/0!", "#N/A", "#NUM!", "#ERROR!", "#N/IMPL!", "#SPILL!",
         "#CALC!", "#CIRC!", "#NULL!",
     ];
-    names.iter().any(|e| *e == name)
+    names.contains(&name)
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -240,6 +240,7 @@ pub enum TokenType {
     Bang,               // !
     Percent,            // %
     And,                // &
+    At,                 // @
     Reference {
         sheet: Option<String>,
         row: i32,

base/src/expressions/utils/mod.rs

@@ -211,15 +211,19 @@ pub fn parse_reference_a1(r: &str) -> Option<ParsedReference> {
 pub fn is_valid_identifier(name: &str) -> bool {
     // https://support.microsoft.com/en-us/office/names-in-formulas-fc2935f9-115d-4bef-a370-3aa8bb4c91f1
     // https://github.com/MartinTrummer/excel-names/
-    // NOTE: We are being much more restrictive than Excel.
-    // In particular we do not support non ascii characters.
     let upper = name.to_ascii_uppercase();
-    let bytes = upper.as_bytes();
-    let len = bytes.len();
+    // length of chars
+    let len = upper.chars().count();
+
+    let mut chars = upper.chars();
+
     if len > 255 || len == 0 {
         return false;
     }
-    let first = bytes[0] as char;
+    let first = match chars.next() {
+        Some(ch) => ch,
+        None => return false,
+    };
     // The first character of a name must be a letter, an underscore character (_), or a backslash (\).
     if !(first.is_ascii_alphabetic() || first == '_' || first == '\\') {
         return false;
@@ -237,20 +241,10 @@ pub fn is_valid_identifier(name: &str) -> bool {
     if parse_reference_r1c1(name).is_some() {
         return false;
     }
-    let mut i = 1;
-    while i < len {
-        let ch = bytes[i] as char;
-        match ch {
-            'a'..='z' => {}
-            'A'..='Z' => {}
-            '0'..='9' => {}
-            '_' => {}
-            '.' => {}
-            _ => {
-                return false;
-            }
+    for ch in chars {
+        if !(ch.is_alphanumeric() || ch == '_' || ch == '.') {
+            return false;
         }
-        i += 1;
     }
 
     true
@@ -259,15 +253,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;
+        }
+    }
+    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
+        return true;
     }
-    // TODO:
-    // cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
-    // cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
-    // integers
     false
 }
 
@@ -279,3 +281,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/expressions/utils/test.rs

@@ -196,6 +196,7 @@ fn test_names() {
     assert!(is_valid_identifier("_."));
     assert!(is_valid_identifier("_1"));
     assert!(is_valid_identifier("\\."));
+    assert!(is_valid_identifier("truñe"));
 
     // invalid
     assert!(!is_valid_identifier("true"));
@@ -209,6 +210,7 @@ fn test_names() {
     assert!(!is_valid_identifier("1true"));
 
     assert!(!is_valid_identifier("test€"));
-    assert!(!is_valid_identifier("truñe"));
     assert!(!is_valid_identifier("tr&ue"));
+
+    assert!(!is_valid_identifier("LOG10"));
 }

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
@@ -21,14 +23,12 @@ fn is_date_within_range(date: NaiveDate) -> bool {
 pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
     if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
         return Err(format!(
-            "Excel date must be greater than {}",
-            MINIMUM_DATE_SERIAL_NUMBER
+            "Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}"
         ));
     };
     if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
         return Err(format!(
-            "Excel date must be less than {}",
-            MAXIMUM_DATE_SERIAL_NUMBER
+            "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
         ));
     };
     #[allow(clippy::expect_used)]
@@ -39,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()),
     }
 }
 
@@ -57,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
@@ -70,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 = {
@@ -82,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
     };
@@ -96,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

@@ -15,7 +15,7 @@ pub struct Formatted {
 
 /// Returns the vector of chars of the fractional part of a *positive* number:
 /// 3.1415926 ==> ['1', '4', '1', '5', '9', '2', '6']
-fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
+fn get_fract_part(value: f64, precision: i32, int_len: usize) -> Vec<char> {
     let b = format!("{:.1$}", value.fract(), precision as usize)
         .chars()
         .collect::<Vec<char>>();
@@ -30,6 +30,12 @@ fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
     if last_non_zero < 2 {
         return vec![];
     }
+    let max_len = if int_len > 15 {
+        2_usize
+    } else {
+        15_usize - int_len + 1
+    };
+    let last_non_zero = usize::min(last_non_zero, max_len + 1);
     b[2..last_non_zero].to_vec()
 }
 
@@ -120,7 +126,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             // We should have different codepaths for general formatting and errors
             let value_abs = value.abs();
             if (1.0e-8..1.0e+11).contains(&value_abs) {
-                let mut text = format!("{:.9}", value);
+                let mut text = format!("{value:.9}");
                 text = text.trim_end_matches('0').trim_end_matches('.').to_string();
                 Formatted {
                     text,
@@ -138,7 +144,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                 let exponent = value_abs.log10().floor();
                 value /= 10.0_f64.powf(exponent);
                 let sign = if exponent < 0.0 { '-' } else { '+' };
-                let s = format!("{:.5}", value);
+                let s = format!("{value:.5}");
                 Formatted {
                     text: format!(
                         "{}E{}{:02}",
@@ -154,48 +160,72 @@ 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) => {
-                        text = format!("{}{}", text, c);
+                        text = format!("{text}{c}");
                     }
                     TextToken::Text(t) => {
-                        text = format!("{}{}", text, t);
+                        text = format!("{text}{t}");
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Raw => {
-                        text = format!("{}{}", text, value);
+                        text = format!("{text}{value}");
                     }
                     TextToken::Digit(_) => {}
                     TextToken::Period => {}
-                    TextToken::Day => {
-                        let day = date.day() as usize;
-                        text = format!("{}{}", text, 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!("{}{:02}", text, day);
+                        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 +233,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 +250,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);
+                        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!("{}{:02}", text, month);
+                        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);
+                        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 {
@@ -247,7 +399,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Number(p) => {
             let mut text = "".to_string();
             if let Some(c) = p.currency {
-                text = format!("{}", c);
+                text = format!("{c}");
             }
             let tokens = &p.tokens;
             value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
@@ -277,7 +429,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             if value_abs as i64 == 0 {
                 int_part = vec![];
             }
-            let fract_part = get_fract_part(value_abs, p.precision);
+            let fract_part = get_fract_part(value_abs, p.precision, int_part.len());
             // ln is the number of digits of the integer part of the value
             let ln = int_part.len() as i32;
             // digit count is the number of digit tokens ('0', '?' and '#') to the left of the decimal point
@@ -295,26 +447,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
-                        text = format!("{}{}", text, c);
+                        text = format!("{text}{c}");
                     }
                     TextToken::Text(t) => {
-                        text = format!("{}{}", text, t);
+                        text = format!("{text}{t}");
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Raw => {
-                        text = format!("{}{}", text, value);
+                        text = format!("{text}{value}");
                     }
                     TextToken::Period => {
-                        text = format!("{}{}", text, decimal_separator);
+                        text = format!("{text}{decimal_separator}");
                     }
                     TextToken::Digit(digit) => {
                         if digit.number == 'i' {
@@ -322,7 +474,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             let index = digit.index;
                             let number_index = ln - digit_count + index;
                             if index == 0 && is_negative {
-                                text = format!("-{}", text);
+                                text = format!("-{text}");
                             }
                             if ln <= digit_count {
                                 // The number of digits is less or equal than the number of digit tokens
@@ -347,7 +499,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                     } else {
                                         ""
                                     };
-                                    text = format!("{}{}{}", text, c, sep);
+                                    text = format!("{text}{c}{sep}");
                                 }
                                 digit_index += 1;
                             } else {
@@ -373,18 +525,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             if index < fract_part.len() {
                                 text = format!("{}{}", text, fract_part[index]);
                             } else if digit.kind == '0' {
-                                text = format!("{}0", text);
+                                text = format!("{text}0");
                             } else if digit.kind == '?' {
-                                text = format!("{} ", text);
+                                text = format!("{text} ");
                             }
                         } else if digit.number == 'e' {
                             // 3. Exponent part
                             let index = digit.index;
                             if index == 0 {
                                 if exponent_is_negative {
-                                    text = format!("{}E-", text);
+                                    text = format!("{text}E-");
                                 } else {
-                                    text = format!("{}E+", text);
+                                    text = format!("{text}E+");
                                 }
                             }
                             let number_index = l_exp - (p.exponent_digit_count - index);
@@ -400,7 +552,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                         exponent_part[number_index as usize]
                                     };
 
-                                    text = format!("{}{}", text, c);
+                                    text = format!("{text}{c}");
                                 }
                             } else {
                                 for i in 0..number_index + 1 {
@@ -422,6 +574,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 {
@@ -591,10 +750,10 @@ fn parse_date(value: &str) -> Result<(i32, String), String> {
 /// "30.34%" => (0.3034, "0.00%")
 /// 100€ => (100, "100€")
 pub(crate) fn parse_formatted_number(
-    value: &str,
+    original: &str,
     currencies: &[&str],
 ) -> Result<(f64, Option<String>), String> {
-    let value = value.trim();
+    let value = original.trim();
     let scientific_format = "0.00E+00";
 
     // Check if it is a percentage
@@ -614,7 +773,7 @@ pub(crate) fn parse_formatted_number(
 
     // check if it is a currency in currencies
     for currency in currencies {
-        if let Some(p) = value.strip_prefix(&format!("-{}", currency)) {
+        if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
             let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));
@@ -646,7 +805,8 @@ pub(crate) fn parse_formatted_number(
         }
     }
 
-    if let Ok((serial_number, format)) = parse_date(value) {
+    // check if it is a date. NOTE: we don't trim the original here
+    if let Ok((serial_number, format)) = parse_date(original) {
         return Ok((serial_number as f64, Some(format)));
     }
 

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,
 }
@@ -178,10 +182,7 @@ impl Lexer {
             }
         }
         self.position = position;
-        match chars.parse::<f64>() {
-            Err(_) => None,
-            Ok(v) => Some(v),
-        }
+        chars.parse::<f64>().ok()
     }
 
     fn consume_condition(&mut self) -> Option<(Compare, f64)> {
@@ -336,7 +337,7 @@ impl Lexer {
                         } else if s == '-' {
                             Token::ScientificMinus
                         } else {
-                            self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
+                            self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
                             Token::ILLEGAL
                         }
                     } else {
@@ -364,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,
@@ -384,18 +385,75 @@ 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();
                         if Some(c) != cc {
-                            self.set_error(&format!("Unexpected character: {}", x));
+                            self.set_error(&format!("Unexpected character: {x}"));
                             return Token::ILLEGAL;
                         }
                     }
                     Token::General
                 }
                 _ => {
-                    self.set_error(&format!("Unexpected character: {}", x));
+                    self.set_error(&format!("Unexpected character: {x}"));
                     Token::ILLEGAL
                 }
             },

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,12 +249,22 @@ impl Parser {
                     tokens.push(TextToken::MonthName);
                 }
                 Token::Month => {
-                    is_date = true;
-                    tokens.push(TextToken::Month);
+                    if is_time {
+                        // minute
+                        tokens.push(TextToken::Minute);
+                    } else {
+                        is_date = true;
+                        tokens.push(TextToken::Month);
+                    }
                 }
                 Token::MonthPadded => {
-                    is_date = true;
-                    tokens.push(TextToken::MonthPadded);
+                    if is_time {
+                        // minute padded
+                        tokens.push(TextToken::MinutePadded);
+                    } else {
+                        is_date = true;
+                        tokens.push(TextToken::MonthPadded);
+                    }
                 }
                 Token::MonthLetter => {
                     is_date = true;
@@ -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/database.rs

@@ -0,0 +1,946 @@
+use chrono::Datelike;
+
+use crate::{
+    calc_result::CalcResult,
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    formatter::dates::date_to_serial_number,
+    Model,
+};
+
+use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex};
+
+impl Model {
+    // =DAVERAGE(database, field, criteria)
+    pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut sum = 0.0f64;
+        let mut count = 0usize;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                        count += 1;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        CalcResult::Number(sum / count as f64)
+    }
+
+    // =DCOUNT(database, field, criteria)
+    // Counts numeric entries in the field for rows that match criteria
+    pub(crate) fn fn_dcount(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut count = 0usize;
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if matches!(v, CalcResult::Number(_)) {
+                    count += 1;
+                }
+            }
+            row += 1;
+        }
+
+        CalcResult::Number(count as f64)
+    }
+
+    // =DGET(database, field, criteria)
+    // Returns the (single) field value for the unique matching row
+    pub(crate) fn fn_dget(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut result: Option<CalcResult> = None;
+        let mut matches = 0usize;
+
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                matches += 1;
+                if matches > 1 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "More than one matching record".to_string(),
+                    };
+                }
+                result = Some(self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                }));
+            }
+            row += 1;
+        }
+
+        match (matches, result) {
+            (0, _) | (_, None) => CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No matching record".to_string(),
+            },
+            (_, Some(v)) => v,
+        }
+    }
+
+    // =DMAX(database, field, criteria)
+    pub(crate) fn fn_dmax(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.db_extreme(args, cell, true)
+    }
+
+    // =DMIN(database, field, criteria)
+    pub(crate) fn fn_dmin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.db_extreme(args, cell, false)
+    }
+
+    // =DSUM(database, field, criteria)
+    pub(crate) fn fn_dsum(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut sum = 0.0;
+
+        // skip header
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        CalcResult::Number(sum)
+    }
+
+    // =DCOUNTA(database, field, criteria)
+    // Counts non-empty entries (any type) in the field for rows that match criteria
+    pub(crate) fn fn_dcounta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut count = 0;
+        for row in (db_left.row + 1)..=db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if !matches!(v, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                    count += 1;
+                }
+            }
+        }
+
+        CalcResult::Number(count as f64)
+    }
+
+    // =DPRODUCT(database, field, criteria)
+    pub(crate) fn fn_dproduct(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut product = 1.0f64;
+        let mut has_numeric = false;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        product *= n;
+                        has_numeric = true;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        // Excel returns 0 when no rows / no numeric values match for DPRODUCT
+        if has_numeric {
+            CalcResult::Number(product)
+        } else {
+            CalcResult::Number(0.0)
+        }
+    }
+
+    // Small internal helper for DSTDEV / DVAR
+    // Collects sum, sum of squares, and count of numeric values in the field
+    // for rows that match the criteria.
+    fn db_numeric_stats(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+    ) -> Result<(f64, f64, usize), CalcResult> {
+        if args.len() != 3 {
+            return Err(CalcResult::new_args_number_error(cell));
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return Err(e),
+        };
+
+        let field_col = self.resolve_db_field_column(db_left, db_right, &args[1], cell)?;
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return Err(e),
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return Err(CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            });
+        }
+
+        let mut sum = 0.0f64;
+        let mut sumsq = 0.0f64;
+        let mut count = 0usize;
+
+        let mut row = db_left.row + 1; // skip header
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(n) = v {
+                    if n.is_finite() {
+                        sum += n;
+                        sumsq += n * n;
+                        count += 1;
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        Ok((sum, sumsq, count))
+    }
+
+    // =DSTDEV(database, field, criteria)
+    // Sample standard deviation of matching numeric values
+    pub(crate) fn fn_dstdev(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
+        if count < 2 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Not enough numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var.sqrt())
+    }
+
+    // =DVAR(database, field, criteria)
+    // Sample variance of matching numeric values
+    pub(crate) fn fn_dvar(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
+        if count < 2 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Not enough numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var)
+    }
+
+    // =DSTDEVP(database, field, criteria)
+    // Population standard deviation of matching numeric values
+    pub(crate) fn fn_dstdevp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if no numeric values match
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / n;
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var.sqrt())
+    }
+
+    // =DVARP(database, field, criteria)
+    // Population variance of matching numeric values
+    pub(crate) fn fn_dvarp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
+            Ok(stats) => stats,
+            Err(e) => return e,
+        };
+
+        // Excel behaviour: #DIV/0! if no numeric values match
+        if count == 0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "No numeric values matched criteria".to_string(),
+            };
+        }
+
+        let n = count as f64;
+        let var = (sumsq - (sum * sum) / n) / n;
+        let var = if var < 0.0 { 0.0 } else { var };
+        CalcResult::Number(var)
+    }
+
+    /// Resolve the "field" (2nd arg) to an absolute column index (i32) within the sheet.
+    /// Field can be a number (1-based index) or a header name (case-insensitive).
+    /// Returns the absolute column index, not a 1-based offset within the database range.
+    fn resolve_db_field_column(
+        &mut self,
+        db_left: CellReferenceIndex,
+        db_right: CellReferenceIndex,
+        field_arg: &Node,
+        cell: CellReferenceIndex,
+    ) -> Result<i32, CalcResult> {
+        let field_column_name = match self.evaluate_node_in_context(field_arg, cell) {
+            CalcResult::String(s) => s.to_lowercase(),
+            CalcResult::Number(index) => {
+                let index = index.floor() as i32;
+                if index < 1 || db_left.column + index - 1 > db_right.column {
+                    return Err(CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Field index out of range".to_string(),
+                    });
+                }
+                return Ok(db_left.column + index - 1);
+            }
+            CalcResult::Boolean(b) => {
+                return if b {
+                    Ok(db_left.column)
+                } else {
+                    // Index 0 is out of range
+                    Err(CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Invalid field specifier".to_string(),
+                    })
+                };
+            }
+            error @ CalcResult::Error { .. } => {
+                return Err(error);
+            }
+            CalcResult::Range { .. } => {
+                return Err(CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                })
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return Err(CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                })
+            }
+        };
+
+        // We search in the database a column whose header matches field_column_name
+        for column in db_left.column..=db_right.column {
+            let v = self.evaluate_cell(CellReferenceIndex {
+                sheet: db_left.sheet,
+                row: db_left.row,
+                column,
+            });
+            match &v {
+                CalcResult::String(s) => {
+                    if s.to_lowercase() == field_column_name {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Number(n) => {
+                    if field_column_name == n.to_string() {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Boolean(b) => {
+                    if field_column_name == b.to_string() {
+                        return Ok(column);
+                    }
+                }
+                CalcResult::Error { .. }
+                | CalcResult::Range { .. }
+                | CalcResult::EmptyCell
+                | CalcResult::EmptyArg
+                | CalcResult::Array(_) => {}
+            }
+        }
+
+        Err(CalcResult::Error {
+            error: Error::VALUE,
+            origin: cell,
+            message: "Field header not found".to_string(),
+        })
+    }
+
+    /// Check whether a database row matches the criteria range.
+    /// Criteria logic: OR across criteria rows; AND across columns within a row.
+    fn db_row_matches_criteria(
+        &mut self,
+        db_left: CellReferenceIndex,
+        db_right: CellReferenceIndex,
+        row: i32,
+        criteria: (CellReferenceIndex, CellReferenceIndex),
+    ) -> bool {
+        let (c_left, c_right) = criteria;
+
+        // Read criteria headers (first row of criteria range)
+        // Map header name (lowercased) -> db column (if exists)
+        let mut crit_cols: Vec<i32> = Vec::new();
+        let mut header_count = 0;
+        // We cover the criteria table:
+        //  headerA | headerB | ...
+        //  critA1  | critA2  | ...
+        //  critB1  | critB2  | ...
+        //  ...
+        for column in c_left.column..=c_right.column {
+            let cell = CellReferenceIndex {
+                sheet: c_left.sheet,
+                row: c_left.row,
+                column,
+            };
+            let criteria_header = self.evaluate_cell(cell);
+            if let Ok(s) = self.cast_to_string(criteria_header, cell) {
+                // Non-empty string header. If the header is non string we skip it
+                header_count += 1;
+                let wanted = s.to_lowercase();
+
+                // Find corresponding Database column
+                let mut found = false;
+                for db_column in db_left.column..=db_right.column {
+                    let db_header = self.evaluate_cell(CellReferenceIndex {
+                        sheet: db_left.sheet,
+                        row: db_left.row,
+                        column: db_column,
+                    });
+                    if let Ok(hs) = self.cast_to_string(db_header, cell) {
+                        if hs.to_lowercase() == wanted {
+                            crit_cols.push(db_column);
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                if !found {
+                    // that means the criteria column has no matching DB column
+                    // If the criteria condition is empty then we remove this condition
+                    // otherwise this condition can never be satisfied
+                    // We evaluate all criteria rows to see if any is non-empty
+                    let mut has_non_empty = false;
+                    for r in (c_left.row + 1)..=c_right.row {
+                        let ccell = self.evaluate_cell(CellReferenceIndex {
+                            sheet: c_left.sheet,
+                            row: r,
+                            column,
+                        });
+                        if !matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                            has_non_empty = true;
+                            break;
+                        }
+                    }
+                    if has_non_empty {
+                        // This criteria column can never be satisfied
+                        header_count -= 1;
+                    }
+                }
+            };
+        }
+
+        if c_right.row <= c_left.row {
+            // If no criteria rows (only headers), everything matches
+            return true;
+        }
+
+        if header_count == 0 {
+            // If there are not "String" headers, nothing matches
+            // NB: There might be String headers that do not match any DB columns,
+            // in that case everything matches.
+            return false;
+        }
+
+        // Evaluate each criteria row (OR)
+        for r in (c_left.row + 1)..=c_right.row {
+            // AND across columns for this criteria row
+            let mut and_ok = true;
+
+            for (offset, db_col) in crit_cols.iter().enumerate() {
+                // Criteria cell
+                let ccell = self.evaluate_cell(CellReferenceIndex {
+                    sheet: c_left.sheet,
+                    row: r,
+                    column: c_left.column + offset as i32,
+                });
+
+                // Empty criteria cell -> ignored
+                if matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
+                    continue;
+                }
+
+                // Database value for this row/column
+                let db_val = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: *db_col,
+                });
+
+                if !self.criteria_cell_matches(&db_val, &ccell) {
+                    and_ok = false;
+                    break;
+                }
+            }
+
+            if and_ok {
+                // This criteria row satisfied (OR)
+                return true;
+            }
+        }
+
+        // none matched
+        false
+    }
+
+    /// Implements Excel-like criteria matching for a single value.
+    /// Supports prefixes: <>, >=, <=, >, <, = ; wildcards * and ? for string equals.
+    fn criteria_cell_matches(&self, db_val: &CalcResult, crit_cell: &CalcResult) -> bool {
+        // Convert the criteria cell to a string for operator parsing if possible,
+        // otherwise fall back to equality via compare_values.
+
+        let mut criteria = match crit_cell {
+            CalcResult::String(s) => s.trim().to_string(),
+            CalcResult::Number(n) => {
+                // treat as equality with number
+                return match db_val {
+                    CalcResult::Number(v) => (*v - *n).abs() <= f64::EPSILON,
+                    _ => false,
+                };
+            }
+            CalcResult::Boolean(b) => {
+                // check equality with boolean
+                return match db_val {
+                    CalcResult::Boolean(v) => *v == *b,
+                    _ => false,
+                };
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Error { .. } => return false,
+            CalcResult::Range { .. } | CalcResult::Array(_) => return false,
+        };
+
+        // Detect operator prefix
+        let mut op = "="; // default equality (with wildcard semantics for strings)
+        let prefixes = ["<>", ">=", "<=", ">", "<", "="];
+        for p in prefixes.iter() {
+            if criteria.starts_with(p) {
+                op = p;
+                criteria = criteria[p.len()..].trim().to_string();
+                break;
+            }
+        }
+
+        // Is it a number?
+        let rhs_num = criteria.parse::<f64>().ok();
+
+        // Is it a date?
+        // FIXME: We should parse dates according to locale settings
+        let rhs_date = criteria.parse::<chrono::NaiveDate>().ok();
+
+        match op {
+            ">" | ">=" | "<" | "<=" => {
+                if let Some(d) = rhs_date {
+                    // date comparison
+                    let serial = match date_to_serial_number(d.day(), d.month(), d.year()) {
+                        Ok(sn) => sn as f64,
+                        Err(_) => return false,
+                    };
+
+                    if let CalcResult::Number(n) = db_val {
+                        match op {
+                            ">" => *n > serial,
+                            ">=" => *n >= serial,
+                            "<" => *n < serial,
+                            "<=" => *n <= serial,
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    }
+                } else if let Some(t) = rhs_num {
+                    // numeric comparison
+                    if let CalcResult::Number(n) = db_val {
+                        match op {
+                            ">" => *n > t,
+                            ">=" => *n >= t,
+                            "<" => *n < t,
+                            "<=" => *n <= t,
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    }
+                } else {
+                    // string comparison (case-insensitive) using compare_values semantics
+                    let rhs = CalcResult::String(criteria.to_lowercase());
+                    let lhs = match db_val {
+                        CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
+                        x => x.clone(),
+                    };
+                    let c = compare_values(&lhs, &rhs);
+                    match op {
+                        ">" => c > 0,
+                        ">=" => c >= 0,
+                        "<" => c < 0,
+                        "<=" => c <= 0,
+                        _ => false,
+                    }
+                }
+            }
+            "<>" => {
+                // not equal (with wildcard semantics for strings)
+                // If rhs has wildcards and db_val is string, do regex; else use compare_values != 0
+                if let CalcResult::String(s) = db_val {
+                    if criteria.contains('*') || criteria.contains('?') {
+                        if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
+                            return !result_matches_regex(
+                                &CalcResult::String(s.to_lowercase()),
+                                &re,
+                            );
+                        }
+                    }
+                }
+                let rhs = if let Some(n) = rhs_num {
+                    CalcResult::Number(n)
+                } else {
+                    CalcResult::String(criteria.to_lowercase())
+                };
+                let lhs = match db_val {
+                    CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
+                    x => x.clone(),
+                };
+                compare_values(&lhs, &rhs) != 0
+            }
+            _ => {
+                // equality. For strings, support wildcards (*, ?)
+                if let Some(n) = rhs_num {
+                    // numeric equals
+                    if let CalcResult::Number(m) = db_val {
+                        (*m - n).abs() <= f64::EPSILON
+                    } else {
+                        compare_values(db_val, &CalcResult::Number(n)) == 0
+                    }
+                } else {
+                    // textual/boolean equals (case-insensitive), wildcard-enabled for strings
+                    if let CalcResult::String(s) = db_val {
+                        if criteria.contains('*') || criteria.contains('?') {
+                            if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
+                                return result_matches_regex(
+                                    &CalcResult::String(s.to_lowercase()),
+                                    &re,
+                                );
+                            }
+                        }
+                        // This is weird but we only need to check if "starts with" for equality
+                        return s.to_lowercase().starts_with(&criteria.to_lowercase());
+                    }
+                    // Fallback: compare_values equality
+                    compare_values(db_val, &CalcResult::String(criteria.to_lowercase())) == 0
+                }
+            }
+        }
+    }
+
+    /// Shared implementation for DMAX/DMIN
+    fn db_extreme(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        want_max: bool,
+    ) -> CalcResult {
+        if args.len() != 3 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
+            Ok(c) => c,
+            Err(e) => return e,
+        };
+
+        let criteria = match self.get_reference(&args[2], cell) {
+            Ok(r) => (r.left, r.right),
+            Err(e) => return e,
+        };
+
+        if db_right.row <= db_left.row {
+            // no data rows
+            return CalcResult::Error {
+                error: Error::VALUE,
+                origin: cell,
+                message: "No data rows in database".to_string(),
+            };
+        }
+
+        let mut best: Option<f64> = None;
+
+        let mut row = db_left.row + 1;
+        while row <= db_right.row {
+            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
+                let v = self.evaluate_cell(CellReferenceIndex {
+                    sheet: db_left.sheet,
+                    row,
+                    column: field_col,
+                });
+                if let CalcResult::Number(value) = v {
+                    if value.is_finite() {
+                        best = Some(match best {
+                            None => value,
+                            Some(cur) => {
+                                if want_max {
+                                    value.max(cur)
+                                } else {
+                                    value.min(cur)
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+            row += 1;
+        }
+
+        match best {
+            Some(v) => CalcResult::Number(v),
+            None => CalcResult::Number(0.0),
+        }
+    }
+}

base/src/functions/engineering/bessel.rs

@@ -1,10 +1,12 @@
+use statrs::function::erf::{erf, erfc};
+
 use crate::{
     calc_result::CalcResult,
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     model::Model,
 };
 
-use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y, erf};
+use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y};
 // https://root.cern/doc/v610/TMath_8cxx_source.html
 
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
@@ -160,7 +162,7 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(1.0 - erf(x))
+        CalcResult::Number(erfc(x))
     }
 
     pub(crate) fn fn_erfcprecise(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -171,6 +173,6 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(1.0 - erf(x))
+        CalcResult::Number(erfc(x))
     }
 }

base/src/functions/engineering/complex.rs

@@ -46,18 +46,18 @@ impl fmt::Display for Complex {
         // it is a bit weird what Excel does but it seems it uses general notation for
         // numbers > 1e-20 and scientific notation for the rest
         let y_str = if y.abs() <= 9e-20 {
-            format!("{:E}", y)
+            format!("{y:E}")
         } else if y == 1.0 {
             "".to_string()
         } else if y == -1.0 {
             "-".to_string()
         } else {
-            format!("{}", y)
+            format!("{y}")
         };
         let x_str = if x.abs() <= 9e-20 {
-            format!("{:E}", x)
+            format!("{x:E}")
         } else {
-            format!("{}", x)
+            format!("{x}")
         };
         if y == 0.0 && x == 0.0 {
             write!(f, "0")

base/src/functions/engineering/number_basis.rs

@@ -76,7 +76,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
         } else {
-            let result = format!("{:X}", value);
+            let result = format!("{value:X}");
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -120,7 +120,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9))
         } else {
-            let result = format!("{:o}", value);
+            let result = format!("{value:o}");
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -163,7 +163,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -202,7 +202,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{:X}", value);
+        let result = format!("{value:X}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -242,7 +242,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{:o}", value);
+        let result = format!("{value:o}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -301,7 +301,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -391,7 +391,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{:o}", value);
+        let result = format!("{value:o}");
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -446,7 +446,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if value < 512 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -532,7 +532,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{:X}", value);
+        let result = format!("{value:X}");
         if let Some(places) = places {
             if value < HEX_MAX_HALF && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());

base/src/functions/engineering/transcendental/erf.rs

@@ -1,53 +0,0 @@
-pub(crate) fn erf(x: f64) -> f64 {
-    let cof = vec![
-        -1.3026537197817094,
-        6.419_697_923_564_902e-1,
-        1.9476473204185836e-2,
-        -9.561_514_786_808_63e-3,
-        -9.46595344482036e-4,
-        3.66839497852761e-4,
-        4.2523324806907e-5,
-        -2.0278578112534e-5,
-        -1.624290004647e-6,
-        1.303655835580e-6,
-        1.5626441722e-8,
-        -8.5238095915e-8,
-        6.529054439e-9,
-        5.059343495e-9,
-        -9.91364156e-10,
-        -2.27365122e-10,
-        9.6467911e-11,
-        2.394038e-12,
-        -6.886027e-12,
-        8.94487e-13,
-        3.13092e-13,
-        -1.12708e-13,
-        3.81e-16,
-        7.106e-15,
-        -1.523e-15,
-        -9.4e-17,
-        1.21e-16,
-        -2.8e-17,
-    ];
-
-    let mut d = 0.0;
-    let mut dd = 0.0;
-
-    let x_abs = x.abs();
-
-    let t = 2.0 / (2.0 + x_abs);
-    let ty = 4.0 * t - 2.0;
-
-    for j in (1..=cof.len() - 1).rev() {
-        let tmp = d;
-        d = ty * d - dd + cof[j];
-        dd = tmp;
-    }
-
-    let res = t * f64::exp(-x_abs * x_abs + 0.5 * (cof[0] + ty * d) - dd);
-    if x < 0.0 {
-        res - 1.0
-    } else {
-        1.0 - res
-    }
-}

base/src/functions/engineering/transcendental/mod.rs

@@ -4,7 +4,6 @@ mod bessel_j1_y1;
 mod bessel_jn_yn;
 mod bessel_k;
 mod bessel_util;
-mod erf;
 
 #[cfg(test)]
 mod test_bessel;
@@ -13,4 +12,3 @@ pub(crate) use bessel_i::bessel_i;
 pub(crate) use bessel_jn_yn::jn as bessel_j;
 pub(crate) use bessel_jn_yn::yn as bessel_y;
 pub(crate) use bessel_k::bessel_k;
-pub(crate) use erf::erf;

base/src/functions/financial.rs

@@ -231,7 +231,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{}'", sheet),
+                                format!("Invalid worksheet index: '{sheet}'"),
                             )
                         })?
                         .dimension()
@@ -245,7 +245,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{}'", sheet),
+                                format!("Invalid worksheet index: '{sheet}'"),
                             )
                         })?
                         .dimension()

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},
 };
 
@@ -235,6 +235,11 @@ impl Model {
                 // This cannot happen
                 CalcResult::Number(1.0)
             }
+            CalcResult::Array(_) => CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            },
         }
     }
     pub(crate) fn fn_sheet(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -249,7 +254,7 @@ impl Model {
         // The arg could be a defined name or a table
         // let  = &args[0];
         match &args[0] {
-            Node::DefinedNameKind((name, scope)) => {
+            Node::DefinedNameKind((name, scope, _)) => {
                 // Let's see if it is a defined name
                 if let Some(defined_name) = self
                     .parsed_defined_names
@@ -315,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/logical.rs

@@ -161,6 +161,13 @@ impl Model {
                                 CalcResult::Range { .. }
                                 | CalcResult::String { .. }
                                 | CalcResult::EmptyCell => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                             if let (Some(current_result), Some(short_circuit_value)) =
                                 (result, short_circuit_value)
@@ -185,6 +192,13 @@ impl Model {
                 }
                 // References to empty cells are ignored. If all args are ignored the result is #VALUE!
                 CalcResult::EmptyCell => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             }
 
             if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
@@ -232,7 +246,7 @@ impl Model {
         }
         // None of the cases matched so we return the default
         // If there is an even number of args is the last one otherwise is #N/A
-        if args_count % 2 == 0 {
+        if args_count.is_multiple_of(2) {
             return self.evaluate_node_in_context(&args[args_count - 1], cell);
         }
         CalcResult::Error {
@@ -248,7 +262,7 @@ impl Model {
         if args_count < 2 {
             return CalcResult::new_args_number_error(cell);
         }
-        if args_count % 2 != 0 {
+        if !args_count.is_multiple_of(2) {
             // Missing value for last condition
             return CalcResult::new_args_number_error(cell);
         }

base/src/functions/lookup_and_reference.rs

@@ -855,7 +855,7 @@ impl Model {
             if left.row != right.row || left.column != right.column {
                 // FIXME: Implicit intersection or dynamic arrays
                 return CalcResult::Error {
-                    error: Error::ERROR,
+                    error: Error::NIMPL,
                     origin: cell,
                     message: "argument must be a reference to a single cell".to_string(),
                 };

base/src/functions/macros.rs

@@ -0,0 +1,100 @@
+#[macro_export]
+macro_rules! single_number_fn {
+    // The macro takes:
+    //   1) A function name to define (e.g. fn_sin)
+    //   2) The operation to apply (e.g. f64::sin)
+    ($fn_name:ident, $op:expr) => {
+        pub(crate) fn $fn_name(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+            // 1) Check exactly one argument
+            if args.len() != 1 {
+                return CalcResult::new_args_number_error(cell);
+            }
+            // 2) Try to get a "NumberOrArray"
+            match self.get_number_or_array(&args[0], cell) {
+                // -----------------------------------------
+                // Case A: It's a single number
+                // -----------------------------------------
+                Ok(NumberOrArray::Number(f)) => match $op(f) {
+                    Ok(x) => CalcResult::Number(x),
+                    Err(Error::DIV) => CalcResult::Error {
+                        error: Error::DIV,
+                        origin: cell,
+                        message: "Divide by 0".to_string(),
+                    },
+                    Err(Error::VALUE) => CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Invalid number".to_string(),
+                    },
+                    Err(e) => CalcResult::Error {
+                        error: e,
+                        origin: cell,
+                        message: "Unknown error".to_string(),
+                    },
+                },
+
+                // -----------------------------------------
+                // Case B: It's an array, so apply $op
+                // element-by-element.
+                // -----------------------------------------
+                Ok(NumberOrArray::Array(a)) => {
+                    let mut array = Vec::new();
+                    for row in a {
+                        let mut data_row = Vec::with_capacity(row.len());
+                        for value in row {
+                            match value {
+                                // If Boolean, treat as 0.0 or 1.0
+                                ArrayNode::Boolean(b) => {
+                                    let n = if b { 1.0 } else { 0.0 };
+                                    match $op(n) {
+                                        Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                        Err(Error::DIV) => {
+                                            data_row.push(ArrayNode::Error(Error::DIV))
+                                        }
+                                        Err(Error::VALUE) => {
+                                            data_row.push(ArrayNode::Error(Error::VALUE))
+                                        }
+                                        Err(e) => data_row.push(ArrayNode::Error(e)),
+                                    }
+                                }
+                                // If Number, apply directly
+                                ArrayNode::Number(n) => match $op(n) {
+                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                    Err(Error::VALUE) => {
+                                        data_row.push(ArrayNode::Error(Error::VALUE))
+                                    }
+                                    Err(e) => data_row.push(ArrayNode::Error(e)),
+                                },
+                                // If String, parse to f64 then apply or #VALUE! error
+                                ArrayNode::String(s) => {
+                                    let node = match self.cast_number(&s) {
+                                        Some(f) => match $op(f) {
+                                            Ok(x) => ArrayNode::Number(x),
+                                            Err(Error::DIV) => ArrayNode::Error(Error::DIV),
+                                            Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
+                                            Err(e) => ArrayNode::Error(e),
+                                        },
+                                        None => ArrayNode::Error(Error::VALUE),
+                                    };
+                                    data_row.push(node);
+                                }
+                                // If Error, propagate the error
+                                e @ ArrayNode::Error(_) => {
+                                    data_row.push(e);
+                                }
+                            }
+                        }
+                        array.push(data_row);
+                    }
+                    CalcResult::Array(array)
+                }
+
+                // -----------------------------------------
+                // Case C: It's an Error => just return it
+                // -----------------------------------------
+                Err(err_result) => err_result,
+            }
+        }
+    };
+}

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

@@ -8,6 +8,7 @@ use crate::{
 };
 
 pub(crate) mod binary_search;
+mod database;
 mod date_and_time;
 mod engineering;
 mod financial;
@@ -15,6 +16,8 @@ mod financial_util;
 mod information;
 mod logical;
 mod lookup_and_reference;
+mod macros;
+mod math_util;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -53,6 +56,9 @@ pub enum Function {
     Columns,
     Cos,
     Cosh,
+    Log,
+    Log10,
+    Ln,
     Max,
     Min,
     Pi,
@@ -72,6 +78,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,
@@ -92,6 +135,11 @@ pub enum Function {
     Sheet,
     Type,
 
+    Sheets,
+    N,
+    Cell,
+    Info,
+
     // Lookup and reference
     Hlookup,
     Index,
@@ -144,13 +192,30 @@ 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
     Cumipmt,
@@ -246,10 +311,24 @@ pub enum Function {
     Delta,
     Gestep,
     Subtotal,
+
+    // Database
+    Daverage,
+    Dcount,
+    Dget,
+    Dmax,
+    Dmin,
+    Dsum,
+    Dcounta,
+    Dproduct,
+    Dstdev,
+    Dvar,
+    Dvarp,
+    Dstdevp,
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 195> {
+    pub fn into_iter() -> IntoIter<Function, 268> {
         [
             Function::And,
             Function::False,
@@ -276,15 +355,50 @@ impl Function {
             Function::Atanh,
             Function::Abs,
             Function::Pi,
+            Function::Ln,
+            Function::Log,
+            Function::Log10,
             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,
@@ -355,9 +469,26 @@ 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::Pmt,
             Function::Pv,
             Function::Rate,
@@ -446,6 +577,27 @@ 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,
+            Function::Daverage,
+            Function::Dcount,
+            Function::Dget,
+            Function::Dmax,
+            Function::Dmin,
+            Function::Dsum,
+            Function::Dcounta,
+            Function::Dproduct,
+            Function::Dstdev,
+            Function::Dvar,
+            Function::Dvarp,
+            Function::Dstdevp,
         ]
         .into_iter()
     }
@@ -487,6 +639,27 @@ 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(),
+            Function::Acoth => "_xlfn.ACOTH".to_string(),
+            Function::Cot => "_xlfn.COT".to_string(),
+            Function::Coth => "_xlfn.COTH".to_string(),
+            Function::Csc => "_xlfn.CSC".to_string(),
+            Function::Csch => "_xlfn.CSCH".to_string(),
+            Function::Sec => "_xlfn.SEC".to_string(),
+            Function::Sech => "_xlfn.SECH".to_string(),
+            Function::Acot => "_xlfn.ACOT".to_string(),
+
             _ => self.to_string(),
         }
     }
@@ -509,30 +682,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" | "_XLFN.ACOT" => Some(Function::Acot),
+            "COTH" | "_XLFN.COTH" => Some(Function::Coth),
+            "COT" | "_XLFN.COT" => Some(Function::Cot),
+            "CSC" | "_XLFN.CSC" => Some(Function::Csc),
+            "CSCH" | "_XLFN.CSCH" => Some(Function::Csch),
+            "SEC" | "_XLFN.SEC" => Some(Function::Sec),
+            "SECH" | "_XLFN.SECH" => Some(Function::Sech),
+            "ACOTH" | "_XLFN.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),
@@ -544,6 +748,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),
@@ -620,9 +827,26 @@ 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
             "PMT" => Some(Function::Pmt),
             "PV" => Some(Function::Pv),
@@ -714,6 +938,25 @@ 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),
+
+            "DAVERAGE" => Some(Function::Daverage),
+            "DCOUNT" => Some(Function::Dcount),
+            "DGET" => Some(Function::Dget),
+            "DMAX" => Some(Function::Dmax),
+            "DMIN" => Some(Function::Dmin),
+            "DSUM" => Some(Function::Dsum),
+            "DCOUNTA" => Some(Function::Dcounta),
+            "DPRODUCT" => Some(Function::Dproduct),
+            "DSTDEV" => Some(Function::Dstdev),
+            "DVAR" => Some(Function::Dvar),
+            "DVARP" => Some(Function::Dvarp),
+            "DSTDEVP" => Some(Function::Dstdevp),
+
             _ => None,
         }
     }
@@ -733,6 +976,9 @@ impl fmt::Display for Function {
             Function::Switch => write!(f, "SWITCH"),
             Function::True => write!(f, "TRUE"),
             Function::Xor => write!(f, "XOR"),
+            Function::Log => write!(f, "LOG"),
+            Function::Log10 => write!(f, "LOG10"),
+            Function::Ln => write!(f, "LN"),
             Function::Sin => write!(f, "SIN"),
             Function::Cos => write!(f, "COS"),
             Function::Tan => write!(f, "TAN"),
@@ -745,6 +991,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"),
@@ -809,7 +1063,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"),
@@ -827,9 +1080,26 @@ 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::Pmt => write!(f, "PMT"),
             Function::Pv => write!(f, "PV"),
             Function::Rate => write!(f, "RATE"),
@@ -917,8 +1187,53 @@ 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"),
+            Function::Daverage => write!(f, "DAVERAGE"),
+            Function::Dcount => write!(f, "DCOUNT"),
+            Function::Dget => write!(f, "DGET"),
+            Function::Dmax => write!(f, "DMAX"),
+            Function::Dmin => write!(f, "DMIN"),
+            Function::Dsum => write!(f, "DSUM"),
+            Function::Dcounta => write!(f, "DCOUNTA"),
+            Function::Dproduct => write!(f, "DPRODUCT"),
+            Function::Dstdev => write!(f, "DSTDEV"),
+            Function::Dvar => write!(f, "DVAR"),
+            Function::Dvarp => write!(f, "DVARP"),
+            Function::Dstdevp => write!(f, "DSTDEVP"),
         }
     }
 }
@@ -947,7 +1262,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),
@@ -959,31 +1273,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),
@@ -995,8 +1305,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),
@@ -1010,7 +1318,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),
@@ -1028,7 +1335,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),
@@ -1046,7 +1352,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),
@@ -1059,16 +1364,31 @@ 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),
-            // Financial
+            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),
             Function::Pmt => self.fn_pmt(args, cell),
             Function::Pv => self.fn_pv(args, cell),
             Function::Rate => self.fn_rate(args, cell),
@@ -1102,7 +1422,6 @@ impl Model {
             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),
@@ -1157,8 +1476,60 @@ 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),
+            Function::Daverage => self.fn_daverage(args, cell),
+            Function::Dcount => self.fn_dcount(args, cell),
+            Function::Dget => self.fn_dget(args, cell),
+            Function::Dmax => self.fn_dmax(args, cell),
+            Function::Dmin => self.fn_dmin(args, cell),
+            Function::Dsum => self.fn_dsum(args, cell),
+            Function::Dcounta => self.fn_dcounta(args, cell),
+            Function::Dproduct => self.fn_dproduct(args, cell),
+            Function::Dstdev => self.fn_dstdev(args, cell),
+            Function::Dvar => self.fn_dvar(args, cell),
+            Function::Dvarp => self.fn_dvarp(args, cell),
+            Function::Dstdevp => self.fn_dstdevp(args, cell),
         }
     }
 }
@@ -1213,7 +1584,7 @@ mod tests {
         }
         // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
         let iter_list = Function::into_iter()
-            .map(|f| format!("{}", f).replace('.', ""))
+            .map(|f| format!("{f}").replace('.', ""))
             .collect::<Vec<_>>();
 
         let len = iter_list.len();

base/src/functions/statistical.rs

@@ -134,6 +134,13 @@ impl Model {
                                     );
                                 }
                                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                         }
                     }
@@ -165,6 +172,13 @@ impl Model {
                 }
                 error @ CalcResult::Error { .. } => return error,
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
         }
         if count == 0.0 {
@@ -336,7 +350,7 @@ impl Model {
     // FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
     pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let args_count = args.len();
-        if args_count < 2 || args_count % 2 == 1 {
+        if args_count < 2 || !args_count.is_multiple_of(2) {
             return CalcResult::new_args_number_error(cell);
         }
 
@@ -462,7 +476,7 @@ impl Model {
         F: FnMut(f64),
     {
         let args_count = args.len();
-        if args_count < 3 || args_count % 2 == 0 {
+        if args_count < 3 || args_count.is_multiple_of(2) {
             return Err(CalcResult::new_args_number_error(cell));
         }
         let arg_0 = self.evaluate_node_in_context(&args[0], cell);

base/src/functions/subtotal.rs

@@ -182,6 +182,13 @@ impl Model {
                             }
                         }
                         CalcResult::EmptyCell | CalcResult::EmptyArg => result.push(0.0),
+                        CalcResult::Array(_) => {
+                            return Err(CalcResult::Error {
+                                error: Error::NIMPL,
+                                origin: cell,
+                                message: "Arrays not supported yet".to_string(),
+                            })
+                        }
                     }
                 }
             }
@@ -426,6 +433,13 @@ impl Model {
                         | CalcResult::Number(_)
                         | CalcResult::Boolean(_)
                         | CalcResult::Error { .. } => counta += 1,
+                        CalcResult::Array(_) => {
+                            return CalcResult::Error {
+                                error: Error::NIMPL,
+                                origin: cell,
+                                message: "Arrays not supported yet".to_string(),
+                            }
+                        }
                     }
                 }
             }

base/src/functions/text.rs

@@ -55,14 +55,14 @@ impl Model {
         let mut result = "".to_string();
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::String(value) => result = format!("{}{}", result, value),
-                CalcResult::Number(value) => result = format!("{}{}", result, value),
+                CalcResult::String(value) => result = format!("{result}{value}"),
+                CalcResult::Number(value) => result = format!("{result}{value}"),
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                 CalcResult::Boolean(value) => {
                     if value {
-                        result = format!("{}TRUE", result);
+                        result = format!("{result}TRUE");
                     } else {
-                        result = format!("{}FALSE", result);
+                        result = format!("{result}FALSE");
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
@@ -82,25 +82,37 @@ impl Model {
                                 column,
                             }) {
                                 CalcResult::String(value) => {
-                                    result = format!("{}{}", result, value);
-                                }
-                                CalcResult::Number(value) => {
-                                    result = format!("{}{}", result, value)
+                                    result = format!("{result}{value}");
                                 }
+                                CalcResult::Number(value) => result = format!("{result}{value}"),
                                 CalcResult::Boolean(value) => {
                                     if value {
-                                        result = format!("{}TRUE", result);
+                                        result = format!("{result}TRUE");
                                     } else {
-                                        result = format!("{}FALSE", result);
+                                        result = format!("{result}FALSE");
                                     }
                                 }
                                 error @ CalcResult::Error { .. } => return error,
                                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                                 CalcResult::Range { .. } => {}
+                                CalcResult::Array(_) => {
+                                    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::String(result)
@@ -125,6 +137,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             let format_code = match self.get_string(&args[1], cell) {
                 Ok(s) => s,
@@ -261,7 +280,7 @@ impl Model {
     pub(crate) fn fn_len(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -280,6 +299,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::Number(s.chars().count() as f64);
         }
@@ -289,7 +315,7 @@ impl Model {
     pub(crate) fn fn_trim(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -308,6 +334,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.trim().to_owned());
         }
@@ -317,7 +350,7 @@ impl Model {
     pub(crate) fn fn_lower(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -336,6 +369,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.to_lowercase());
         }
@@ -345,7 +385,7 @@ impl Model {
     pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -370,6 +410,13 @@ impl Model {
                         message: "Empty cell".to_string(),
                     }
                 }
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
 
             match s.chars().next() {
@@ -392,7 +439,7 @@ impl Model {
     pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -411,6 +458,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.to_uppercase());
         }
@@ -422,7 +476,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -441,6 +495,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let num_chars = if args.len() == 2 {
             match self.evaluate_node_in_context(&args[1], cell) {
@@ -471,6 +532,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             }
         } else {
             1
@@ -490,7 +558,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -509,6 +577,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let num_chars = if args.len() == 2 {
             match self.evaluate_node_in_context(&args[1], cell) {
@@ -539,6 +614,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             }
         } else {
             1
@@ -558,7 +640,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -577,6 +659,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let start_num = match self.evaluate_node_in_context(&args[1], cell) {
             CalcResult::Number(v) => {
@@ -641,6 +730,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let mut result = "".to_string();
         let mut count: usize = 0;
@@ -983,6 +1079,13 @@ impl Model {
                                 }
                                 error @ CalcResult::Error { .. } => return error,
                                 CalcResult::EmptyArg | CalcResult::Range { .. } => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                         }
                     }
@@ -1002,6 +1105,13 @@ impl Model {
                     }
                 }
                 CalcResult::EmptyArg => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
         }
         let result = values.join(&delimiter);
@@ -1125,6 +1235,11 @@ impl Model {
                 }
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => CalcResult::Number(0.0),
+            CalcResult::Array(_) => CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            },
         }
     }
 

base/src/functions/util.rs

@@ -1,7 +1,10 @@
 #[cfg(feature = "use_regex_lite")]
 use regex_lite as regex;
 
-use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
+use crate::{
+    calc_result::CalcResult, expressions::token::is_english_error_string,
+    number_format::to_excel_precision,
+};
 
 /// This test for exact match (modulo case).
 ///   * strings are not cast into bools or numbers
@@ -34,6 +37,8 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
     match (left, right) {
         (CalcResult::Number(value1), CalcResult::Number(value2)) => {
+            let value1 = to_excel_precision(*value1, 15);
+            let value2 = to_excel_precision(*value2, 15);
             if (value2 - value1).abs() < f64::EPSILON {
                 return 0;
             }
@@ -110,7 +115,7 @@ pub(crate) fn from_wildcard_to_regex(
 
     // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
     if exact {
-        return regex::Regex::new(&format!("^{}$", reg));
+        return regex::Regex::new(&format!("^{reg}$"));
     }
     regex::Regex::new(reg)
 }
@@ -393,10 +398,8 @@ pub(crate) fn build_criteria<'a>(value: &'a CalcResult) -> Box<dyn Fn(&CalcResul
             // An error will match an error (never a string that is an error)
             Box::new(move |x| result_is_equal_to_error(x, &error.to_string()))
         }
-        CalcResult::Range { left: _, right: _ } => {
-            // TODO: Implicit Intersection
-            Box::new(move |_x| false)
-        }
+        CalcResult::Range { left: _, right: _ } => Box::new(move |_x| false),
+        CalcResult::Array(_) => Box::new(move |_x| false),
         CalcResult::EmptyCell | CalcResult::EmptyArg => Box::new(result_is_equal_to_empty),
     }
 }

base/src/functions/xlookup.rs

@@ -141,9 +141,9 @@ impl Model {
     ///   *  1 - Perform a search starting at the first item. This is the default.
     ///   * -1 - Perform a reverse search starting at the last item.
     ///   *  2 - Perform a binary search that relies on lookup_array being sorted
-    ///          in ascending order. If not sorted, invalid results will be returned.
+    ///      in ascending order. If not sorted, invalid results will be returned.
     ///   * -2 - Perform a binary search that relies on lookup_array being sorted
-    ///          in descending order. If not sorted, invalid results will be returned.
+    ///     in descending order. If not sorted, invalid results will be returned.
     pub(crate) fn fn_xlookup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 3 || args.len() > 6 {
             return CalcResult::new_args_number_error(cell);

base/src/language/mod.rs

@@ -1,7 +1,6 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
-use once_cell::sync::Lazy;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Booleans {
@@ -31,14 +30,17 @@ pub struct Language {
     pub errors: Errors,
 }
 
+static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
+
 #[allow(clippy::expect_used)]
-static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
-});
+fn get_languages() -> &'static HashMap<String, Language> {
+    LANGUAGES.get_or_init(|| {
+        bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
+    })
+}
 
 pub fn get_language(id: &str) -> Result<&Language, String> {
-    let language = LANGUAGES
+    get_languages()
         .get(id)
-        .ok_or(format!("Language is not supported: '{}'", id))?;
-    Ok(language)
+        .ok_or_else(|| format!("Language is not supported: '{id}'"))
 }

base/src/lib.rs

@@ -39,9 +39,9 @@ pub mod types;
 pub mod worksheet;
 
 mod actions;
+mod arithmetic;
 mod cast;
 mod constants;
-mod diffs;
 mod functions;
 mod implicit_intersection;
 mod model;

base/src/locale/mod.rs

@@ -1,7 +1,6 @@
-use bitcode::{Decode, Encode};
-use once_cell::sync::Lazy;
+use std::{collections::HashMap, sync::OnceLock};
 
-use std::collections::HashMap;
+use bitcode::{Decode, Encode};
 
 #[derive(Encode, Decode, Clone)]
 pub struct Locale {
@@ -65,12 +64,17 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
+static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
+
 #[allow(clippy::expect_used)]
-static LOCALES: Lazy<HashMap<String, Locale>> =
-    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
+fn get_locales() -> &'static HashMap<String, Locale> {
+    LOCALES.get_or_init(|| {
+        bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
+    })
+}
 
 pub fn get_locale(id: &str) -> Result<&Locale, String> {
-    // TODO: pass the locale once we implement locales in Rust
-    let locale = LOCALES.get(id).ok_or("Invalid locale")?;
-    Ok(locale)
+    get_locales()
+        .get(id)
+        .ok_or_else(|| format!("Invalid locale: '{id}'"))
 }

base/src/model.rs

@@ -106,15 +106,15 @@ pub struct Model {
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
     pub(crate) parser: Parser,
-    /// The list of cells with formulas that are evaluated of being evaluated
+    /// The list of cells with formulas that are evaluated or being evaluated
     pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
     pub(crate) locale: Locale,
-    /// Tha language used
+    /// The language used
     pub(crate) language: Language,
     /// The timezone used to evaluate the model
     pub(crate) tz: Tz,
-    /// The view id. A view consist of a selected sheet and ranges.
+    /// The view id. A view consists of a selected sheet and ranges.
     pub(crate) view_id: u32,
 }
 
@@ -207,6 +207,17 @@ impl Model {
                     },
                 }
             }
+            Node::ImplicitIntersection {
+                automatic: _,
+                child,
+            } => match self.evaluate_node_with_reference(child, cell) {
+                CalcResult::Range { left, right } => CalcResult::Range { left, right },
+                _ => CalcResult::new_error(
+                    Error::ERROR,
+                    cell,
+                    format!("Error with Implicit Intersection in cell {cell:?}"),
+                ),
+            },
             _ => self.evaluate_node_in_context(node, cell),
         }
     }
@@ -256,27 +267,10 @@ impl Model {
     ) -> CalcResult {
         use Node::*;
         match node {
-            OpSumKind { kind, left, right } => {
-                // In the future once the feature try trait stabilizes we could use the '?' operator for this :)
-                // See: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=236044e8321a1450988e6ffe5a27dab5
-                let l = match self.get_number(left, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
-                    }
-                };
-                let r = match self.get_number(right, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
-                    }
-                };
-                let result = match kind {
-                    OpSum::Add => l + r,
-                    OpSum::Minus => l - r,
-                };
-                CalcResult::Number(result)
-            }
+            OpSumKind { kind, left, right } => match kind {
+                OpSum::Add => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 + f2)),
+                OpSum::Minus => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 - f2)),
+            },
             NumberKind(value) => CalcResult::Number(*value),
             StringKind(value) => CalcResult::String(value.replace(r#""""#, r#"""#)),
             BooleanKind(value) => CalcResult::Boolean(*value),
@@ -361,62 +355,30 @@ impl Model {
                         return s;
                     }
                 };
-                let result = format!("{}{}", l, r);
+                let result = format!("{l}{r}");
                 CalcResult::String(result)
             }
-            OpProductKind { kind, left, right } => {
-                let l = match self.get_number(left, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
+            OpProductKind { kind, left, right } => match kind {
+                OpProduct::Times => {
+                    self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 * f2))
+                }
+                OpProduct::Divide => self.handle_arithmetic(left, right, cell, &|f1, f2| {
+                    if f2 == 0.0 {
+                        Err(Error::DIV)
+                    } else {
+                        Ok(f1 / f2)
                     }
-                };
-                let r = match self.get_number(right, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
-                    }
-                };
-                let result = match kind {
-                    OpProduct::Times => l * r,
-                    OpProduct::Divide => {
-                        if r == 0.0 {
-                            return CalcResult::new_error(
-                                Error::DIV,
-                                cell,
-                                "Divide by Zero".to_string(),
-                            );
-                        }
-                        l / r
-                    }
-                };
-                CalcResult::Number(result)
-            }
+                }),
+            },
             OpPowerKind { left, right } => {
-                let l = match self.get_number(left, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
-                    }
-                };
-                let r = match self.get_number(right, cell) {
-                    Ok(f) => f,
-                    Err(s) => {
-                        return s;
-                    }
-                };
-                // Deal with errors properly
-                CalcResult::Number(l.powf(r))
+                self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1.powf(f2)))
             }
             FunctionKind { kind, args } => self.evaluate_function(kind, args, cell),
             InvalidFunctionKind { name, args: _ } => {
-                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {}", name))
+                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}"))
             }
-            ArrayKind(_) => {
-                // TODO: NOT IMPLEMENTED
-                CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
-            }
-            DefinedNameKind((name, scope)) => {
+            ArrayKind(s) => CalcResult::Array(s.to_owned()),
+            DefinedNameKind((name, scope, _)) => {
                 if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
                     match parsed_defined_name {
                         ParsedDefinedName::CellReference(reference) => {
@@ -429,26 +391,26 @@ impl Model {
                         ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
                             Error::NAME,
                             cell,
-                            format!("Defined name \"{}\" is not a reference.", name),
+                            format!("Defined name \"{name}\" is not a reference."),
                         ),
                     }
                 } else {
                     CalcResult::new_error(
                         Error::NAME,
                         cell,
-                        format!("Defined name \"{}\" not found.", name),
+                        format!("Defined name \"{name}\" not found."),
                     )
                 }
             }
             TableNameKind(s) => CalcResult::new_error(
                 Error::NAME,
                 cell,
-                format!("table name \"{}\" not supported.", s),
+                format!("table name \"{s}\" not supported."),
             ),
             WrongVariableKind(s) => CalcResult::new_error(
                 Error::NAME,
                 cell,
-                format!("Variable name \"{}\" not found.", s),
+                format!("Variable name \"{s}\" not found."),
             ),
             CompareKind { kind, left, right } => {
                 let l = self.evaluate_node_in_context(left, cell);
@@ -525,9 +487,25 @@ impl Model {
             } => CalcResult::new_error(
                 Error::ERROR,
                 cell,
-                format!("Error parsing {}: {}", formula, message),
+                format!("Error parsing {formula}: {message}"),
             ),
             EmptyArgKind => CalcResult::EmptyArg,
+            ImplicitIntersection {
+                automatic: _,
+                child,
+            } => match self.evaluate_node_with_reference(child, cell) {
+                CalcResult::Range { left, right } => {
+                    match implicit_intersection(&cell, &Range { left, right }) {
+                        Some(cell_reference) => self.evaluate_cell(cell_reference),
+                        None => CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error with Implicit Intersection in cell {cell:?}"),
+                        ),
+                    }
+                }
+                _ => self.evaluate_node_in_context(child, cell),
+            },
         }
     }
 
@@ -617,12 +595,15 @@ impl Model {
                     };
                 }
                 CalcResult::Range { left, right } => {
-                    let range = Range {
-                        left: *left,
-                        right: *right,
-                    };
-                    if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
+                    if left.sheet == right.sheet
+                        && left.row == right.row
+                        && left.column == right.column
                     {
+                        let intersection_cell = CellReferenceIndex {
+                            sheet: left.sheet,
+                            column: left.column,
+                            row: left.row,
+                        };
                         let v = self.evaluate_cell(intersection_cell);
                         self.set_cell_value(cell_reference, &v);
                     } else {
@@ -639,10 +620,32 @@ impl Model {
                             f,
                             s,
                             o,
-                            m: "Invalid reference".to_string(),
-                            ei: Error::VALUE,
+                            m: "Implicit Intersection not implemented".to_string(),
+                            ei: Error::NIMPL,
                         };
                     }
+                    // if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
+                    // {
+                    //     let v = self.evaluate_cell(intersection_cell);
+                    //     self.set_cell_value(cell_reference, &v);
+                    // } else {
+                    //     let o = match self.cell_reference_to_string(&cell_reference) {
+                    //         Ok(s) => s,
+                    //         Err(_) => "".to_string(),
+                    //     };
+                    //     *self.workbook.worksheets[sheet as usize]
+                    //         .sheet_data
+                    //         .get_mut(&row)
+                    //         .expect("expected a row")
+                    //         .get_mut(&column)
+                    //         .expect("expected a column") = Cell::CellFormulaError {
+                    //         f,
+                    //         s,
+                    //         o,
+                    //         m: "Invalid reference".to_string(),
+                    //         ei: Error::VALUE,
+                    //     };
+                    // }
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {
                     *self.workbook.worksheets[sheet as usize]
@@ -652,6 +655,20 @@ impl Model {
                         .get_mut(&column)
                         .expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
                 }
+                CalcResult::Array(_) => {
+                    *self.workbook.worksheets[sheet as usize]
+                        .sheet_data
+                        .get_mut(&row)
+                        .expect("expected a row")
+                        .get_mut(&column)
+                        .expect("expected a column") = Cell::CellFormulaError {
+                        f,
+                        s,
+                        o: "".to_string(),
+                        m: "Arrays not supported yet".to_string(),
+                        ei: Error::NIMPL,
+                    };
+                }
             }
         }
     }
@@ -680,7 +697,7 @@ impl Model {
             worksheet.color = Some(color.to_string());
             return Ok(());
         }
-        Err(format!("Invalid color: {}", color))
+        Err(format!("Invalid color: {color}"))
     }
 
     /// Changes the visibility of a sheet
@@ -865,11 +882,7 @@ impl Model {
 
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
 
-        let defined_names = workbook
-            .get_defined_names_with_scope()
-            .iter()
-            .map(|s| (s.0.to_owned(), s.1))
-            .collect();
+        let defined_names = workbook.get_defined_names_with_scope();
         // add all tables
         // let mut tables = Vec::new();
         // for worksheet in worksheets {
@@ -1014,7 +1027,7 @@ impl Model {
         let source_sheet_name = self
             .workbook
             .worksheet(source.sheet)
-            .map_err(|e| format!("Could not find source worksheet: {}", e))?
+            .map_err(|e| format!("Could not find source worksheet: {e}"))?
             .get_name();
         if source.sheet != area.sheet {
             return Err("Source and area are in different sheets".to_string());
@@ -1028,7 +1041,7 @@ impl Model {
         let target_sheet_name = self
             .workbook
             .worksheet(target.sheet)
-            .map_err(|e| format!("Could not find target worksheet: {}", e))?
+            .map_err(|e| format!("Could not find target worksheet: {e}"))?
             .get_name();
         if let Some(formula) = value.strip_prefix('=') {
             let cell_reference = CellReferenceRC {
@@ -1048,7 +1061,7 @@ impl Model {
                     column_delta: target.column - source.column,
                 },
             );
-            Ok(format!("={}", formula_str))
+            Ok(format!("={formula_str}"))
         } else {
             Ok(value.to_string())
         }
@@ -1525,7 +1538,7 @@ impl Model {
         // If the formula fails to parse try adding a parenthesis
         // SUM(A1:A3  => SUM(A1:A3)
         if let Node::ParseErrorKind { .. } = parsed_formula {
-            let new_parsed_formula = self.parser.parse(&format!("{})", formula), &cell_reference);
+            let new_parsed_formula = self.parser.parse(&format!("{formula})"), &cell_reference);
             match new_parsed_formula {
                 Node::ParseErrorKind { .. } => {}
                 _ => parsed_formula = new_parsed_formula,
@@ -2055,21 +2068,7 @@ impl Model {
         scope: Option<u32>,
         formula: &str,
     ) -> Result<(), String> {
-        if !is_valid_identifier(name) {
-            return Err("Invalid defined name".to_string());
-        };
-        let name_upper = name.to_uppercase();
-        let defined_names = &self.workbook.defined_names;
-        let sheet_id = match scope {
-            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
-            None => None,
-        };
-        // if the defined name already exist return error
-        for df in defined_names {
-            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
-                return Err("Defined name already exists".to_string());
-            }
-        }
+        let sheet_id = self.is_valid_defined_name(name, scope, formula)?;
         self.workbook.defined_names.push(DefinedName {
             name: name.to_string(),
             formula: formula.to_string(),
@@ -2080,6 +2079,48 @@ impl Model {
         Ok(())
     }
 
+    /// Validates if a defined name can be created
+    pub fn is_valid_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<Option<u32>, String> {
+        if !is_valid_identifier(name) {
+            return Err("Name: Invalid defined name".to_string());
+        }
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => match self.workbook.worksheet(index) {
+                Ok(ws) => Some(ws.sheet_id),
+                Err(_) => return Err("Scope: Invalid sheet index".to_string()),
+            },
+            None => None,
+        };
+        // if the defined name already exist return error
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Err("Name: Defined name already exists".to_string());
+            }
+        }
+
+        // Make sure the formula is valid
+        match common::ParsedReference::parse_reference_formula(
+            None,
+            formula,
+            &self.locale,
+            |name| self.get_sheet_index_by_name(name),
+        ) {
+            Ok(_) => {}
+            Err(_) => {
+                return Err("Formula: Invalid defined name formula".to_string());
+            }
+        };
+
+        Ok(sheet_id)
+    }
+
     /// Delete defined name of name and scope
     pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
         let name_upper = name.to_uppercase();
@@ -2113,7 +2154,7 @@ impl Model {
         new_formula: &str,
     ) -> Result<(), String> {
         if !is_valid_identifier(new_name) {
-            return Err("Invalid defined name".to_string());
+            return Err("Name: Invalid defined name".to_string());
         };
         let name_upper = name.to_uppercase();
         let new_name_upper = new_name.to_uppercase();
@@ -2121,18 +2162,28 @@ impl Model {
         if name_upper != new_name_upper || scope != new_scope {
             for key in self.parsed_defined_names.keys() {
                 if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
-                    return Err("Defined name already exists".to_string());
+                    return Err("Name: Defined name already exists".to_string());
                 }
             }
         }
         let defined_names = &self.workbook.defined_names;
         let sheet_id = match scope {
-            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            Some(index) => Some(
+                self.workbook
+                    .worksheet(index)
+                    .map_err(|_| "Scope: Invalid sheet index")?
+                    .sheet_id,
+            ),
             None => None,
         };
 
         let new_sheet_id = match new_scope {
-            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            Some(index) => Some(
+                self.workbook
+                    .worksheet(index)
+                    .map_err(|_| "Scope: Invalid sheet index")?
+                    .sheet_id,
+            ),
             None => None,
         };
 

base/src/new_empty.rs

@@ -8,7 +8,7 @@ use crate::{
     expressions::{
         lexer::LexerMode,
         parser::{
-            stringify::{rename_sheet_in_node, to_rc_format},
+            stringify::{rename_sheet_in_node, to_rc_format, to_string},
             Parser,
         },
         types::CellReferenceRC,
@@ -17,7 +17,8 @@ use crate::{
     locale::get_locale,
     model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
     types::{
-        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
+        DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
+        WorksheetView,
     },
     utils::ParsedReference,
 };
@@ -144,12 +145,7 @@ impl Model {
 
     /// Reparses all formulas and defined names
     pub(crate) fn reset_parsed_structures(&mut self) {
-        let defined_names = self
-            .workbook
-            .get_defined_names_with_scope()
-            .iter()
-            .map(|s| (s.0.to_owned(), s.1))
-            .collect();
+        let defined_names = self.workbook.get_defined_names_with_scope();
         self.parser
             .set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
         self.parsed_formulas = vec![];
@@ -172,11 +168,11 @@ impl Model {
             .get_worksheet_names()
             .iter()
             .map(|s| s.to_uppercase())
-            .any(|x| x == format!("{}{}", base_name_uppercase, index))
+            .any(|x| x == format!("{base_name_uppercase}{index}"))
         {
             index += 1;
         }
-        let sheet_name = format!("{}{}", base_name, index);
+        let sheet_name = format!("{base_name}{index}");
         // Now we need a sheet_id
         let sheet_id = self.get_new_sheet_id();
         let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
@@ -196,7 +192,7 @@ impl Model {
         sheet_id: Option<u32>,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(sheet_name) {
-            return Err(format!("Invalid name for a sheet: '{}'", sheet_name));
+            return Err(format!("Invalid name for a sheet: '{sheet_name}'"));
         }
         if self
             .workbook
@@ -238,12 +234,12 @@ impl Model {
         if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) {
             return self.rename_sheet_by_index(sheet_index, new_name);
         }
-        Err(format!("Could not find sheet {}", old_name))
+        Err(format!("Could not find sheet {old_name}"))
     }
 
     /// Renames a sheet and updates all existing references to that sheet.
     /// It can fail if:
-    ///   * The original index is too large
+    ///   * The original index is out of bounds
     ///   * The target sheet name already exists
     ///   * The target sheet name is invalid
     pub fn rename_sheet_by_index(
@@ -252,22 +248,20 @@ impl Model {
         new_name: &str,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(new_name) {
-            return Err(format!("Invalid name for a sheet: '{}'.", new_name));
+            return Err(format!("Invalid name for a sheet: '{new_name}'."));
         }
         if self.get_sheet_index_by_name(new_name).is_some() {
-            return Err(format!("Sheet already exists: '{}'.", new_name));
-        }
-        let worksheets = &self.workbook.worksheets;
-        let sheet_count = worksheets.len() as u32;
-        if sheet_index >= sheet_count {
-            return Err("Sheet index out of bounds".to_string());
+            return Err(format!("Sheet already exists: '{new_name}'."));
         }
+        // Gets the new name and checks that a sheet with that index exists
+        let old_name = self.workbook.worksheet(sheet_index)?.get_name();
+
         // Parse all formulas with the old name
         // All internal formulas are R1C1
         self.parser.set_lexer_mode(LexerMode::R1C1);
-        // We use iter because the default would be a mut_iter and we don't need a mutable reference
-        let worksheets = &mut self.workbook.worksheets;
-        for worksheet in worksheets {
+
+        for worksheet in &mut self.workbook.worksheets {
+            // R1C1 formulas are not tied to a cell (but are tied to a cell)
             let cell_reference = &CellReferenceRC {
                 sheet: worksheet.get_name(),
                 row: 1,
@@ -281,11 +275,32 @@ impl Model {
             }
             worksheet.shared_formulas = formulas;
         }
-        // Se the mode back to A1
+
+        // Set the mode back to A1
         self.parser.set_lexer_mode(LexerMode::A1);
+
+        // We reparse all the defined names formulas
+        let mut defined_names = Vec::new();
+        // Defined names do not have a context, we can use anything
+        let cell_reference = &CellReferenceRC {
+            sheet: old_name.clone(),
+            row: 1,
+            column: 1,
+        };
+        for defined_name in &mut self.workbook.defined_names {
+            let mut t = self.parser.parse(&defined_name.formula, cell_reference);
+            rename_sheet_in_node(&mut t, sheet_index, new_name);
+            let formula = to_string(&t, cell_reference);
+            defined_names.push(DefinedName {
+                name: defined_name.name.clone(),
+                formula,
+                sheet_id: defined_name.sheet_id,
+            });
+        }
+        self.workbook.defined_names = defined_names;
+
         // Update the name of the worksheet
-        let worksheets = &mut self.workbook.worksheets;
-        worksheets[sheet_index as usize].set_name(new_name);
+        self.workbook.worksheet_mut(sheet_index)?.set_name(new_name);
         self.reset_parsed_structures();
         Ok(())
     }
@@ -347,14 +362,14 @@ impl Model {
         };
         let locale = match get_locale(locale_id) {
             Ok(l) => l.clone(),
-            Err(_) => return Err(format!("Invalid locale: {}", locale_id)),
+            Err(_) => return Err(format!("Invalid locale: {locale_id}")),
         };
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
         let dt = match DateTime::from_timestamp(seconds, 0) {
             Some(s) => s,
-            None => return Err(format!("Invalid timestamp: {}", milliseconds)),
+            None => return Err(format!("Invalid timestamp: {milliseconds}")),
         };
         // "2020-08-06T21:20:53Z
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();

base/src/number_format.rs

@@ -112,29 +112,36 @@ pub fn to_precision(value: f64, precision: usize) -> f64 {
 /// ```
 /// This intends to be equivalent to the js: `${parseFloat(value.toPrecision(precision)})`
 /// See ([ecma](https://tc39.es/ecma262/#sec-number.prototype.toprecision)).
-/// FIXME: There has to be a better algorithm :/
 pub fn to_excel_precision_str(value: f64) -> String {
     to_precision_str(value, 15)
 }
+
+pub fn to_excel_precision(value: f64, precision: usize) -> f64 {
+    if !value.is_finite() {
+        return value;
+    }
+
+    let s = format!("{:.*e}", precision.saturating_sub(1), value);
+    s.parse::<f64>().unwrap_or(value)
+}
+
 pub fn to_precision_str(value: f64, precision: usize) -> String {
-    if value.is_infinite() {
-        return "inf".to_string();
+    if !value.is_finite() {
+        if value.is_infinite() {
+            return "inf".to_string();
+        } else {
+            return "NaN".to_string();
+        }
     }
-    if value.is_nan() {
-        return "NaN".to_string();
-    }
-    let exponent = value.abs().log10().floor();
-    let base = value / 10.0_f64.powf(exponent);
-    let base = format!("{0:.1$}", base, precision - 1);
-    let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
-        // TODO: do this in a way that does not require a possible error
-        0.0
-    });
+
+    let s = format!("{:.*e}", precision.saturating_sub(1), value);
+    let parsed = s.parse::<f64>().unwrap_or(value);
+
     // I would love to use the std library. There is not a speed concern here
     // problem is it doesn't do the right thing
     // Also ryu is my favorite _modern_ algorithm
     let mut buffer = ryu::Buffer::new();
-    let text = buffer.format(value);
+    let text = buffer.format(parsed);
     // The above algorithm converts 2 to 2.0 regrettably
     if let Some(stripped) = text.strip_suffix(".0") {
         return stripped.to_string();

base/src/styles.rs

@@ -154,7 +154,7 @@ impl Styles {
                 return Ok(cell_style.xf_id);
             }
         }
-        Err(format!("Style '{}' not found", style_name))
+        Err(format!("Style '{style_name}' not found"))
     }
 
     pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {

base/src/test/engineering/test_complex.rs

@@ -133,6 +133,7 @@ fn fn_imcot() {
     );
 }
 
+#[cfg_attr(target_os = "windows", ignore)]
 #[test]
 fn fn_imtan() {
     let mut model = new_empty_model();

base/src/test/mod.rs

@@ -7,6 +7,9 @@ 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_average;
 mod test_fn_averageifs;
@@ -27,8 +30,8 @@ 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_forward_references;
 mod test_frozen_rows_columns;
 mod test_general;
 mod test_math;
@@ -44,24 +47,38 @@ 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;
 mod test_fn_offset;
 mod test_number_format;
 
+mod test_arrays;
 mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;
+mod test_fn_round;
 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_mod_quotient;
+mod test_networkdays;
+mod test_now;
 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_actions.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -508,6 +508,10 @@ fn test_move_column_right() {
     assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
     assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
     assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G1"), "1");
+    assert_eq!(model._get_text("H1"), "3");
 }
 
 #[test]
@@ -532,5 +536,249 @@ fn tets_move_column_error() {
     assert!(result.is_ok());
 }
 
+#[test]
+fn test_move_row_down() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Formulas referencing rows 3 and 4
+    model._set("E3", "=G3");
+    model._set("E4", "=G4");
+    model._set("E5", "=SUM(G3:J3)");
+    model._set("E6", "=SUM(G3:G3)");
+    model._set("E7", "=SUM(G4:G4)");
+    model.evaluate();
+
+    // Move row 3 down by one position
+    let result = model.move_row_action(0, 3, 1);
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=G3");
+    assert_eq!(model._get_formula("E4"), "=G4");
+    assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
+    assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
+    assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G4"), "-2");
+    assert_eq!(model._get_text("G3"), "");
+}
+
+#[test]
+fn test_move_row_up() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Formulas referencing rows 4 and 5
+    model._set("E4", "=G4");
+    model._set("E5", "=G5");
+    model._set("E6", "=SUM(G4:J4)");
+    model._set("E7", "=SUM(G4:G4)");
+    model._set("E8", "=SUM(G5:G5)");
+    model.evaluate();
+
+    // Move row 5 up by one position
+    let result = model.move_row_action(0, 5, -1);
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E4"), "=G4");
+    assert_eq!(model._get_formula("E5"), "=G5");
+    assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
+    assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
+    assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G4"), "");
+    assert_eq!(model._get_text("G5"), "");
+}
+
+#[test]
+fn test_move_row_error() {
+    let mut model = new_empty_model();
+    model.evaluate();
+
+    let result = model.move_row_action(0, 7, -10);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, -7, 20);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, LAST_ROW, 1);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, LAST_ROW + 1, -10);
+    assert!(result.is_err());
+
+    // This works
+    let result = model.move_row_action(0, LAST_ROW, -1);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_move_row_down_absolute_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Absolute references
+    model._set("E3", "=$G$3");
+    model._set("E4", "=$G$4");
+    model._set("E5", "=SUM($G$3:$J$3)");
+    model._set("E6", "=SUM($G$3:$G$3)");
+    model._set("E7", "=SUM($G$4:$G$4)");
+    model.evaluate();
+
+    assert!(model.move_row_action(0, 3, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$G$3");
+    assert_eq!(model._get_formula("E4"), "=$G$4");
+    assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
+    assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
+}
+
+#[test]
+fn test_move_column_right_absolute_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Absolute references
+    model._set("E3", "=$G$3");
+    model._set("E4", "=$H$3");
+    model._set("E5", "=SUM($G$3:$J$7)");
+    model._set("E6", "=SUM($G$3:$G$7)");
+    model._set("E7", "=SUM($H$3:$H$7)");
+    model.evaluate();
+
+    assert!(model.move_column_action(0, 7, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$H$3");
+    assert_eq!(model._get_formula("E4"), "=$G$3");
+    assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
+    assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
+}
+
+#[test]
+fn test_move_row_down_mixed_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    model._set("E3", "=$G3"); // absolute col, relative row
+    model._set("E4", "=$G4");
+    model._set("E5", "=SUM($G3:$J3)");
+    model._set("E6", "=SUM($G3:$G3)");
+    model._set("E7", "=SUM($G4:$G4)");
+    model._set("F3", "=H$3"); // relative col, absolute row
+    model._set("F4", "=G$3");
+    model.evaluate();
+
+    assert!(model.move_row_action(0, 3, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$G3");
+    assert_eq!(model._get_formula("E4"), "=$G4");
+    assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
+    assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
+    assert_eq!(model._get_formula("F3"), "=G$4");
+    assert_eq!(model._get_formula("F4"), "=H$4");
+}
+
+#[test]
+fn test_move_column_right_mixed_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    model._set("E3", "=$G3");
+    model._set("E4", "=$H3");
+    model._set("E5", "=SUM($G3:$J7)");
+    model._set("E6", "=SUM($G3:$G7)");
+    model._set("E7", "=SUM($H3:$H7)");
+    model._set("F3", "=H$3");
+    model._set("F4", "=H$3");
+    model.evaluate();
+
+    assert!(model.move_column_action(0, 7, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$H3");
+    assert_eq!(model._get_formula("E4"), "=$G3");
+    assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
+    assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
+    assert_eq!(model._get_formula("F3"), "=G$3");
+    assert_eq!(model._get_formula("F4"), "=G$3");
+}
+
+#[test]
+fn test_move_row_height() {
+    let mut model = new_empty_model();
+    let sheet = 0;
+    let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
+    // Set a custom height for row 3
+    model
+        .workbook
+        .worksheet_mut(sheet)
+        .unwrap()
+        .set_row_height(3, custom_height)
+        .unwrap();
+
+    // Record the original height of row 4 (should be the default)
+    let original_row4_height = model.get_row_height(sheet, 4).unwrap();
+
+    // Move row 3 down by one position
+    assert!(model.move_row_action(sheet, 3, 1).is_ok());
+
+    // The custom height should now be on row 4
+    assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
+
+    // Row 3 should now have the previous height of row 4
+    assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
+}
+
+/// Moving a row down by two positions should shift formulas on intermediate
+/// rows by only one (the row that gets skipped), not by the full delta ‒ this
+/// guards against the regression fixed in the RowMove displacement logic.
+#[test]
+fn test_row_move_down_two_updates_intermediate_refs_by_one() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Set up formulas to verify intermediate rows shift by 1 (not full delta).
+    model._set("E3", "=G3"); // target row
+    model._set("E4", "=G4"); // intermediate row
+    model._set("E5", "=SUM(G3:J3)");
+    model.evaluate();
+
+    // Move row 3 down by two positions (row 3 -> row 5)
+    assert!(model.move_row_action(0, 3, 2).is_ok());
+    model.evaluate();
+
+    // Assert that references for the moved row and intermediate row are correct.
+    assert_eq!(model._get_formula("E3"), "=G3");
+    assert_eq!(model._get_formula("E5"), "=G5");
+    assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
+}
+
+/// Moving a column right by two positions should shift formulas on
+/// intermediate columns by only one, ensuring the ColumnMove displacement
+/// logic handles multi-position moves correctly.
+#[test]
+fn test_column_move_right_two_updates_intermediate_refs_by_one() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Set up formulas to verify intermediate columns shift by 1 (not full delta).
+    model._set("E3", "=$G3"); // target column
+    model._set("E4", "=$H3"); // intermediate column
+    model._set("E5", "=SUM($G3:$J7)");
+    model.evaluate();
+
+    // Move column G (7) right by two positions (G -> I)
+    assert!(model.move_column_action(0, 7, 2).is_ok());
+    model.evaluate();
+
+    // Assert that references for moved and intermediate columns are correct.
+    assert_eq!(model._get_formula("E3"), "=$I3");
+    assert_eq!(model._get_formula("E4"), "=$G3");
+    assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
+}
+
 // A  B  C  D  E  F  G   H  I  J   K   L   M   N   O   P   Q   R
 // 1  2  3  4  5  6  7   8  9  10  11  12  13  14  15  16  17  18

base/src/test/test_arabic_roman

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=ARABIC()");
+    model._set("A2", "=ARABIC(V)");
+    model._set("A3", "=ARABIC(V, 2)");
+
+    model._set("A4", "=ROMAN()");
+    model._set("A5", "=ROMAN(5)");
+    model._set("A6", "=ROMAN(5, 0)");
+    model._set("A7", "=ROMAN(5, 0, 2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"5");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+    assert_eq!(model._get_text("A5"), *"V");
+    assert_eq!(model._get_text("A6"), *"V");
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+}

base/src/test/test_arrays.rs

@@ -0,0 +1,13 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn sum_arrays() {
+    let mut model = new_empty_model();
+    model._set("A1", "=SUM({1,2,3}+{3,4,5})");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"18");
+}

base/src/test/test_combin_combina

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=COMBIN(5,2)");
+    model._set("A2", "=COMBINA(5,2)");
+    model._set("A3", "=COMBIN()");
+    model._set("A4", "=COMBINA()");
+    model._set("A5", "=COMBIN(2)");
+    model._set("A6", "=COMBINA(2)");
+    model._set("A5", "=COMBIN(1, 2, 3)");
+    model._set("A6", "=COMBINA(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"10");
+    assert_eq!(model._get_text("A2"), *"15");
+    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!");
+    assert_eq!(model._get_text("A7"), *"#ERROR!");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+}

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,380 @@ 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("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("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_even_odd

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

base/src/test/test_exp_sign.rs

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

base/src/test/test_fn_concatenate.rs

@@ -22,13 +22,14 @@ fn fn_concatenate() {
     model._set("B1", r#"=CONCATENATE(A1, A2, A3, "!")"#);
     // This will break once we implement the implicit intersection operator
     // It should be:
-    // model._set("B2", r#"=CONCATENATE(@A1:A3, "!")"#);
+    model._set("C2", r#"=CONCATENATE(@A1:A3, "!")"#);
     model._set("B2", r#"=CONCATENATE(A1:A3, "!")"#);
     model._set("B3", r#"=CONCAT(A1:A3, "!")"#);
 
     model.evaluate();
 
     assert_eq!(model._get_text("B1"), *"Hello my World!");
-    assert_eq!(model._get_text("B2"), *" my !");
+    assert_eq!(model._get_text("B2"), *"#N/IMPL!");
     assert_eq!(model._get_text("B3"), *"Hello my World!");
+    assert_eq!(model._get_text("C2"), *" my !");
 }

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_datevalue_timevalue.rs

@@ -0,0 +1,24 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn datevalue_timevalue_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DATEVALUE()");
+    model._set("A2", "=TIMEVALUE()");
+    model._set("A3", "=DATEVALUE("2000-01-01")")
+    model._set("A4", "=TIMEVALUE("12:00:00")")
+    model._set("A5", "=DATEVALUE(1,2)");
+    model._set("A6", "=TIMEVALUE(1,2)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"36526");
+    assert_eq!(model._get_text("A4"), *"0.5");
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+}
+
+

base/src/test/test_fn_formulatext.rs

@@ -30,8 +30,18 @@ fn implicit_intersection() {
     model._set("A2", "=FORMULATEXT(D1:E1)");
     model.evaluate();
 
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A1"), *"#N/IMPL!");
+    assert_eq!(model._get_text("A2"), *"#N/IMPL!");
+}
+
+#[test]
+fn implicit_intersection_operator() {
+    let mut model = new_empty_model();
+    model._set("A1", "=1 +  2");
+    model._set("B1", "=FORMULATEXT(@A:A)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#N/IMPL!");
 }
 
 #[test]

base/src/test/test_fn_or_xor.rs

@@ -174,7 +174,7 @@ fn fn_or_xor_no_arguments() {
         println!("Testing function: {func}");
 
         let mut model = new_empty_model();
-        model._set("A1", &format!("={}()", func));
+        model._set("A1", &format!("={func}()"));
         model.evaluate();
         assert_eq!(model._get_text("A1"), *"#ERROR!");
     }

base/src/test/test_fn_round.rs

@@ -0,0 +1,15 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_round_approximation() {
+    let mut model = new_empty_model();
+    model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
+    model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"0.0063");
+    assert_eq!(model._get_text("A2"), *"0.00625");
+}

base/src/test/test_fn_sum.rs

@@ -17,3 +17,19 @@ fn test_fn_sum_arguments() {
     assert_eq!(model._get_text("A3"), *"1");
     assert_eq!(model._get_text("A4"), *"4");
 }
+
+#[test]
+fn arrays() {
+    let mut model = new_empty_model();
+    model._set("A1", "=SUM({1, 2, 3})");
+    model._set("A2", "=SUM({1; 2; 3})");
+    model._set("A3", "=SUM({1, 2; 3, 4})");
+    model._set("A4", "=SUM({1, 2; 3, 4; 5, 6})");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"6");
+    assert_eq!(model._get_text("A2"), *"6");
+    assert_eq!(model._get_text("A3"), *"10");
+    assert_eq!(model._get_text("A4"), *"21");
+}

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_forward_references.rs

@@ -1,121 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::expressions::types::{Area, CellReferenceIndex};
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_forward_references() {
-    let mut model = new_empty_model();
-
-    // test single ref changed nd not changed
-    model._set("H8", "=F6*G9");
-    // tests areas
-    model._set("H9", "=SUM(D4:F6)");
-    // absolute coordinates
-    model._set("H10", "=$F$6");
-    // area larger than the source area
-    model._set("H11", "=SUM(D3:F6)");
-    // Test arguments and concat
-    model._set("H12", "=SUM(F6, D4:F6) & D4");
-    // Test range operator. This is syntax error for now.
-    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
-    // Test operations
-    model._set("H14", "=-D4+D5*F6/F5");
-
-    model.evaluate();
-
-    // Source Area is D4:F6
-    let source_area = &Area {
-        sheet: 0,
-        row: 4,
-        column: 4,
-        width: 3,
-        height: 3,
-    };
-
-    // We paste in B10
-    let target_row = 10;
-    let target_column = 2;
-    let result = model.forward_references(
-        source_area,
-        &CellReferenceIndex {
-            sheet: 0,
-            row: target_row,
-            column: target_column,
-        },
-    );
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("H8"), "=D12*G9");
-    assert_eq!(model._get_formula("H9"), "=SUM(B10:D12)");
-    assert_eq!(model._get_formula("H10"), "=$D$12");
-
-    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
-    assert_eq!(model._get_formula("H12"), "=SUM(D12,B10:D12)&B10");
-    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
-    assert_eq!(model._get_formula("H14"), "=-B10+B11*D12/D11");
-}
-
-#[test]
-fn test_different_sheet() {
-    let mut model = new_empty_model();
-
-    // test single ref changed not changed
-    model._set("H8", "=F6*G9");
-    // tests areas
-    model._set("H9", "=SUM(D4:F6)");
-    // absolute coordinates
-    model._set("H10", "=$F$6");
-    // area larger than the source area
-    model._set("H11", "=SUM(D3:F6)");
-    // Test arguments and concat
-    model._set("H12", "=SUM(F6, D4:F6) & D4");
-    // Test range operator. This is syntax error for now.
-    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
-    // Test operations
-    model._set("H14", "=-D4+D5*F6/F5");
-
-    // Adds a new sheet
-    assert!(model.add_sheet("Sheet2").is_ok());
-
-    model.evaluate();
-
-    // Source Area is D4:F6
-    let source_area = &Area {
-        sheet: 0,
-        row: 4,
-        column: 4,
-        width: 3,
-        height: 3,
-    };
-
-    // We paste in Sheet2!B10
-    let target_row = 10;
-    let target_column = 2;
-    let result = model.forward_references(
-        source_area,
-        &CellReferenceIndex {
-            sheet: 1,
-            row: target_row,
-            column: target_column,
-        },
-    );
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("H8"), "=Sheet2!D12*G9");
-    assert_eq!(model._get_formula("H9"), "=SUM(Sheet2!B10:D12)");
-    assert_eq!(model._get_formula("H10"), "=Sheet2!$D$12");
-
-    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
-    assert_eq!(
-        model._get_formula("H12"),
-        "=SUM(Sheet2!D12,Sheet2!B10:D12)&Sheet2!B10"
-    );
-    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
-    assert_eq!(
-        model._get_formula("H14"),
-        "=-Sheet2!B10+Sheet2!B11*Sheet2!D12/Sheet2!D11"
-    );
-}

base/src/test/test_implicit_intersection.rs

@@ -0,0 +1,50 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_colum() {
+    let mut model = new_empty_model();
+    // We populate cells A1 to A3
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("A3", "3");
+
+    model._set("C2", "=@A1:A3");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("C2"), "2".to_string());
+}
+
+#[test]
+fn return_of_array_is_n_impl() {
+    let mut model = new_empty_model();
+    // We populate cells A1 to A3
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("A3", "3");
+
+    model._set("C2", "=A1:A3");
+    model._set("D2", "=SUM(SIN(A:A)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("C2"), "#N/IMPL!".to_string());
+    assert_eq!(model._get_text("D2"), "1.89188842".to_string());
+}
+
+#[test]
+fn concat() {
+    let mut model = new_empty_model();
+    model._set("A1", "=CONCAT(@B1:B3)");
+    model._set("A2", "=CONCAT(B1:B3)");
+    model._set("B1", "Hello");
+    model._set("B2", " ");
+    model._set("B3", "world!");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"Hello");
+    assert_eq!(model._get_text("A2"), *"Hello world!");
+}

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_ln.rs

@@ -0,0 +1,17 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LN(100)");
+    model._set("A2", "=LN()");
+    model._set("A3", "=LN(100, 10)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"4.605170186");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+}

base/src/test/test_log.rs

@@ -0,0 +1,19 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LOG(100)");
+    model._set("A2", "=LOG()");
+    model._set("A3", "=LOG(10000, 10)");
+    model._set("A4", "=LOG(100, 10, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"2");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"4");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+}

base/src/test/test_log10.rs

@@ -0,0 +1,35 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LOG10(100)");
+    model._set("A2", "=LOG10()");
+    model._set("A3", "=LOG10(100, 10)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"2");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+}
+
+#[test]
+fn cell_and_function() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LOG10");
+
+    model.evaluate();
+
+    // This is the cell LOG10
+    assert_eq!(model._get_text("A1"), *"0");
+
+    model._set("LOG10", "1000");
+    model._set("A2", "=LOG10(LOG10)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1000");
+    assert_eq!(model._get_text("A2"), *"3");
+}

base/src/test/test_mod_quotient.rs

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

base/src/test/test_mround_trunc_int

@@ -0,0 +1,40 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=MROUND()");
+    model._set("A2", "=MROUND(10)");
+    model._set("A3", "=MROUND(10, 3)");
+    model._set("A4", "=MROUND(10, 3, 1)");
+
+    model._set("A5", "=TRUNC()");
+    model._set("A6", "=TRUNC(10)");
+    model._set("A7", "=TRUNC(10.22, 1)");
+    model._set("A8", "=TRUNC(10, 3, 1)");
+
+    model._set("A9", "=INT()");
+    model._set("A10", "=INT(10.22)");
+    model._set("A11", "=INT(10.22, 1)");
+    model._set("A12", "=INT(10.22, 1, 2)");
+
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"9");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A5"), *"#ERROR!");
+    assert_eq!(model._get_text("A6"), *"#ERROR!");
+    assert_eq!(model._get_text("A7"), *"10.2");
+    assert_eq!(model._get_text("A8"), *"#ERROR!");
+
+    assert_eq!(model._get_text("A9"), *"#ERROR!");
+    assert_eq!(model._get_text("A10"), *"10");
+    assert_eq!(model._get_text("A11"), *"#ERROR!");
+    assert_eq!(model._get_text("A12"), *"#ERROR!");
+}