BOB

.github/workflows/npm.yml

@@ -1,446 +0,0 @@
-name: nodejs
-env:
-  DEBUG: napi:*
-  APP_NAME: nodejs
-  MACOSX_DEPLOYMENT_TARGET: '10.13'
-permissions:
-  contents: write
-  id-token: write
-'on':
-  workflow_dispatch:
-    inputs:
-      publish:
-        description: "Publish to npm"
-        required: true
-        type: boolean
-defaults:
-  run:
-    working-directory: ./bindings/nodejs
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-            build: yarn build --target x86_64-apple-darwin
-          - host: windows-latest
-            build: yarn build --target x86_64-pc-windows-msvc
-            target: x86_64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-            build: yarn build --target x86_64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: yarn build --target x86_64-unknown-linux-musl
-          - host: macos-latest
-            target: aarch64-apple-darwin
-            build: yarn build --target aarch64-apple-darwin
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
-            build: yarn build --target aarch64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: armv7-unknown-linux-gnueabihf
-            setup: |
-              sudo apt-get update
-              sudo apt-get install gcc-arm-linux-gnueabihf -y
-            build: yarn build --target armv7-unknown-linux-gnueabihf
-          - host: ubuntu-latest
-            target: armv7-unknown-linux-musleabihf
-            build: yarn build --target armv7-unknown-linux-musleabihf
-          - host: ubuntu-latest
-            target: aarch64-linux-android
-            build: yarn build --target aarch64-linux-android
-          - host: ubuntu-latest
-            target: armv7-linux-androideabi
-            build: yarn build --target armv7-linux-androideabi
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |-
-              set -e &&
-              rustup target add aarch64-unknown-linux-musl &&
-              yarn build --target aarch64-unknown-linux-musl
-          - host: windows-latest
-            target: aarch64-pc-windows-msvc
-            build: yarn build --target aarch64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: riscv64gc-unknown-linux-gnu
-            setup: |
-              sudo apt-get update
-              sudo apt-get install gcc-riscv64-linux-gnu -y
-            build: yarn build --target riscv64gc-unknown-linux-gnu
-    name: stable - ${{ matrix.settings.target }} - node@20
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        if: ${{ !matrix.settings.docker }}
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install
-        uses: dtolnay/rust-toolchain@stable
-        if: ${{ !matrix.settings.docker }}
-        with:
-          toolchain: stable
-          targets: ${{ matrix.settings.target }}
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            .cargo-cache
-            target/
-          key: ${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
-      - uses: goto-bus-stop/setup-zig@v2
-        if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' || matrix.settings.target == 'armv7-unknown-linux-musleabihf' }}
-        with:
-          version: 0.13.0
-      - name: Setup toolchain
-        run: ${{ matrix.settings.setup }}
-        if: ${{ matrix.settings.setup }}
-        shell: bash
-      - name: Install dependencies
-        run: yarn install
-      - name: Build in docker
-        uses: addnab/docker-run-action@v3
-        if: ${{ matrix.settings.docker }}
-        with:
-          image: ${{ matrix.settings.docker }}
-          options: '--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: ${{ matrix.settings.build }}
-      - name: Build
-        run: ${{ matrix.settings.build }}
-        if: ${{ !matrix.settings.docker }}
-        shell: bash
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  test-macOS-windows-binding:
-    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-          - host: windows-latest
-            target: x86_64-pc-windows-msvc
-        node:
-          - '18'
-          - '20'
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-          architecture: x64
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: yarn test
-  test-linux-x64-gnu-binding:
-    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-slim yarn test
-  test-linux-x64-musl-binding:
-    name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-alpine yarn test
-  test-linux-aarch64-gnu-binding:
-    name: Test bindings on aarch64-unknown-linux-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "glibc"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:${{ matrix.node }}-slim
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-            ls -la
-  test-linux-aarch64-musl-binding:
-    name: Test bindings on aarch64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts-alpine
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-  test-linux-arm-gnueabihf-binding:
-    name: Test bindings on armv7-unknown-linux-gnueabihf - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-armv7-unknown-linux-gnueabihf
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:${{ matrix.node }}-bullseye-slim
-          options: '--platform linux/arm/v7 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-            ls -la
-  universal-macOS:
-    name: Build universal macOS binary
-    needs:
-      - build
-    runs-on: macos-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download macOS x64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Download macOS arm64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Combine binaries
-        run: yarn universal
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-universal-apple-darwin
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  publish:
-    name: Publish
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    needs:
-      - test-macOS-windows-binding
-      - test-linux-x64-gnu-binding
-      - test-linux-x64-musl-binding
-      - test-linux-aarch64-gnu-binding
-      - test-linux-aarch64-musl-binding
-      - test-linux-arm-gnueabihf-binding
-      - universal-macOS
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: bindings/nodejs/artifacts
-      - name: Move artifacts
-        run: yarn artifacts
-      - name: List packages
-        run: ls -R ./npm
-        shell: bash
-      - name: Publish
-        run: |
-          echo "${{ github.event.inputs.publish }}"
-          if [ "${{ github.event.inputs.publish }}" = "true" ]; then
-            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
-            npm publish --access public
-            echo "Published to npm"
-          else
-            echo "Not a release, skipping publish"
-          fi
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/pypi.yml

@@ -1,141 +0,0 @@
-name: Upload component to Python Package Index
-
-on:
-  workflow_dispatch:
-    inputs:
-      release:
-        type: boolean
-        default: false
-        required: false
-        description: "Release? If false, publish to test.pypi.org, if true, publish to pypi.org"
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          manylinux: auto
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  windows:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        target: [x64, x86]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-          architecture: ${{ matrix.target }}
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  macos:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        target: [x86_64, aarch64]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-${{ matrix.target }}
-          path: bindings/python/dist
-
-  sdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-          working-directory: bindings/python
-      - name: Upload sdist
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ runner.os }}-sdist
-          path: bindings/python/dist
-
-  publish-to-test-pypi:
-    if: ${{ github.event.inputs.release != 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to Test PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: bindings/python/
-      - name: Publish distribution 📦 to Test PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_TEST_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
-        with:
-          command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
-          working-directory: bindings/python
-
-  publish-pypi:
-    if: ${{ github.event.inputs.release == 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: bindings/python/
-      - name: Publish distribution 📦 to PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
-        with:
-          command: upload
-          args: "--skip-existing **/*.whl **/*.tar.gz"
-          working-directory: bindings/python

.github/workflows/test-coverage.yaml

@@ -17,9 +17,8 @@ jobs:
       - name: Generate code coverage
         run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        uses: codecov/codecov-action@v3
         with:
+          token: ${{ secrets.CODECOV_TOKEN }}
           files: lcov.info
           fail_ci_if_error: true

.gitignore

@@ -1,3 +1,2 @@
 target/*
-**/node_modules/**
-.DS_Store
+.DS_Store

CHANGELOG.md

@@ -7,21 +7,12 @@
 - New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
 - New document server (Thanks Dani!)
 - New function FORMULATEXT
-- Name Manager ([#212](https://github.com/ironcalc/IronCalc/pull/212) [#220](https://github.com/ironcalc/IronCalc/pull/220))
-- Add context menu. We can now insert rows and columns. Freeze and unfreeze rows and columns. Delete rows and columns [#271]
-- Add nodejs bindings [#254]
-- Add python bindings for all platforms
-- Add is split into the product and widget
-- Add Python documentation [#260]
 
 ### Fixed
 
 - Fixed several issues with pasting content
 - Fixed several issues with borders
 - Fixed bug where columns and rows could be resized to negative width and height, respectively
-- Undo/redo when add/delete sheet now works [#270]
-- Numerous small fixes
-- Multiple fixes to the documentation
 
 ## [0.2.0] - 2024-11-06 (The HN release)
 

Cargo.lock

@@ -43,15 +43,6 @@ 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"
@@ -94,12 +85,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "bitflags"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -225,15 +210,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
-[[package]]
-name = "convert_case"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.6"
@@ -295,16 +271,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ctor"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
-dependencies = [
- "quote",
- "syn",
-]
-
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -423,7 +389,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.6.0"
+version = "0.2.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -439,31 +405,20 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.2.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.6.0"
-dependencies = [
- "ironcalc",
- "napi",
- "napi-build",
- "napi-derive",
- "serde",
 ]
 
 [[package]]
@@ -505,16 +460,6 @@ version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
-[[package]]
-name = "libloading"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
-dependencies = [
- "cfg-if",
- "windows-targets",
-]
-
 [[package]]
 name = "log"
 version = "0.4.21"
@@ -545,65 +490,6 @@ dependencies = [
  "adler",
 ]
 
-[[package]]
-name = "napi"
-version = "2.16.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
-dependencies = [
- "bitflags",
- "ctor",
- "napi-derive",
- "napi-sys",
- "once_cell",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "napi-build"
-version = "2.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
-
-[[package]]
-name = "napi-derive"
-version = "2.16.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
-dependencies = [
- "cfg-if",
- "convert_case",
- "napi-derive-backend",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "napi-derive-backend"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
-dependencies = [
- "convert_case",
- "once_cell",
- "proc-macro2",
- "quote",
- "regex",
- "semver",
- "syn",
-]
-
-[[package]]
-name = "napi-sys"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
-dependencies = [
- "libloading",
-]
-
 [[package]]
 name = "num-conv"
 version = "0.1.0"
@@ -730,10 +616,11 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
 dependencies = [
+ "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -747,9 +634,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -757,9 +644,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -767,9 +654,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -779,9 +666,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.0"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -792,9 +679,8 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.6.0"
+version = "0.1.2"
 dependencies = [
- "bitcode",
  "ironcalc",
  "pyo3",
  "serde",
@@ -881,12 +767,6 @@ 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"
@@ -899,12 +779,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
-[[package]]
-name = "semver"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
-
 [[package]]
 name = "serde"
 version = "1.0.197"
@@ -975,16 +849,6 @@ 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"
@@ -1004,9 +868,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.2"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "thiserror"
@@ -1059,12 +923,6 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
 [[package]]
 name = "unindent"
 version = "0.2.3"
@@ -1095,7 +953,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.6.0"
+version = "0.1.3"
 dependencies = [
  "ironcalc_base",
  "serde",
@@ -1106,24 +964,23 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
  "cfg-if",
- "once_cell",
- "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
  "bumpalo",
  "log",
+ "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -1144,9 +1001,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1154,9 +1011,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1167,12 +1024,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
-dependencies = [
- "unicode-ident",
-]
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
 name = "wasm-bindgen-test"

Cargo.toml

@@ -6,12 +6,10 @@ members = [
   "xlsx",
   "bindings/wasm",
   "bindings/python",
-  "bindings/nodejs",
 ]
 
 exclude = [
   "generate_locale",
-  "webapp/app.ironcalc.com/server",
 ]
 
 [profile.release]

Dockerfile

@@ -1,93 +0,0 @@
-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
-

Makefile

@@ -2,8 +2,7 @@
 lint:
 	cargo fmt -- --check
 	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
-	cd webapp/IronCalc/ && npm install && npm run check
-	cd webapp/app.ironcalc.com/frontend/ && npm install && npm run check
+	cd webapp && npm install && npm run check
 
 .PHONY: format
 format:
@@ -16,7 +15,7 @@ tests: lint
 	# Regretabbly we need to build the wasm twice, once for the nodejs tests
 	# and a second one for the vitest.
 	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
-	cd webapp/IronCalc/ && npm run test
+	cd webapp && npm run test
 	cd bindings/python && ./run_tests.sh && ./run_examples.sh
 
 .PHONY: remove-artifacts

README.md

@@ -31,17 +31,7 @@ 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 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.
+We will build different _skins_: in the terminal, as a desktop application or use it in you own web application.
 
 # Building
 
@@ -87,14 +77,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.5"}
+ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
 ```
 
 And then use this code in `main.rs`:
 
 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, Model},
+    base::{expressions::utils::number_to_column, model::Model},
     export::save_to_xlsx,
 };
 

base/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
 repository = "https://github.com/ironcalc/ironcalc/"
-description = "Open source spreadsheet engine"
+description = "The democratization of spreadsheets"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -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,6 +1,5 @@
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
-use crate::expressions::types::CellReferenceRC;
+use crate::expressions::parser::stringify::DisplaceData;
 use crate::model::Model;
 
 // NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
@@ -9,45 +8,16 @@ 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) -> Result<(), String> {
+    fn displace_cells(&mut self, displace_data: &DisplaceData) {
         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.
@@ -164,34 +134,7 @@ impl Model {
                 column,
                 delta: column_count,
             }),
-        )?;
-
-        // In the list of columns:
-        // * Keep all the columns to the left
-        // * Displace all the columns to the right
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-
-        let mut new_columns = Vec::new();
-        for col in worksheet.cols.iter_mut() {
-            // range under study
-            let min = col.min;
-            let max = col.max;
-            if column > max {
-                // If the range under study is to our left, this is a noop
-            } else if column <= min {
-                // If the range under study is to our right, we displace it
-                col.min = min + column_count;
-                col.max = max + column_count;
-            } else {
-                // If the range under study is in the middle we augment it
-                col.max = max + column_count;
-            }
-            new_columns.push(col.clone());
-        }
-        // TODO: If in a row the cell to the right and left have the same style we should copy it
-
-        worksheet.cols = new_columns;
+        );
 
         Ok(())
     }
@@ -212,12 +155,6 @@ 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;
@@ -250,7 +187,7 @@ impl Model {
                 column,
                 delta: -column_count,
             }),
-        )?;
+        );
         let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
 
         // deletes all the column styles
@@ -374,7 +311,7 @@ impl Model {
                 row,
                 delta: row_count,
             }),
-        )?;
+        );
 
         Ok(())
     }
@@ -390,13 +327,6 @@ 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();
@@ -442,7 +372,7 @@ impl Model {
                 row,
                 delta: -row_count,
             }),
-        )?;
+        );
         Ok(())
     }
 
@@ -457,86 +387,23 @@ 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 moves the data and column styles along with the formulas
+    ///      NOTE: This does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,
         column: i32,
         delta: i32,
-    ) -> Result<(), String> {
+    ) -> Result<(), &'static str> {
         // Check boundaries
         let target_column = column + delta;
         if !(1..=LAST_COLUMN).contains(&target_column) {
-            return Err("Target column out of boundaries".to_string());
+            return Err("Target column out of boundaries");
         }
         if !(1..=LAST_COLUMN).contains(&column) {
-            return Err("Initial column out of boundaries".to_string());
+            return Err("Initial column out of boundaries");
         }
 
-        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)?;
+        // TODO: Add the actual displacement of data and styles
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -545,91 +412,7 @@ 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

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

base/src/cast.rs

@@ -1,103 +1,11 @@
 use crate::{
     calc_result::{CalcResult, Range},
-    expressions::{
-        parser::{ArrayNode, Node},
-        token::Error,
-        types::CellReferenceIndex,
-    },
-    formatter::format::parse_formatted_number,
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
+    implicit_intersection::implicit_intersection,
     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,
@@ -107,16 +15,16 @@ impl Model {
         self.cast_to_number(result, cell)
     }
 
-    pub(crate) fn cast_to_number(
+    fn cast_to_number(
         &mut self,
         result: CalcResult,
         cell: CellReferenceIndex,
     ) -> Result<f64, CalcResult> {
         match result {
             CalcResult::Number(f) => Ok(f),
-            CalcResult::String(s) => match self.cast_number(&s) {
-                Some(f) => Ok(f),
-                None => Err(CalcResult::new_error(
+            CalcResult::String(s) => match s.parse::<f64>() {
+                Ok(f) => Ok(f),
+                _ => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),
@@ -131,16 +39,19 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
             error @ CalcResult::Error { .. } => Err(error),
-            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(),
-            }),
+            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(),
+                    }),
+                }
+            }
         }
     }
 
@@ -177,7 +88,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 {
@@ -188,16 +99,19 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
             error @ CalcResult::Error { .. } => Err(error),
-            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(),
-            }),
+            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(),
+                    }),
+                }
+            }
         }
     }
 
@@ -237,16 +151,19 @@ impl Model {
             CalcResult::Boolean(b) => Ok(b),
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
             error @ CalcResult::Error { .. } => Err(error),
-            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(),
-            }),
+            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(),
+                    }),
+                }
+            }
         }
     }
 

base/src/constants.rs

@@ -12,17 +12,7 @@ pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
 pub(crate) const LAST_COLUMN: i32 = 16_384;
 pub(crate) const LAST_ROW: i32 = 1_048_576;
 
-// Excel uses 15 significant digits of precision for all numeric calculations.
-pub(crate) const EXCEL_PRECISION: usize = 15;
-
 // 693_594 is computed as:
 // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
 // The 2 days offset is because of Excel 1900 bug
 pub(crate) const EXCEL_DATE_BASE: i32 = 693_594;
-
-// We do not support dates before 1899-12-31.
-pub(crate) const MINIMUM_DATE_SERIAL_NUMBER: i32 = 1;
-
-// Excel can handle dates until the year 9999-12-31
-// 2958465 is the number of days from 1900-01-01 to 9999-12-31
-pub(crate) const MAXIMUM_DATE_SERIAL_NUMBER: i32 = 2_958_465;

base/src/diffs.rs

@@ -0,0 +1,138 @@
+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,7 +187,6 @@ impl Lexer {
                     ']' => TokenType::RightBracket,
                     ':' => TokenType::Colon,
                     ';' => TokenType::Semicolon,
-                    '@' => TokenType::At,
                     ',' => {
                         if self.locale.numbers.symbols.decimal == "," {
                             match self.consume_number(',') {
@@ -314,9 +313,6 @@ 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()
@@ -514,7 +510,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),
         })
     }
 
@@ -575,7 +571,9 @@ 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,16 +148,15 @@ 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]".len();
+                self.position += "#This Row]".bytes().len();
                 TableSpecifier::ThisRow
             } else if rest_of_formula.starts_with("#All]") {
-                self.position += "#All]".len();
+                self.position += "#All]".bytes().len();
                 TableSpecifier::All
             } else if rest_of_formula.starts_with("#Data]") {
-                self.position += "#Data]".len();
+                self.position += "#Data]".bytes().len();
                 TableSpecifier::Data
             } else if rest_of_formula.starts_with("#Headers]") {
-                self.position += "#Headers]".len();
+                self.position += "#Headers]".bytes().len();
                 TableSpecifier::Headers
             } else if rest_of_formula.starts_with("#Totals]") {
-                self.position += "#Totals]".len();
+                self.position += "#Totals]".bytes().len();
                 TableSpecifier::Totals
             } else {
                 return Err(LexerError {

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

@@ -1,5 +1,4 @@
 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,6 +1,5 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -686,29 +685,3 @@ 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

@@ -1,25 +0,0 @@
-#![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 @@
 /*!
-# GRAMMAR
+# GRAMAR
 
 <pre class="rust">
 opComp   => '=' | '<' | '>' | '<=' } '>=' | '<>'
@@ -12,8 +12,7 @@ term    => factor (opFactor factor)*
 factor  => prod (opProd prod)*
 prod    => power ('^' power)*
 power   => (unaryOp)* range '%'*
-range   => implicit (':' primary)?
-implicit=> '@' primary | primary
+range   => primary (':' primary)?
 primary => '(' expr ')'
         => number
         => function '(' f_args ')'
@@ -46,8 +45,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;
@@ -82,9 +81,6 @@ 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,
@@ -94,14 +90,6 @@ 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),
@@ -175,14 +163,8 @@ pub enum Node {
         name: String,
         args: Vec<Node>,
     },
-    ArrayKind(Vec<Vec<ArrayNode>>),
-    DefinedNameKind(DefinedNameS),
-    TableNameKind(String),
-    WrongVariableKind(String),
-    ImplicitIntersection {
-        automatic: bool,
-        child: Box<Node>,
-    },
+    ArrayKind(Vec<Node>),
+    VariableKind(String),
     CompareKind {
         kind: OpCompare,
         left: Box<Node>,
@@ -205,17 +187,12 @@ pub enum Node {
 pub struct Parser {
     lexer: lexer::Lexer,
     worksheets: Vec<String>,
-    defined_names: Vec<DefinedNameS>,
-    context: CellReferenceRC,
+    context: Option<CellReferenceRC>,
     tables: HashMap<String, Table>,
 }
 
 impl Parser {
-    pub fn new(
-        worksheets: Vec<String>,
-        defined_names: Vec<DefinedNameS>,
-        tables: HashMap<String, Table>,
-    ) -> Parser {
+    pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
         let lexer = lexer::Lexer::new(
             "",
             lexer::LexerMode::A1,
@@ -224,16 +201,10 @@ impl Parser {
             #[allow(clippy::expect_used)]
             get_language("en").expect(""),
         );
-        let context = CellReferenceRC {
-            sheet: worksheets.first().map_or("", |v| v).to_string(),
-            column: 1,
-            row: 1,
-        };
         Parser {
             lexer,
             worksheets,
-            defined_names,
-            context,
+            context: None,
             tables,
         }
     }
@@ -241,18 +212,13 @@ impl Parser {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_worksheets_and_names(
-        &mut self,
-        worksheets: Vec<String>,
-        defined_names: Vec<DefinedNameS>,
-    ) {
+    pub fn set_worksheets(&mut self, worksheets: Vec<String>) {
         self.worksheets = worksheets;
-        self.defined_names = defined_names;
     }
 
-    pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
+    pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
         self.lexer.set_formula(formula);
-        self.context = context.clone();
+        self.context.clone_from(context);
         self.parse_expr()
     }
 
@@ -266,24 +232,6 @@ impl Parser {
         None
     }
 
-    // Returns:
-    //  * None: If there is no defined name by that name
-    //  * 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>, 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, df_formula.to_owned()));
-            }
-        }
-        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, df_formula.to_owned()));
-            }
-        }
-        None
-    }
-
     fn parse_expr(&mut self) -> Node {
         let mut t = self.parse_concat();
         if let Node::ParseErrorKind { .. } = t {
@@ -427,7 +375,7 @@ impl Parser {
     }
 
     fn parse_range(&mut self) -> Node {
-        let t = self.parse_implicit();
+        let t = self.parse_primary();
         if let Node::ParseErrorKind { .. } = t {
             return t;
         }
@@ -446,93 +394,6 @@ 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),
-            Node::UnaryKind {
-                kind: OpUnary::Minus,
-                right,
-            } => {
-                if let Node::NumberKind(n) = *right {
-                    ArrayNode::Number(-n)
-                } else {
-                    return Err(Node::ParseErrorKind {
-                        formula: self.lexer.get_formula(),
-                        message: "Invalid value in array".to_string(),
-                        position: self.lexer.get_position() as usize,
-                    });
-                }
-            }
-            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),
-                Node::UnaryKind {
-                    kind: OpUnary::Minus,
-                    right,
-                } => {
-                    if let Node::NumberKind(n) = *right {
-                        ArrayNode::Number(-n)
-                    } else {
-                        return Err(Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            message: "Invalid value in array".to_string(),
-                            position: self.lexer.get_position() as usize,
-                        });
-                    }
-                }
-                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 {
@@ -554,35 +415,21 @@ impl Parser {
             TokenType::Number(s) => Node::NumberKind(s),
             TokenType::String(s) => Node::StringKind(s),
             TokenType::LeftBrace => {
-                // 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 t = self.parse_expr();
+                if let Node::ParseErrorKind { .. } = t {
+                    return t;
+                }
                 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 row = match self.parse_array_row() {
-                        Ok(s) => s,
-                        Err(error) => return error,
-                    };
-                    next_token = self.lexer.peek_token();
-                    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(),
-                        };
+                    let p = self.parse_expr();
+                    if let Node::ParseErrorKind { .. } = p {
+                        return p;
                     }
-                    matrix.push(row);
+                    next_token = self.lexer.peek_token();
+                    args.push(p);
                 }
-
                 if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
                     return Node::ParseErrorKind {
                         formula: self.lexer.get_formula(),
@@ -590,7 +437,7 @@ impl Parser {
                         message: err.message,
                     };
                 }
-                Node::ArrayKind(matrix)
+                Node::ArrayKind(args)
             }
             TokenType::Reference {
                 sheet,
@@ -599,7 +446,16 @@ impl Parser {
                 absolute_column,
                 absolute_row,
             } => {
-                let context = &self.context;
+                let context = match &self.context {
+                    Some(c) => c,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: self.lexer.get_position() as usize,
+                            message: "Expected context for the reference".to_string(),
+                        }
+                    }
+                };
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -634,7 +490,16 @@ impl Parser {
                 }
             }
             TokenType::Range { sheet, left, right } => {
-                let context = &self.context;
+                let context = match &self.context {
+                    Some(c) => c,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: self.lexer.get_position() as usize,
+                            message: "Expected context for the reference".to_string(),
+                        }
+                    }
+                };
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -720,47 +585,11 @@ impl Parser {
                             kind: function_kind,
                             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;
-
-                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
-                    Some(i) => i,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
-                        };
-                    }
-                };
-
-                // Could be a defined name or a table
-                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() {
-                    if table_name.to_lowercase() == name_lower {
-                        return Node::TableNameKind(name);
+                    } else {
+                        return Node::InvalidFunctionKind { name, args };
                     }
                 }
-                Node::WrongVariableKind(name)
+                Node::VariableKind(name)
             }
             TokenType::Error(kind) => Node::ErrorKind(kind),
             TokenType::Illegal(error) => Node::ParseErrorKind {
@@ -773,38 +602,7 @@ impl Parser {
                 position: 0,
                 message: "Unexpected end of input.".to_string(),
             },
-            TokenType::Boolean(value) => {
-                // Could be a function call "TRUE()"
-                let next_token = self.lexer.peek_token();
-                if next_token == TokenType::LeftParenthesis {
-                    self.lexer.advance_token();
-                    // We parse all the arguments, although technically this is moot
-                    // But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
-                    let args = match self.parse_function_args() {
-                        Ok(s) => s,
-                        Err(e) => return e,
-                    };
-                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: err.position,
-                            message: err.message,
-                        };
-                    }
-                    if value {
-                        return Node::FunctionKind {
-                            kind: Function::True,
-                            args,
-                        };
-                    } else {
-                        return Node::FunctionKind {
-                            kind: Function::False,
-                            args,
-                        };
-                    }
-                }
-                Node::BooleanKind(value)
-            }
+            TokenType::Boolean(value) => Node::BooleanKind(value),
             TokenType::Compare(_) => {
                 // A primary Node cannot start with an operator
                 Node::ParseErrorKind {
@@ -837,14 +635,6 @@ 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
@@ -856,7 +646,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(),
@@ -871,177 +661,187 @@ impl Parser {
                 // We will try to convert to a normal reference
                 // table_name[column_name] => cell1:cell2
                 // table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
-                let context = &self.context;
-                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
-                    Some(i) => i,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
-                        };
-                    }
-                };
-                // table-name => table
-                let table = match self.tables.get(&table_name) {
-                    Some(t) => t,
-                    None => {
-                        let message = format!(
-                            "Table not found: '{table_name}' at '{}!{}{}'",
-                            context.sheet,
-                            number_to_column(context.column)
-                                .unwrap_or(format!("{}", context.column)),
-                            context.row
-                        );
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: 0,
-                            message,
-                        };
-                    }
-                };
-                let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
-                    Some(i) => i,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: 0,
-                            message: format!("table sheet not found: {}", table.sheet_name),
-                        };
-                    }
-                };
-
-                let sheet_name = if table_sheet_index == context_sheet_index {
-                    None
-                } else {
-                    Some(table.sheet_name.clone())
-                };
-
-                // context must be with tables.reference
-                #[allow(clippy::expect_used)]
-                let (column_start, mut row_start, column_end, mut row_end) =
-                    parse_range(&table.reference).expect("Failed parsing range");
-
-                let totals_row_count = table.totals_row_count as i32;
-                let header_row_count = table.header_row_count as i32;
-                row_end -= totals_row_count;
-
-                match specifier {
-                    Some(token::TableSpecifier::ThisRow) => {
-                        row_start = context.row;
-                        row_end = context.row;
-                    }
-                    Some(token::TableSpecifier::Totals) => {
-                        if totals_row_count != 0 {
-                            row_start = row_end + 1;
-                            row_end = row_start;
-                        } else {
-                            // Table1[#Totals] is #REF! if Table1 does not have totals
-                            return Node::ErrorKind(token::Error::REF);
-                        }
-                    }
-                    Some(token::TableSpecifier::Headers) => {
-                        row_end = row_start;
-                    }
-                    Some(token::TableSpecifier::Data) => {
-                        row_start += header_row_count;
-                    }
-                    Some(token::TableSpecifier::All) => {
-                        if totals_row_count != 0 {
-                            row_end += 1;
-                        }
-                    }
-                    None => {
-                        // skip the headers
-                        row_start += header_row_count;
-                    }
-                }
-                match table_reference {
-                    None => Node::RangeKind {
-                        sheet_name,
-                        sheet_index: table_sheet_index,
-                        absolute_row1: true,
-                        absolute_column1: true,
-                        row1: row_start,
-                        column1: column_start,
-                        absolute_row2: true,
-                        absolute_column2: true,
-                        row2: row_end,
-                        column2: column_end,
-                    },
-                    Some(TableReference::ColumnReference(s)) => {
-                        let column_index = match get_table_column_by_name(&s, table) {
-                            Some(s) => s + column_start,
-                            None => {
-                                return Node::ParseErrorKind {
-                                    formula: self.lexer.get_formula(),
-                                    position: self.lexer.get_position() as usize,
-                                    message: format!("Expecting column: {s} in table {table_name}"),
-                                };
-                            }
-                        };
-                        if row_start == row_end {
-                            return Node::ReferenceKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row: true,
-                                absolute_column: true,
-                                row: row_start,
-                                column: column_index,
+                if let Some(context) = &self.context {
+                    let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                        Some(i) => i,
+                        None => {
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: 0,
+                                message: "sheet not found".to_string(),
                             };
                         }
-                        Node::RangeKind {
-                            sheet_name,
-                            sheet_index: table_sheet_index,
-                            absolute_row1: true,
-                            absolute_column1: true,
-                            row1: row_start,
-                            column1: column_index,
-                            absolute_row2: true,
-                            absolute_column2: true,
-                            row2: row_end,
-                            column2: column_index,
+                    };
+                    // table-name => table
+                    let table = match self.tables.get(&table_name) {
+                        Some(t) => t,
+                        None => {
+                            let message = format!(
+                                "Table not found: '{table_name}' at '{}!{}{}'",
+                                context.sheet,
+                                number_to_column(context.column)
+                                    .unwrap_or(format!("{}", context.column)),
+                                context.row
+                            );
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: 0,
+                                message,
+                            };
                         }
-                    }
-                    Some(TableReference::RangeReference((left, right))) => {
-                        let left_column_index = match get_table_column_by_name(&left, table) {
-                            Some(f) => f + column_start,
-                            None => {
-                                return Node::ParseErrorKind {
-                                    formula: self.lexer.get_formula(),
-                                    position: self.lexer.get_position() as usize,
-                                    message: format!(
-                                        "Expecting column: {left} in table {table_name}"
-                                    ),
-                                };
-                            }
-                        };
+                    };
+                    let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
+                        Some(i) => i,
+                        None => {
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: 0,
+                                message: "sheet not found".to_string(),
+                            };
+                        }
+                    };
 
-                        let right_column_index = match get_table_column_by_name(&right, table) {
-                            Some(f) => f + column_start,
-                            None => {
-                                return Node::ParseErrorKind {
-                                    formula: self.lexer.get_formula(),
-                                    position: self.lexer.get_position() as usize,
-                                    message: format!(
-                                        "Expecting column: {right} in table {table_name}"
-                                    ),
-                                };
+                    let sheet_name = if table_sheet_index == context_sheet_index {
+                        None
+                    } else {
+                        Some(table.sheet_name.clone())
+                    };
+
+                    // context must be with tables.reference
+                    #[allow(clippy::expect_used)]
+                    let (column_start, mut row_start, column_end, mut row_end) =
+                        parse_range(&table.reference).expect("Failed parsing range");
+
+                    let totals_row_count = table.totals_row_count as i32;
+                    let header_row_count = table.header_row_count as i32;
+                    row_end -= totals_row_count;
+
+                    match specifier {
+                        Some(token::TableSpecifier::ThisRow) => {
+                            row_start = context.row;
+                            row_end = context.row;
+                        }
+                        Some(token::TableSpecifier::Totals) => {
+                            if totals_row_count != 0 {
+                                row_start = row_end + 1;
+                                row_end = row_start;
+                            } else {
+                                // Table1[#Totals] is #REF! if Table1 does not have totals
+                                return Node::ErrorKind(token::Error::REF);
                             }
-                        };
-                        Node::RangeKind {
-                            sheet_name,
-                            sheet_index: table_sheet_index,
-                            absolute_row1: true,
-                            absolute_column1: true,
-                            row1: row_start,
-                            column1: left_column_index,
-                            absolute_row2: true,
-                            absolute_column2: true,
-                            row2: row_end,
-                            column2: right_column_index,
+                        }
+                        Some(token::TableSpecifier::Headers) => {
+                            row_end = row_start;
+                        }
+                        Some(token::TableSpecifier::Data) => {
+                            row_start += header_row_count;
+                        }
+                        Some(token::TableSpecifier::All) => {
+                            if totals_row_count != 0 {
+                                row_end += 1;
+                            }
+                        }
+                        None => {
+                            // skip the headers
+                            row_start += header_row_count;
                         }
                     }
+                    match table_reference {
+                        None => {
+                            return Node::RangeKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row1: true,
+                                absolute_column1: true,
+                                row1: row_start,
+                                column1: column_start,
+                                absolute_row2: true,
+                                absolute_column2: true,
+                                row2: row_end,
+                                column2: column_end,
+                            };
+                        }
+                        Some(TableReference::ColumnReference(s)) => {
+                            let column_index = match get_table_column_by_name(&s, table) {
+                                Some(s) => s + column_start,
+                                None => {
+                                    return Node::ParseErrorKind {
+                                        formula: self.lexer.get_formula(),
+                                        position: self.lexer.get_position() as usize,
+                                        message: format!(
+                                            "Expecting column: {s} in table {table_name}"
+                                        ),
+                                    };
+                                }
+                            };
+                            if row_start == row_end {
+                                return Node::ReferenceKind {
+                                    sheet_name,
+                                    sheet_index: table_sheet_index,
+                                    absolute_row: true,
+                                    absolute_column: true,
+                                    row: row_start,
+                                    column: column_index,
+                                };
+                            }
+                            return Node::RangeKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row1: true,
+                                absolute_column1: true,
+                                row1: row_start,
+                                column1: column_index,
+                                absolute_row2: true,
+                                absolute_column2: true,
+                                row2: row_end,
+                                column2: column_index,
+                            };
+                        }
+                        Some(TableReference::RangeReference((left, right))) => {
+                            let left_column_index = match get_table_column_by_name(&left, table) {
+                                Some(f) => f + column_start,
+                                None => {
+                                    return Node::ParseErrorKind {
+                                        formula: self.lexer.get_formula(),
+                                        position: self.lexer.get_position() as usize,
+                                        message: format!(
+                                            "Expecting column: {left} in table {table_name}"
+                                        ),
+                                    };
+                                }
+                            };
+
+                            let right_column_index = match get_table_column_by_name(&right, table) {
+                                Some(f) => f + column_start,
+                                None => {
+                                    return Node::ParseErrorKind {
+                                        formula: self.lexer.get_formula(),
+                                        position: self.lexer.get_position() as usize,
+                                        message: format!(
+                                            "Expecting column: {right} in table {table_name}"
+                                        ),
+                                    };
+                                }
+                            };
+                            return Node::RangeKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row1: true,
+                                absolute_column1: true,
+                                row1: row_start,
+                                column1: left_column_index,
+                                absolute_row2: true,
+                                absolute_column2: true,
+                                row2: row_end,
+                                column2: right_column_index,
+                            };
+                        }
+                    }
+                }
+                Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    position: 0,
+                    message: "Structured references not supported in R1C1 mode".to_string(),
                 }
             }
         }

base/src/expressions/parser/move_formula.rs

@@ -1,6 +1,6 @@
 use super::{
     stringify::{stringify_reference, DisplaceData},
-    ArrayNode, Node, Reference,
+    Node, Reference,
 };
 use crate::{
     constants::{LAST_COLUMN, LAST_ROW},
@@ -53,24 +53,15 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
             arguments = to_string_moved(el, move_context);
         }
     }
-    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}"),
-    }
+    format!("{}({})", name, arguments)
 }
 
 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,
@@ -241,7 +232,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         WrongReferenceKind {
             sheet_name,
@@ -325,7 +316,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!(
             "{}:{}",
@@ -358,7 +349,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!(
             "{}^{}",
@@ -371,43 +362,20 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             move_function(name, args, move_context)
         }
         ArrayKind(args) => {
-            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(',');
+            // 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));
                 } else {
-                    first_row = false;
+                    first = false;
+                    arguments = to_string_moved(el, move_context);
                 }
-
-                // 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('}');
             }
-
-            // Enclose the whole matrix in braces
-            format!("{{{matrix_string}}}")
+            format!("{{{}}}", arguments)
         }
-        DefinedNameKind((name, ..)) => name.to_string(),
-        TableNameKind(name) => name.to_string(),
-        WrongVariableKind(name) => name.to_string(),
+        VariableKind(value) => value.to_string(),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
             to_string_moved(left, move_context),
@@ -418,18 +386,12 @@ 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,8 +1,6 @@
 use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-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::token::OpUnary;
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -28,11 +26,6 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
-    RowMove {
-        sheet: u32,
-        row: i32,
-        delta: i32,
-    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -41,21 +34,10 @@ 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,
@@ -64,10 +46,18 @@ 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_column is true then column details will be omitted.
+/// If full_colum is true then column details will be omitted.
 pub(crate) fn stringify_reference(
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
@@ -164,29 +154,6 @@ 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,
@@ -195,18 +162,14 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             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;
-                            }
+                        } else if (*delta > 0
+                            && column > *move_column
+                            && column <= *move_column + *delta)
+                            || (*delta < 0
+                                && column < *move_column
+                                && column >= *move_column + *delta)
+                        {
+                            column -= *delta;
                         }
                     }
                 }
@@ -216,16 +179,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
             };
@@ -240,27 +203,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)
                 }
             }
         }
@@ -272,7 +235,7 @@ fn format_function(
     args: &Vec<Node>,
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
-    export_to_excel: bool,
+    use_original_name: bool,
 ) -> String {
     let mut first = true;
     let mut arguments = "".to_string();
@@ -281,52 +244,27 @@ fn format_function(
             arguments = format!(
                 "{},{}",
                 arguments,
-                stringify(el, context, displace_data, export_to_excel)
+                stringify(el, context, displace_data, use_original_name)
             );
         } else {
             first = false;
-            arguments = stringify(el, context, displace_data, export_to_excel);
+            arguments = stringify(el, context, displace_data, use_original_name);
         }
     }
-    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,
-    export_to_excel: bool,
+    use_original_name: 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,
@@ -416,7 +354,7 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         WrongRangeKind {
             sheet_name,
@@ -465,70 +403,71 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
-            stringify(left, context, displace_data, export_to_excel),
-            stringify(right, context, displace_data, export_to_excel)
+            stringify(left, context, displace_data, use_original_name),
+            stringify(right, context, displace_data, use_original_name)
         ),
         OpConcatenateKind { left, right } => format!(
             "{}&{}",
-            stringify(left, context, displace_data, export_to_excel),
-            stringify(right, context, displace_data, export_to_excel)
+            stringify(left, context, displace_data, use_original_name),
+            stringify(right, context, displace_data, use_original_name)
         ),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
-            stringify(left, context, displace_data, export_to_excel),
+            stringify(left, context, displace_data, use_original_name),
             kind,
-            stringify(right, context, displace_data, export_to_excel)
+            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)
         ),
-        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 { .. } | CompareKind { .. } => format!(
+                OpSumKind { .. } => format!(
                     "({})",
-                    stringify(left, context, displace_data, export_to_excel)
+                    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),
             };
             let y = match **right {
-                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
+                OpSumKind { .. } => format!(
                     "({})",
-                    stringify(right, context, displace_data, export_to_excel)
+                    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),
             };
-            format!("{x}{kind}{y}")
+            format!("{}{}{}", x, kind, y)
         }
         OpPowerKind { left, right } => {
             let x = match **left {
                 BooleanKind(_)
                 | NumberKind(_)
-                | UnaryKind { .. }
                 | StringKind(_)
                 | ReferenceKind { .. }
                 | RangeKind { .. }
                 | WrongReferenceKind { .. }
-                | DefinedNameKind(_)
-                | TableNameKind(_)
-                | WrongVariableKind(_)
-                | WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
+                | VariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(left, context, displace_data, use_original_name)
+                }
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
                 | OpProductKind { .. }
@@ -536,14 +475,14 @@ fn stringify(
                 | FunctionKind { .. }
                 | InvalidFunctionKind { .. }
                 | ArrayKind(_)
+                | UnaryKind { .. }
                 | ErrorKind(_)
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
                 | CompareKind { .. }
-                | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(left, context, displace_data, export_to_excel)
+                    stringify(left, context, displace_data, use_original_name)
                 ),
             };
             let y = match **right {
@@ -553,11 +492,9 @@ fn stringify(
                 | ReferenceKind { .. }
                 | RangeKind { .. }
                 | WrongReferenceKind { .. }
-                | DefinedNameKind(_)
-                | TableNameKind(_)
-                | WrongVariableKind(_)
+                | VariableKind(_)
                 | WrongRangeKind { .. } => {
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                 }
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
@@ -571,128 +508,63 @@ fn stringify(
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
                 | CompareKind { .. }
-                | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                 ),
             };
-            format!("{x}^{y}")
+            format!("{}^{}", x, y)
         }
         InvalidFunctionKind { name, args } => {
-            format_function(name, args, context, displace_data, export_to_excel)
+            format_function(name, args, context, displace_data, use_original_name)
         }
         FunctionKind { kind, args } => {
-            let name = if export_to_excel {
+            let name = if use_original_name {
                 kind.to_xlsx_string()
             } else {
                 kind.to_string()
             };
-            format_function(&name, args, context, displace_data, export_to_excel)
+            format_function(&name, args, context, displace_data, use_original_name)
         }
         ArrayKind(args) => {
-            let mut first_row = true;
-            let mut matrix_string = String::new();
-
-            for row in args {
-                if !first_row {
-                    matrix_string.push(';');
+            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)
+                    );
                 } else {
-                    first_row = false;
+                    first = false;
+                    arguments = stringify(el, context, displace_data, use_original_name);
                 }
-                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!("{{{matrix_string}}}")
+            format!("{{{}}}", arguments)
         }
-        TableNameKind(value) => value.to_string(),
-        DefinedNameKind((name, ..)) => name.to_string(),
-        WrongVariableKind(name) => name.to_string(),
+        VariableKind(value) => value.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                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)
-                    )
-                }
+                format!(
+                    "-{}",
+                    stringify(right, context, displace_data, use_original_name)
+                )
             }
             OpUnary::Percentage => {
                 format!(
                     "{}%",
-                    stringify(right, context, displace_data, export_to_excel)
+                    stringify(right, context, displace_data, use_original_name)
                 )
             }
         },
-        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)
-            )
-        }
     }
 }
 
@@ -780,12 +652,6 @@ 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(_) => {}
@@ -794,96 +660,7 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
         Node::ErrorKind(_) => {}
         Node::ParseErrorKind { .. } => {}
         Node::ArrayKind(_) => {}
-        Node::DefinedNameKind(_) => {}
-        Node::TableNameKind(_) => {}
-        Node::WrongVariableKind(_) => {}
+        Node::VariableKind(_) => {}
         Node::EmptyArgKind => {}
     }
 }
-
-pub(crate) fn rename_defined_name_in_node(
-    node: &mut Node,
-    name: &str,
-    scope: Option<u32>,
-    new_name: &str,
-) {
-    match node {
-        // Rename
-        Node::DefinedNameKind((n, s, _)) => {
-            if name.to_lowercase() == n.to_lowercase() && *s == scope {
-                *n = new_name.to_string();
-            }
-        }
-        // Go next level
-        Node::OpRangeKind { left, right } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        Node::OpConcatenateKind { left, right } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        Node::OpSumKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        Node::OpProductKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        Node::OpPowerKind { left, right } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        Node::FunctionKind { kind: _, args } => {
-            for arg in args {
-                rename_defined_name_in_node(arg, name, scope, new_name);
-            }
-        }
-        Node::InvalidFunctionKind { name: _, args } => {
-            for arg in args {
-                rename_defined_name_in_node(arg, name, scope, new_name);
-            }
-        }
-        Node::CompareKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            rename_defined_name_in_node(left, name, scope, new_name);
-            rename_defined_name_in_node(right, name, scope, new_name);
-        }
-        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(_) => {}
-        Node::NumberKind(_) => {}
-        Node::StringKind(_) => {}
-        Node::ErrorKind(_) => {}
-        Node::ParseErrorKind { .. } => {}
-        Node::ArrayKind(_) => {}
-        Node::EmptyArgKind => {}
-        Node::ReferenceKind { .. } => {}
-        Node::RangeKind { .. } => {}
-        Node::WrongReferenceKind { .. } => {}
-        Node::WrongRangeKind { .. } => {}
-        Node::TableNameKind(_) => {}
-        Node::WrongVariableKind(_) => {}
-    }
-}

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

@@ -1,9 +1,5 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,92 +0,0 @@
-#![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_general.rs

@@ -17,7 +17,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_reference() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -25,14 +25,14 @@ fn test_parser_reference() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("A2", &cell_reference);
+    let t = parser.parse("A2", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R[1]C[0]");
 }
 
 #[test]
 fn test_parser_absolute_column() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -40,14 +40,14 @@ fn test_parser_absolute_column() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A1", &cell_reference);
+    let t = parser.parse("$A1", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R[0]C1");
 }
 
 #[test]
 fn test_parser_absolute_row_col() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -55,14 +55,14 @@ fn test_parser_absolute_row_col() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$C$5", &cell_reference);
+    let t = parser.parse("$C$5", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R5C3");
 }
 
 #[test]
 fn test_parser_absolute_row_col_1() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -70,14 +70,14 @@ fn test_parser_absolute_row_col_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A$1", &cell_reference);
+    let t = parser.parse("$A$1", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R1C1");
 }
 
 #[test]
 fn test_parser_simple_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -86,14 +86,14 @@ fn test_parser_simple_formula() {
         column: 1,
     };
 
-    let t = parser.parse("C3+Sheet2!D4", &cell_reference);
+    let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R[2]C[2]+Sheet2!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_boolean() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -102,14 +102,14 @@ fn test_parser_boolean() {
         column: 1,
     };
 
-    let t = parser.parse("true", &cell_reference);
+    let t = parser.parse("true", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "TRUE");
 }
 
 #[test]
 fn test_parser_bad_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -117,7 +117,7 @@ fn test_parser_bad_formula() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("#Value", &cell_reference);
+    let t = parser.parse("#Value", &Some(cell_reference));
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -138,7 +138,7 @@ fn test_parser_bad_formula() {
 #[test]
 fn test_parser_bad_formula_1() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -146,7 +146,7 @@ fn test_parser_bad_formula_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("<5", &cell_reference);
+    let t = parser.parse("<5", &Some(cell_reference));
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -167,7 +167,7 @@ fn test_parser_bad_formula_1() {
 #[test]
 fn test_parser_bad_formula_2() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -175,7 +175,7 @@ fn test_parser_bad_formula_2() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("*5", &cell_reference);
+    let t = parser.parse("*5", &Some(cell_reference));
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -196,7 +196,7 @@ fn test_parser_bad_formula_2() {
 #[test]
 fn test_parser_bad_formula_3() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -204,7 +204,7 @@ fn test_parser_bad_formula_3() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("SUM(#VALVE!)", &cell_reference);
+    let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -225,7 +225,7 @@ fn test_parser_bad_formula_3() {
 #[test]
 fn test_parser_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -259,11 +259,11 @@ fn test_parser_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &CellReferenceRC {
+            &Some(CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            },
+            }),
         );
         assert_eq!(to_rc_format(&t), formula.expected);
         assert_eq!(to_string(&t, &cell_reference), formula.initial);
@@ -273,7 +273,7 @@ fn test_parser_formulas() {
 #[test]
 fn test_parser_r1c1_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
     parser.set_lexer_mode(LexerMode::R1C1);
 
     let formulas = vec![
@@ -324,11 +324,11 @@ fn test_parser_r1c1_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &CellReferenceRC {
+            &Some(CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            },
+            }),
         );
         assert_eq!(to_string(&t, &cell_reference), formula.expected);
         assert_eq!(to_rc_format(&t), formula.initial);
@@ -338,7 +338,7 @@ fn test_parser_r1c1_formulas() {
 #[test]
 fn test_parser_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -347,14 +347,14 @@ fn test_parser_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second Sheet'!D4", &cell_reference);
+    let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second Sheet'!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_escape_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -363,14 +363,14 @@ fn test_parser_escape_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &cell_reference);
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second ''2'' Sheet'!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_parenthesis() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -379,14 +379,14 @@ fn test_parser_parenthesis() {
         column: 1,
     };
 
-    let t = parser.parse("(C3=\"Yes\")*5", &cell_reference);
+    let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "(R[2]C[2]=\"Yes\")*5");
 }
 
 #[test]
 fn test_parser_excel_xlfn() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -395,7 +395,7 @@ fn test_parser_excel_xlfn() {
         column: 1,
     };
 
-    let t = parser.parse("_xlfn.CONCAT(C3)", &cell_reference);
+    let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
     assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
 }
 
@@ -407,9 +407,9 @@ fn test_to_string_displaced() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
-    let node = parser.parse("C3", context);
+    let node = parser.parse("C3", &Some(context.clone()));
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -427,9 +427,9 @@ fn test_to_string_displaced_full_ranges() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
-    let node = parser.parse("SUM(3:3)", context);
+    let node = parser.parse("SUM(3:3)", &Some(context.clone()));
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -440,7 +440,7 @@ fn test_to_string_displaced_full_ranges() {
         "SUM(3:3)".to_string()
     );
 
-    let node = parser.parse("SUM(D:D)", context);
+    let node = parser.parse("SUM(D:D)", &Some(context.clone()));
     let displace_data = DisplaceData::Row {
         sheet: 0,
         row: 3,
@@ -460,9 +460,9 @@ fn test_to_string_displaced_too_low() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
-    let node = parser.parse("C3", context);
+    let node = parser.parse("C3", &Some(context.clone()));
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -480,9 +480,9 @@ fn test_to_string_displaced_too_high() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
-    let node = parser.parse("C3", context);
+    let node = parser.parse("C3", &Some(context.clone()));
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,

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

@@ -1,75 +0,0 @@
-#![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_155.rs

@@ -9,7 +9,7 @@ use crate::expressions::types::CellReferenceRC;
 #[test]
 fn issue_155_parser() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -17,14 +17,14 @@ fn issue_155_parser() {
         row: 2,
         column: 2,
     };
-    let t = parser.parse("A$1:A2", &cell_reference);
+    let t = parser.parse("A$1:A2", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
 }
 
 #[test]
 fn issue_155_parser_case_2() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -32,14 +32,14 @@ fn issue_155_parser_case_2() {
         row: 20,
         column: 20,
     };
-    let t = parser.parse("C$1:D2", &cell_reference);
+    let t = parser.parse("C$1:D2", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
 }
 
 #[test]
 fn issue_155_parser_only_row() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -48,14 +48,14 @@ fn issue_155_parser_only_row() {
         column: 20,
     };
     // This is tricky, I am not sure what to do in these cases
-    let t = parser.parse("A$2:B1", &cell_reference);
+    let t = parser.parse("A$2:B1", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
 }
 
 #[test]
 fn issue_155_parser_only_column() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -64,6 +64,6 @@ fn issue_155_parser_only_column() {
         column: 20,
     };
     // This is tricky, I am not sure what to do in these cases
-    let t = parser.parse("D1:$A3", &cell_reference);
+    let t = parser.parse("D1:$A3", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
 }

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

@@ -1,27 +0,0 @@
-#![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

@@ -15,7 +15,7 @@ fn test_move_formula() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -27,7 +27,7 @@ fn test_move_formula() {
     };
 
     // formula AB31 will not change
-    let node = parser.parse("AB31", context);
+    let node = parser.parse("AB31", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -43,7 +43,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // formula $AB$31 will not change
-    let node = parser.parse("AB31", context);
+    let node = parser.parse("AB31", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -59,7 +59,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // but formula D5 will change to N15  (N = D + 10)
-    let node = parser.parse("D5", context);
+    let node = parser.parse("D5", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -75,7 +75,7 @@ fn test_move_formula() {
     assert_eq!(t, "N15");
 
     // Also formula $D$5 will change to N15  (N = D + 10)
-    let node = parser.parse("$D$5", context);
+    let node = parser.parse("$D$5", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -102,7 +102,7 @@ fn test_move_formula_context_offset() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -113,7 +113,7 @@ fn test_move_formula_context_offset() {
         height: 5,
     };
 
-    let node = parser.parse("-X9+C2%", context);
+    let node = parser.parse("-X9+C2%", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -140,7 +140,7 @@ fn test_move_formula_area_limits() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -152,7 +152,7 @@ fn test_move_formula_area_limits() {
     };
 
     // Outside of the area. Not moved
-    let node = parser.parse("B2+B3+C1+G6+H5", context);
+    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -168,7 +168,7 @@ fn test_move_formula_area_limits() {
     assert_eq!(t, "B2+B3+C1+G6+H5");
 
     // In the area. Moved
-    let node = parser.parse("C2+F4+F5+F6", context);
+    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -195,7 +195,7 @@ fn test_move_formula_ranges() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     let area = &Area {
         sheet: 0,
@@ -205,7 +205,7 @@ fn test_move_formula_ranges() {
         height: 5,
     };
     // Ranges inside the area are fully displaced (absolute or not)
-    let node = parser.parse("SUM(C2:F5)", context);
+    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -220,7 +220,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(M12:P15)");
 
-    let node = parser.parse("SUM($C$2:$F$5)", context);
+    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -236,7 +236,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM($M$12:$P$15)");
 
     // Ranges completely outside of the area are not touched
-    let node = parser.parse("SUM(A1:B3)", context);
+    let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -251,7 +251,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(A1:B3)");
 
-    let node = parser.parse("SUM($A$1:$B$3)", context);
+    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -267,7 +267,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM($A$1:$B$3)");
 
     // Ranges that overlap with the area are also NOT displaced
-    let node = parser.parse("SUM(A1:F5)", context);
+    let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -283,7 +283,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM(A1:F5)");
 
     // Ranges that contain the area are also NOT displaced
-    let node = parser.parse("SUM(A1:X50)", context);
+    let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -318,10 +318,10 @@ fn test_move_formula_wrong_reference() {
         height: 5,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Wrong formulas will NOT be displaced
-    let node = parser.parse("Sheet3!AB31", context);
+    let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -335,7 +335,7 @@ fn test_move_formula_wrong_reference() {
         },
     );
     assert_eq!(t, "Sheet3!AB31");
-    let node = parser.parse("Sheet3!$X$9", context);
+    let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -350,7 +350,7 @@ fn test_move_formula_wrong_reference() {
     );
     assert_eq!(t, "Sheet3!$X$9");
 
-    let node = parser.parse("SUM(Sheet3!D2:D3)", context);
+    let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -377,7 +377,7 @@ fn test_move_formula_misc() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -387,7 +387,7 @@ fn test_move_formula_misc() {
         width: 4,
         height: 5,
     };
-    let node = parser.parse("X9^C2-F4*H2+SUM(F2:H4)+SUM(C2:F6)", context);
+    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -400,9 +400,9 @@ fn test_move_formula_misc() {
             column_delta: 10,
         },
     );
-    assert_eq!(t, "X9^M12-P14*H2+SUM(F2:H4)+SUM(M12:P16)");
+    assert_eq!(t, "X9^M12-P14*H2");
 
-    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -417,7 +417,7 @@ fn test_move_formula_misc() {
     );
     assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");
 
-    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", context);
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -445,7 +445,7 @@ fn test_move_formula_another_sheet() {
     };
     // we add two sheets and we cut/paste from Sheet1 to Sheet2
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -457,7 +457,10 @@ fn test_move_formula_another_sheet() {
     };
 
     // Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
-    let node = parser.parse("AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)", context);
+    let node = parser.parse(
+        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
+        &Some(context.clone()),
+    );
     let t = move_formula(
         &node,
         &MoveContext {
@@ -475,77 +478,3 @@ 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_ranges.rs

@@ -14,7 +14,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_formulas_with_full_ranges() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -52,11 +52,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_a1,
-            &CellReferenceRC {
+            &Some(CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            },
+            }),
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
         assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -67,11 +67,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_r1c1,
-            &CellReferenceRC {
+            &Some(CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            },
+            }),
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
         assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -81,7 +81,7 @@ fn test_parser_formulas_with_full_ranges() {
 #[test]
 fn test_range_inverse_order() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -93,7 +93,7 @@ fn test_range_inverse_order() {
     // D4:C2 => C2:D4
     let t = parser.parse(
         "SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
-        &cell_reference,
+        &Some(cell_reference.clone()),
     );
     assert_eq!(
         to_string(&t, &cell_reference),

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

@@ -9,7 +9,7 @@ use crate::expressions::types::CellReferenceRC;
 #[test]
 fn exp_order() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -17,54 +17,18 @@ fn exp_order() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("(1 + 2)^3  + 4", &cell_reference);
+    let t = parser.parse("(1 + 2)^3  + 4", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
 
-    let t = parser.parse("(C5 + 3)^R4", &cell_reference);
+    let t = parser.parse("(C5 + 3)^R4", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
 
-    let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
+    let t = parser.parse("(C5 + 3)^(R4*6)", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
 
-    let t = parser.parse("(C5)^(R4)", &cell_reference);
+    let t = parser.parse("(C5)^(R4)", &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "C5^R4");
 
-    let t = parser.parse("(5)^(4)", &cell_reference);
+    let t = parser.parse("(5)^(4)", &Some(cell_reference.clone()));
     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,12 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::stringify::to_string;
-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};
 
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
 fn create_test_table(
     table_name: &str,
     column_names: &[&str],
@@ -62,7 +63,7 @@ fn simple_table() {
     let row_count = 3;
     let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
 
-    let mut parser = Parser::new(worksheets, vec![], tables);
+    let mut parser = Parser::new(worksheets, tables);
     // Reference cell is 'Sheet One'!F2
     let cell_reference = CellReferenceRC {
         sheet: "Sheet One".to_string(),
@@ -71,7 +72,7 @@ fn simple_table() {
     };
 
     let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
-    let t = parser.parse(formula, &cell_reference);
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
 
     // Cell A3
@@ -81,7 +82,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &cell_reference);
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
     assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
 
     // Cell A3 in 'Second Sheet'
@@ -91,7 +92,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &cell_reference);
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
     assert_eq!(
         to_string(&t, &cell_reference),
         "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"

base/src/expressions/parser/walk.rs

@@ -0,0 +1,276 @@
+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::VariableKind(_) => {}
+        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.contains(&name)
+    names.iter().any(|e| *e == name)
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -240,7 +240,6 @@ pub enum TokenType {
     Bang,               // !
     Percent,            // %
     And,                // &
-    At,                 // @
     Reference {
         sheet: Option<String>,
         row: i32,

base/src/expressions/utils/mod.rs

@@ -211,19 +211,15 @@ 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();
-    // length of chars
-    let len = upper.chars().count();
-
-    let mut chars = upper.chars();
-
+    let bytes = upper.as_bytes();
+    let len = bytes.len();
     if len > 255 || len == 0 {
         return false;
     }
-    let first = match chars.next() {
-        Some(ch) => ch,
-        None => return false,
-    };
+    let first = bytes[0] as char;
     // 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;
@@ -241,10 +237,20 @@ pub fn is_valid_identifier(name: &str) -> bool {
     if parse_reference_r1c1(name).is_some() {
         return false;
     }
-    for ch in chars {
-        if !(ch.is_alphanumeric() || ch == '_' || ch == '.') {
-            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;
+            }
         }
+        i += 1;
     }
 
     true
@@ -253,23 +259,15 @@ 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 (i, char) in chars.enumerate() {
+    for char in chars {
         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
 }
 
@@ -281,32 +279,3 @@ 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,7 +196,6 @@ 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"));
@@ -210,7 +209,6 @@ 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

@@ -1,158 +1,18 @@
 use chrono::Datelike;
-use chrono::Days;
 use chrono::Duration;
-use chrono::Months;
 use chrono::NaiveDate;
 
 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
-}
-
-fn is_date_within_range(date: NaiveDate) -> bool {
-    convert_to_serial_number(date) >= MINIMUM_DATE_SERIAL_NUMBER
-        && convert_to_serial_number(date) <= MAXIMUM_DATE_SERIAL_NUMBER
-}
-
-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}"
-        ));
-    };
-    if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
-        return Err(format!(
-            "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
-        ));
-    };
+pub fn from_excel_date(days: i64) -> NaiveDate {
     #[allow(clippy::expect_used)]
     let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
-    Ok(dt + Duration::days(days - 2))
+    dt + Duration::days(days - 2)
 }
 
 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(DATE_OUT_OF_RANGE_MESSAGE.to_string()),
-    }
-}
-
-pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Result<i32, String> {
-    // Excel parses `DATE` very permissively. It allows not just for valid date values, but it
-    // allows for invalid dates as well. If you for example enter `DATE(1900, 1, 32)` it will
-    // return the date `1900-02-01`. Despite giving a day that is out of range it will just
-    // wrap the month and year around.
-    //
-    // This function applies that same logic to dates. And does it in the most compatible way as
-    // possible.
-
-    // Special case for the minimum date
-    if year == 1899 && month == 12 && day == 31 {
-        return Ok(MINIMUM_DATE_SERIAL_NUMBER);
-    }
-    let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
-        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
-    // but tried to increment the months so that it wraps around into within range, excel
-    // would still return an error.
-    //
-    // I.E. DATE(0,13,-1) will return an error, despite it being equivalent to DATE(1,1,0) which
-    // is within range.
-    //
-    // 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(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-    }
-
-    date = {
-        let month_diff = month - 1;
-        let abs_month = month_diff.unsigned_abs();
-        if month_diff <= 0 {
-            date = date - Months::new(abs_month);
-        } else {
-            date = date + Months::new(abs_month);
-        }
-        if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-        }
-        date
-    };
-
-    date = {
-        let day_diff = day - 1;
-        let abs_day = day_diff.unsigned_abs() as u64;
-        if day_diff <= 0 {
-            date = date - Days::new(abs_day);
-        } else {
-            date = date + Days::new(abs_day);
-        }
-        if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
-        }
-        date
-    };
-
-    Ok(convert_to_serial_number(date))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_permissive_date_to_serial_number() {
-        assert_eq!(
-            permissive_date_to_serial_number(42, 42, 2002),
-            date_to_serial_number(12, 7, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 42, 2002),
-            date_to_serial_number(1, 6, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 15, 2000),
-            date_to_serial_number(1, 3, 2001)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 49, 2000),
-            date_to_serial_number(31, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 49, 2000),
-            date_to_serial_number(12, 9, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 1, 2004),
-            date_to_serial_number(12, 9, 2004)
-        );
-    }
-
-    #[test]
-    fn test_max_and_min_dates() {
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 9999),
-            Ok(MAXIMUM_DATE_SERIAL_NUMBER),
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 1899),
-            Ok(MINIMUM_DATE_SERIAL_NUMBER),
-        );
+        Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
+        None => Err("Out of range parameters for date".to_string()),
     }
 }

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, int_len: usize) -> Vec<char> {
+fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
     let b = format!("{:.1$}", value.fract(), precision as usize)
         .chars()
         .collect::<Vec<char>>();
@@ -30,12 +30,6 @@ fn get_fract_part(value: f64, precision: i32, int_len: usize) -> 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()
 }
 
@@ -126,7 +120,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!("{value:.9}");
+                let mut text = format!("{:.9}", value);
                 text = text.trim_end_matches('0').trim_end_matches('.').to_string();
                 Formatted {
                     text,
@@ -144,7 +138,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!("{value:.5}");
+                let s = format!("{:.5}", value);
                 Formatted {
                     text: format!(
                         "{}E{}{:02}",
@@ -160,72 +154,47 @@ 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 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();
+            if !(1.0..=2_958_465.0).contains(&value) {
+                // 2_958_465 is 31 December 9999
+                return Formatted {
+                    text: "#VALUE!".to_owned(),
+                    color: None,
+                    error: Some("Date negative or too long".to_owned()),
+                };
+            }
+            let date = from_excel_date(value as i64);
             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 => 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}'")),
-                                }
-                            }
-                        };
+                    TextToken::Day => {
                         let day = date.day() as usize;
-                        text = format!("{text}{day:02}");
+                        text = format!("{}{}", text, day);
+                    }
+                    TextToken::DayPadded => {
+                        let day = date.day() as usize;
+                        text = format!("{}{:02}", text, day);
                     }
                     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;
@@ -233,16 +202,6 @@ 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;
@@ -250,144 +209,32 @@ 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!("{text}{month:02}");
+                        text = format!("{}{:02}", text, month);
                     }
                     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 {
@@ -399,7 +246,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));
@@ -429,7 +276,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, int_part.len());
+            let fract_part = get_fract_part(value_abs, p.precision);
             // 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
@@ -447,26 +294,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' {
@@ -474,7 +321,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
@@ -499,7 +346,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 {
@@ -525,18 +372,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!("{text}0");
+                                text = format!("{}0", text);
                             } 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!("{text}E-");
+                                    text = format!("{}E-", text);
                                 } else {
-                                    text = format!("{text}E+");
+                                    text = format!("{}E+", text);
                                 }
                             }
                             let number_index = l_exp - (p.exponent_digit_count - index);
@@ -552,7 +399,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 {
@@ -574,13 +421,6 @@ 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 {
@@ -750,10 +590,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(
-    original: &str,
+    value: &str,
     currencies: &[&str],
 ) -> Result<(f64, Option<String>), String> {
-    let value = original.trim();
+    let value = value.trim();
     let scientific_format = "0.00E+00";
 
     // Check if it is a percentage
@@ -773,7 +613,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())));
@@ -805,8 +645,7 @@ pub(crate) fn parse_formatted_number(
         }
     }
 
-    // check if it is a date. NOTE: we don't trim the original here
-    if let Ok((serial_number, format)) = parse_date(original) {
+    if let Ok((serial_number, format)) = parse_date(value) {
         return Ok((serial_number as f64, Some(format)));
     }
 

base/src/formatter/lexer.rs

@@ -26,23 +26,19 @@ pub enum Token {
     Scientific,    // E+
     ScientificMinus, // E-
     General,       // General
-    // Dates and time
+    // Dates
     Day,            // d
     DayPadded,      // dd
     DayNameShort,   // ddd
     DayName,        // dddd+
-    Month,          // m (or minute)
-    MonthPadded,    // mm (or minute padded)
+    Month,          // m
+    MonthPadded,    // mm
     MonthNameShort, // mmm
     MonthName,      // mmmm or mmmmmm+
     MonthLetter,    // mmmmm
     YearShort,      // y or yy
     Year,           // yyy+
-    Hour,           // h
-    HourPadded,     // hh
-    Second,         // s
-    SecondPadded,   // ss
-    AMPM,           // AM/PM (or A/P)
+    // TODO: Hours Minutes and Seconds
     ILLEGAL,
     EOF,
 }
@@ -182,7 +178,10 @@ impl Lexer {
             }
         }
         self.position = position;
-        chars.parse::<f64>().ok()
+        match chars.parse::<f64>() {
+            Err(_) => None,
+            Ok(v) => Some(v),
+        }
     }
 
     fn consume_condition(&mut self) -> Option<(Compare, f64)> {
@@ -337,7 +336,7 @@ impl Lexer {
                         } else if s == '-' {
                             Token::ScientificMinus
                         } else {
-                            self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
+                            self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
                             Token::ILLEGAL
                         }
                     } else {
@@ -365,8 +364,8 @@ impl Lexer {
                         self.read_next_char();
                     }
                     match m {
-                        1 => Token::Month,       // (or minute)
-                        2 => Token::MonthPadded, // (or minute padded)
+                        1 => Token::Month,
+                        2 => Token::MonthPadded,
                         3 => Token::MonthNameShort,
                         4 => Token::MonthName,
                         5 => Token::MonthLetter,
@@ -385,75 +384,18 @@ 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,13 +27,6 @@ pub enum TextToken {
     MonthLetter,
     YearShort,
     Year,
-    Hour,
-    HourPadded,
-    Minute,
-    MinutePadded,
-    Second,
-    SecondPadded,
-    AMPM,
 }
 pub struct NumberPart {
     pub color: Option<i32>,
@@ -52,7 +45,6 @@ pub struct NumberPart {
 
 pub struct DatePart {
     pub color: Option<i32>,
-    pub use_ampm: bool,
     pub tokens: Vec<TextToken>,
 }
 
@@ -109,7 +101,6 @@ 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;
@@ -125,7 +116,6 @@ 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();
@@ -210,9 +200,6 @@ impl Parser {
                     index += 1;
                 }
                 Token::Literal(value) => {
-                    if value == ':' {
-                        is_time = true;
-                    }
                     tokens.push(TextToken::Literal(value));
                 }
                 Token::Text(value) => {
@@ -249,22 +236,12 @@ impl Parser {
                     tokens.push(TextToken::MonthName);
                 }
                 Token::Month => {
-                    if is_time {
-                        // minute
-                        tokens.push(TextToken::Minute);
-                    } else {
-                        is_date = true;
-                        tokens.push(TextToken::Month);
-                    }
+                    is_date = true;
+                    tokens.push(TextToken::Month);
                 }
                 Token::MonthPadded => {
-                    if is_time {
-                        // minute padded
-                        tokens.push(TextToken::MinutePadded);
-                    } else {
-                        is_date = true;
-                        tokens.push(TextToken::MonthPadded);
-                    }
+                    is_date = true;
+                    tokens.push(TextToken::MonthPadded);
                 }
                 Token::MonthLetter => {
                     is_date = true;
@@ -278,32 +255,6 @@ 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;
@@ -331,11 +282,7 @@ impl Parser {
             if is_number {
                 return ParsePart::Error(ErrorPart {});
             }
-            ParsePart::Date(DatePart {
-                color,
-                use_ampm,
-                tokens,
-            })
+            ParsePart::Date(DatePart { color, tokens })
         } else {
             ParsePart::Number(NumberPart {
                 color,

base/src/formatter/test/mod.rs

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

base/src/formatter/test/test_time.rs

@@ -1,32 +0,0 @@
-#![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

@@ -1,946 +0,0 @@
-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,12 +1,10 @@
-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};
+use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y, erf};
 // https://root.cern/doc/v610/TMath_8cxx_source.html
 
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
@@ -162,7 +160,7 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(erfc(x))
+        CalcResult::Number(1.0 - erf(x))
     }
 
     pub(crate) fn fn_erfcprecise(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -173,6 +171,6 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(erfc(x))
+        CalcResult::Number(1.0 - erf(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!("{y:E}")
+            format!("{:E}", y)
         } 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!("{x:E}")
+            format!("{:E}", x)
         } else {
-            format!("{x}")
+            format!("{}", x)
         };
         if y == 0.0 && x == 0.0 {
             write!(f, "0")
@@ -188,7 +188,10 @@ impl Model {
         node: &Node,
         cell: CellReferenceIndex,
     ) -> Result<(f64, f64, Suffix), CalcResult> {
-        let value = self.get_string(node, cell)?;
+        let value = match self.get_string(node, cell) {
+            Ok(s) => s,
+            Err(s) => return Err(s),
+        };
         if value.is_empty() {
             return Ok((0.0, 0.0, Suffix::I));
         }

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!("{value:X}");
+            let result = format!("{:X}", value);
             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!("{value:o}");
+            let result = format!("{:o}", value);
             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!("{value:b}");
+        let result = format!("{:b}", value);
         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!("{value:X}");
+        let result = format!("{:X}", value);
         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!("{value:o}");
+        let result = format!("{:o}", value);
         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!("{value:b}");
+        let result = format!("{:b}", value);
         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!("{value:o}");
+        let result = format!("{:o}", value);
         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!("{value:b}");
+        let result = format!("{:b}", value);
         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!("{value:X}");
+        let result = format!("{:X}", value);
         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

@@ -0,0 +1,53 @@
+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,6 +4,7 @@ mod bessel_j1_y1;
 mod bessel_jn_yn;
 mod bessel_k;
 mod bessel_util;
+mod erf;
 
 #[cfg(test)]
 mod test_bessel;
@@ -12,3 +13,4 @@ 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

@@ -2,7 +2,7 @@ use chrono::Datelike;
 
 use crate::{
     calc_result::CalcResult,
-    constants::{LAST_COLUMN, LAST_ROW, MAXIMUM_DATE_SERIAL_NUMBER, MINIMUM_DATE_SERIAL_NUMBER},
+    constants::{LAST_COLUMN, LAST_ROW},
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     formatter::dates::from_excel_date,
     model::Model,
@@ -13,32 +13,37 @@ use super::financial_util::{compute_irr, compute_npv, compute_rate, compute_xirr
 // See:
 // https://github.com/apache/openoffice/blob/c014b5f2b55cff8d4b0c952d5c16d62ecde09ca1/main/scaddins/source/analysis/financial.cxx
 
-fn is_less_than_one_year(start_date: i64, end_date: i64) -> Result<bool, String> {
-    let end = from_excel_date(end_date)?;
-    let start = from_excel_date(start_date)?;
+// FIXME: Is this enough?
+fn is_valid_date(date: f64) -> bool {
+    date > 0.0
+}
+
+fn is_less_than_one_year(start_date: i64, end_date: i64) -> bool {
     if end_date - start_date < 365 {
-        return Ok(true);
+        return true;
     }
+    let end = from_excel_date(end_date);
+    let start = from_excel_date(start_date);
     let end_year = end.year();
     let start_year = start.year();
     if end_year == start_year {
-        return Ok(true);
+        return true;
     }
     if end_year != start_year + 1 {
-        return Ok(false);
+        return false;
     }
     let start_month = start.month();
     let end_month = end.month();
     if end_month < start_month {
-        return Ok(true);
+        return true;
     }
     if end_month > start_month {
-        return Ok(false);
+        return false;
     }
     // we are one year later same month
     let start_day = start.day();
     let end_day = end.day();
-    Ok(end_day <= start_day)
+    end_day <= start_day
 }
 
 fn compute_payment(
@@ -231,7 +236,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
+                                format!("Invalid worksheet index: '{}'", sheet),
                             )
                         })?
                         .dimension()
@@ -245,7 +250,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
+                                format!("Invalid worksheet index: '{}'", sheet),
                             )
                         })?
                         .dimension()
@@ -431,7 +436,7 @@ impl Model {
         }
         if rate == -1.0 {
             return CalcResult::Error {
-                error: Error::DIV,
+                error: Error::NUM,
                 origin: cell,
                 message: "Rate must be != -1".to_string(),
             };
@@ -918,9 +923,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                 // Excel docs claim that if any number in dates is not a valid date,
                 // XNPV returns the #VALUE! error value, but it seems to return #VALUE!
                 return CalcResult::new_error(
@@ -986,9 +989,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                 return CalcResult::new_error(
                     Error::NUM,
                     cell,
@@ -1372,10 +1373,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1383,7 +1383,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1437,10 +1437,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1448,7 +1447,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1488,10 +1487,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1499,7 +1497,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,

base/src/functions/information.rs

@@ -1,6 +1,6 @@
 use crate::{
     calc_result::CalcResult,
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex, utils::number_to_column},
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     model::{Model, ParsedDefinedName},
 };
 
@@ -235,11 +235,6 @@ 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 {
@@ -252,218 +247,50 @@ impl Model {
             return CalcResult::Number(cell.sheet as f64 + 1.0);
         }
         // The arg could be a defined name or a table
-        // let  = &args[0];
-        match &args[0] {
-            Node::DefinedNameKind((name, scope, _)) => {
-                // Let's see if it is a defined name
-                if let Some(defined_name) = self
-                    .parsed_defined_names
-                    .get(&(*scope, name.to_lowercase()))
-                {
-                    match defined_name {
-                        ParsedDefinedName::CellReference(reference) => {
-                            return CalcResult::Number(reference.sheet as f64 + 1.0)
-                        }
-                        ParsedDefinedName::RangeReference(range) => {
-                            return CalcResult::Number(range.left.sheet as f64 + 1.0)
-                        }
-                        ParsedDefinedName::InvalidDefinedNameFormula => {
-                            return CalcResult::Error {
-                                error: Error::ERROR,
-                                origin: cell,
-                                message: "Invalid name".to_string(),
-                            };
-                        }
+        let arg = &args[0];
+        if let Node::VariableKind(name) = arg {
+            // Let's see if it is a defined name
+            if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
+            {
+                match defined_name {
+                    ParsedDefinedName::CellReference(reference) => {
+                        return CalcResult::Number(reference.sheet as f64 + 1.0)
                     }
-                } else {
-                    // This should never happen
-                    return CalcResult::Error {
-                        error: Error::ERROR,
-                        origin: cell,
-                        message: "Invalid name".to_string(),
-                    };
-                }
-            }
-            Node::TableNameKind(name) => {
-                // Now let's see if it is a table
-                for (table_name, table) in &self.workbook.tables {
-                    if table_name == name {
-                        if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
-                            return CalcResult::Number(sheet_index as f64 + 1.0);
-                        } else {
-                            break;
-                        }
+                    ParsedDefinedName::RangeReference(range) => {
+                        return CalcResult::Number(range.left.sheet as f64 + 1.0)
+                    }
+                    ParsedDefinedName::InvalidDefinedNameFormula => {
+                        return CalcResult::Error {
+                            error: Error::NA,
+                            origin: cell,
+                            message: "Invalid name".to_string(),
+                        };
                     }
                 }
             }
-            Node::WrongVariableKind(name) => {
-                return CalcResult::Error {
-                    error: Error::NAME,
-                    origin: cell,
-                    message: format!("Name not found: {name}"),
-                }
-            }
-            arg => {
-                // Now it should be the name of a sheet
-                let sheet_name = match self.get_string(arg, cell) {
-                    Ok(s) => s,
-                    Err(e) => return e,
-                };
-                if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
-                    return CalcResult::Number(sheet_index as f64 + 1.0);
+            // Now let's see if it is a table
+            for (table_name, table) in &self.workbook.tables {
+                if table_name == name {
+                    if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
+                        return CalcResult::Number(sheet_index as f64 + 1.0);
+                    } else {
+                        break;
+                    }
                 }
             }
         }
+        // Now it should be the name of a sheet
+        let sheet_name = match self.get_string(arg, cell) {
+            Ok(s) => s,
+            Err(e) => return e,
+        };
+        if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
+            return CalcResult::Number(sheet_index as f64 + 1.0);
+        }
         CalcResult::Error {
             error: Error::NA,
             origin: cell,
             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

@@ -7,22 +7,6 @@ use crate::{
 use super::util::compare_values;
 
 impl Model {
-    pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(true)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
-    pub(crate) fn fn_false(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(false)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
     pub(crate) fn fn_if(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 2 || args.len() == 3 {
             let cond_result = self.get_boolean(&args[0], cell);
@@ -82,61 +66,24 @@ impl Model {
     }
 
     pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        self.logical_nary(
-            args,
-            cell,
-            |acc, value| acc.unwrap_or(true) && value,
-            Some(false),
-        )
-    }
-
-    pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        self.logical_nary(
-            args,
-            cell,
-            |acc, value| acc.unwrap_or(false) || value,
-            Some(true),
-        )
-    }
-
-    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        self.logical_nary(args, cell, |acc, value| acc.unwrap_or(false) ^ value, None)
-    }
-
-    /// Base function for AND, OR, XOR. These are all n-ary functions that perform a boolean operation on a series of
-    /// boolean values. These boolean values are sourced from `args`. Note that there is not a 1-1 relationship between
-    /// arguments and boolean values evaluated (see how Ranges are handled for example).
-    ///
-    /// Each argument in `args` is evaluated and the resulting value is interpreted as a boolean as follows:
-    /// - Boolean: The value is used directly.
-    /// - Number: 0 is FALSE, all other values are TRUE.
-    /// - Range: Each cell in the range is evaluated as if they were individual arguments with some caveats
-    /// - Empty arg: FALSE
-    /// - Empty cell & String: Ignored, behaves exactly like the argument wasn't passed in at all
-    /// - Error: Propagated
-    ///
-    /// If no arguments are provided, or all arguments are ignored, the function returns a #VALUE! error
-    ///
-    /// **`fold_fn`:** The function that combines the running result with the next value boolean value. The running result
-    /// starts as `None`.
-    ///
-    /// **`short_circuit_value`:** If the running result reaches `short_circuit_value`, the function returns early.
-    fn logical_nary(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-        fold_fn: fn(Option<bool>, bool) -> bool,
-        short_circuit_value: Option<bool>,
-    ) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut result = None;
+        let mut true_count = 0;
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
-                CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
+                CalcResult::Boolean(b) => {
+                    if !b {
+                        return CalcResult::Boolean(false);
+                    }
+                    true_count += 1;
+                }
+                CalcResult::Number(value) => {
+                    if value == 0.0 {
+                        return CalcResult::Boolean(false);
+                    }
+                    true_count += 1;
+                }
+                CalcResult::String(_value) => {
+                    true_count += 1;
+                }
                 CalcResult::Range { left, right } => {
                     if left.sheet != right.sheet {
                         return CalcResult::new_error(
@@ -152,72 +99,161 @@ impl Model {
                                 row,
                                 column,
                             }) {
-                                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
+                                CalcResult::Boolean(b) => {
+                                    if !b {
+                                        return CalcResult::Boolean(false);
+                                    }
+                                    true_count += 1;
+                                }
                                 CalcResult::Number(value) => {
-                                    result = Some(fold_fn(result, value != 0.0))
+                                    if value == 0.0 {
+                                        return CalcResult::Boolean(false);
+                                    }
+                                    true_count += 1;
+                                }
+                                CalcResult::String(_value) => {
+                                    true_count += 1;
                                 }
                                 error @ CalcResult::Error { .. } => return error,
-                                CalcResult::EmptyArg => {} // unreachable
-                                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)
-                            {
-                                if current_result == short_circuit_value {
-                                    return CalcResult::Boolean(current_result);
-                                }
+                                CalcResult::Range { .. } => {}
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                             }
                         }
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyArg => result = Some(result.unwrap_or(false)),
-                // Strings are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value
-                // comes from a reference, in which case it is always ignored regardless of its value.
-                CalcResult::String(..) => {
-                    if !matches!(arg, Node::ReferenceKind { .. }) {
-                        if let Ok(f) = self.get_boolean(arg, cell) {
-                            result = Some(fold_fn(result, f));
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+            };
+        }
+        if true_count == 0 {
+            return CalcResult::new_error(
+                Error::VALUE,
+                cell,
+                "Boolean values not found".to_string(),
+            );
+        }
+        CalcResult::Boolean(true)
+    }
+
+    pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut result = false;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Boolean(value) => result = value || result,
+                CalcResult::Number(value) => {
+                    if value != 0.0 {
+                        return CalcResult::Boolean(true);
+                    }
+                }
+                CalcResult::String(_value) => {
+                    return CalcResult::Boolean(true);
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Boolean(value) => {
+                                    result = value || result;
+                                }
+                                CalcResult::Number(value) => {
+                                    if value != 0.0 {
+                                        return CalcResult::Boolean(true);
+                                    }
+                                }
+                                CalcResult::String(_value) => {
+                                    return CalcResult::Boolean(true);
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {}
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                            }
                         }
                     }
                 }
-                // 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(),
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+            };
+        }
+        CalcResult::Boolean(result)
+    }
+
+    /// XOR(logical1, [logical]*,...)
+    /// Logical1 is required, subsequent logical values are optional. Can be logical values, arrays, or references.
+    /// The result of XOR is TRUE when the number of TRUE inputs is odd and FALSE when the number of TRUE inputs is even.
+    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let mut true_count = 0;
+        let mut false_count = 0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Boolean(b) => {
+                    if b {
+                        true_count += 1;
+                    } else {
+                        false_count += 1;
                     }
                 }
-            }
-
-            if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
-            {
-                if current_result == short_circuit_value {
-                    return CalcResult::Boolean(current_result);
+                CalcResult::Number(value) => {
+                    if value != 0.0 {
+                        true_count += 1;
+                    } else {
+                        false_count += 1;
+                    }
                 }
-            }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Boolean(b) => {
+                                    if b {
+                                        true_count += 1;
+                                    } else {
+                                        false_count += 1;
+                                    }
+                                }
+                                CalcResult::Number(value) => {
+                                    if value != 0.0 {
+                                        true_count += 1;
+                                    } else {
+                                        false_count += 1;
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            };
         }
-
-        if let Some(result) = result {
-            CalcResult::Boolean(result)
-        } else {
-            CalcResult::new_error(
-                Error::VALUE,
-                cell,
-                "No logical values in argument list".to_string(),
-            )
+        if true_count == 0 && false_count == 0 {
+            return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
         }
+        CalcResult::Boolean(true_count % 2 == 1)
     }
 
     /// =SWITCH(expression, case1, value1, [case, value]*, [default])
@@ -246,7 +282,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.is_multiple_of(2) {
+        if args_count % 2 == 0 {
             return self.evaluate_node_in_context(&args[args_count - 1], cell);
         }
         CalcResult::Error {
@@ -262,7 +298,7 @@ impl Model {
         if args_count < 2 {
             return CalcResult::new_args_number_error(cell);
         }
-        if !args_count.is_multiple_of(2) {
+        if args_count % 2 != 0 {
             // 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::NIMPL,
+                    error: Error::ERROR,
                     origin: cell,
                     message: "argument must be a reference to a single cell".to_string(),
                 };

base/src/functions/macros.rs

@@ -1,100 +0,0 @@
-#[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

@@ -1,200 +0,0 @@
-/// 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/mathematical_sum.rs

@@ -1,230 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-type TwoMatricesResult = (i32, i32, Vec<Option<f64>>, Vec<Option<f64>>);
-
-// Helper to check if two shapes are the same or compatible 1D shapes
-fn is_same_shape_or_1d(rows1: i32, cols1: i32, rows2: i32, cols2: i32) -> bool {
-    (rows1 == rows2 && cols1 == cols2)
-        || (rows1 == 1 && cols2 == 1 && cols1 == rows2)
-        || (rows2 == 1 && cols1 == 1 && cols2 == rows1)
-}
-
-impl Model {
-    // SUMX2MY2(array_x, array_y) - Returns the sum of the difference of squares
-    pub(crate) fn fn_sumx2my2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let result = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(s) => return s,
-        };
-
-        let (_, _, values_left, values_right) = result;
-
-        let mut sum = 0.0;
-        for (x_opt, y_opt) in values_left.into_iter().zip(values_right.into_iter()) {
-            let x = x_opt.unwrap_or(0.0);
-            let y = y_opt.unwrap_or(0.0);
-            sum += x * x - y * y;
-        }
-
-        CalcResult::Number(sum)
-    }
-
-    // SUMX2PY2(array_x, array_y) - Returns the sum of the sum of squares
-    pub(crate) fn fn_sumx2py2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let result = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(s) => return s,
-        };
-
-        let (_rows, _cols, values_left, values_right) = result;
-
-        let mut sum = 0.0;
-        for (x_opt, y_opt) in values_left.into_iter().zip(values_right.into_iter()) {
-            let x = x_opt.unwrap_or(0.0);
-            let y = y_opt.unwrap_or(0.0);
-            sum += x * x + y * y;
-        }
-
-        CalcResult::Number(sum)
-    }
-
-    // SUMXMY2(array_x, array_y) - Returns the sum of squares of differences
-    pub(crate) fn fn_sumxmy2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let result = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(s) => return s,
-        };
-
-        let (_, _, values_left, values_right) = result;
-
-        let mut sum = 0.0;
-        for (x_opt, y_opt) in values_left.into_iter().zip(values_right.into_iter()) {
-            let x = x_opt.unwrap_or(0.0);
-            let y = y_opt.unwrap_or(0.0);
-            let diff = x - y;
-            sum += diff * diff;
-        }
-
-        CalcResult::Number(sum)
-    }
-
-    // Helper function to extract and validate two matrices (ranges or arrays) with compatible shapes.
-    // Returns (rows, cols, values_left, values_right) or an error.
-    pub(crate) fn fn_get_two_matrices(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> Result<TwoMatricesResult, CalcResult> {
-        if args.len() != 2 {
-            return Err(CalcResult::new_args_number_error(cell));
-        }
-        let x_range = self.evaluate_node_in_context(&args[0], cell);
-        let y_range = self.evaluate_node_in_context(&args[1], cell);
-
-        let result = match (x_range, y_range) {
-            (
-                CalcResult::Range {
-                    left: l1,
-                    right: r1,
-                },
-                CalcResult::Range {
-                    left: l2,
-                    right: r2,
-                },
-            ) => {
-                if l1.sheet != l2.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let rows1 = r1.row - l1.row + 1;
-                let cols1 = r1.column - l1.column + 1;
-                let rows2 = r2.row - l2.row + 1;
-                let cols2 = r2.column - l2.column + 1;
-                if !is_same_shape_or_1d(rows1, cols1, rows2, cols2) {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Ranges must be of the same shape".to_string(),
-                    ));
-                }
-                let values_left = self.values_from_range(l1, r1)?;
-                let values_right = self.values_from_range(l2, r2)?;
-                (rows1, cols1, values_left, values_right)
-            }
-            (
-                CalcResult::Array(left),
-                CalcResult::Range {
-                    left: l2,
-                    right: r2,
-                },
-            ) => {
-                let rows2 = r2.row - l2.row + 1;
-                let cols2 = r2.column - l2.column + 1;
-
-                let rows1 = left.len() as i32;
-                let cols1 = if rows1 > 0 { left[0].len() as i32 } else { 0 };
-                if !is_same_shape_or_1d(rows1, cols1, rows2, cols2) {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Array and range must be of the same shape".to_string(),
-                    ));
-                }
-                let values_left = match self.values_from_array(left) {
-                    Err(error) => {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            format!("Error in first array: {:?}", error),
-                        ));
-                    }
-                    Ok(v) => v,
-                };
-                let values_right = self.values_from_range(l2, r2)?;
-                (rows2, cols2, values_left, values_right)
-            }
-            (
-                CalcResult::Range {
-                    left: l1,
-                    right: r1,
-                },
-                CalcResult::Array(right),
-            ) => {
-                let rows1 = r1.row - l1.row + 1;
-                let cols1 = r1.column - l1.column + 1;
-
-                let rows2 = right.len() as i32;
-                let cols2 = if rows2 > 0 { right[0].len() as i32 } else { 0 };
-                if !is_same_shape_or_1d(rows1, cols1, rows2, cols2) {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Range and array must be of the same shape".to_string(),
-                    ));
-                }
-                let values_left = self.values_from_range(l1, r1)?;
-                let values_right = match self.values_from_array(right) {
-                    Err(error) => {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            format!("Error in second array: {:?}", error),
-                        ));
-                    }
-                    Ok(v) => v,
-                };
-                (rows1, cols1, values_left, values_right)
-            }
-            (CalcResult::Array(left), CalcResult::Array(right)) => {
-                let rows1 = left.len() as i32;
-                let rows2 = right.len() as i32;
-                let cols1 = if rows1 > 0 { left[0].len() as i32 } else { 0 };
-                let cols2 = if rows2 > 0 { right[0].len() as i32 } else { 0 };
-
-                if !is_same_shape_or_1d(rows1, cols1, rows2, cols2) {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Arrays must be of the same shape".to_string(),
-                    ));
-                }
-                let values_left = match self.values_from_array(left) {
-                    Err(error) => {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            format!("Error in first array: {:?}", error),
-                        ));
-                    }
-                    Ok(v) => v,
-                };
-                let values_right = match self.values_from_array(right) {
-                    Err(error) => {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            format!("Error in second array: {:?}", error),
-                        ));
-                    }
-                    Ok(v) => v,
-                };
-                (rows1, cols1, values_left, values_right)
-            }
-            _ => {
-                return Err(CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Both arguments must be ranges or arrays".to_string(),
-                ));
-            }
-        };
-        Ok(result)
-    }
-}

base/src/functions/statistical.rs

@@ -0,0 +1,719 @@
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::types::CellReferenceIndex;
+use crate::{
+    calc_result::{CalcResult, Range},
+    expressions::parser::Node,
+    expressions::token::Error,
+    model::Model,
+};
+
+use super::util::build_criteria;
+
+impl Model {
+    pub(crate) fn fn_average(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut sum = 0.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    sum += value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        sum += if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    sum += value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        sum += t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(sum / count)
+    }
+
+    pub(crate) fn fn_averagea(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut sum = 0.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::String(_) => count += 1.0,
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    sum += value;
+                                }
+                                CalcResult::Boolean(b) => {
+                                    if b {
+                                        sum += 1.0;
+                                    }
+                                    count += 1.0;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                            }
+                        }
+                    }
+                }
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    sum += value;
+                }
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                        count += 1.0;
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        sum += t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                CalcResult::Boolean(b) => {
+                    count += 1.0;
+                    if b {
+                        sum += 1.0;
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(sum / count)
+    }
+
+    pub(crate) fn fn_count(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut result = 0.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(_) => {
+                    result += 1.0;
+                }
+                CalcResult::Boolean(_) => {
+                    if !matches!(arg, Node::ReferenceKind { .. }) {
+                        result += 1.0;
+                    }
+                }
+                CalcResult::String(s) => {
+                    if !matches!(arg, Node::ReferenceKind { .. }) && s.parse::<f64>().is_ok() {
+                        result += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            if let CalcResult::Number(_) = self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                result += 1.0;
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_counta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut result = 0.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                _ => {
+                                    result += 1.0;
+                                }
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    result += 1.0;
+                }
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_countblank(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        // COUNTBLANK requires only one argument
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut result = 0.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::EmptyCell | CalcResult::EmptyArg => result += 1.0,
+                CalcResult::String(s) => {
+                    if s.is_empty() {
+                        result += 1.0
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::EmptyCell | CalcResult::EmptyArg => result += 1.0,
+                                CalcResult::String(s) => {
+                                    if s.is_empty() {
+                                        result += 1.0
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            };
+        }
+        CalcResult::Number(result)
+    }
+
+    pub(crate) fn fn_countif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() == 2 {
+            let arguments = vec![args[0].clone(), args[1].clone()];
+            self.fn_countifs(&arguments, cell)
+        } else {
+            CalcResult::new_args_number_error(cell)
+        }
+    }
+
+    /// AVERAGEIF(criteria_range, criteria, [average_range])
+    /// if average_rage is missing then criteria_range will be used
+    pub(crate) fn fn_averageif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() == 2 {
+            let arguments = vec![args[0].clone(), args[0].clone(), args[1].clone()];
+            self.fn_averageifs(&arguments, cell)
+        } else if args.len() == 3 {
+            let arguments = vec![args[2].clone(), args[0].clone(), args[1].clone()];
+            self.fn_averageifs(&arguments, cell)
+        } else {
+            CalcResult::new_args_number_error(cell)
+        }
+    }
+
+    // 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 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let case_count = args_count / 2;
+        // NB: this is a beautiful example of the borrow checker
+        // The order of these two definitions cannot be swapped.
+        let mut criteria = Vec::new();
+        let mut fn_criteria = Vec::new();
+        let ranges = &mut Vec::new();
+        for case_index in 0..case_count {
+            let criterion = self.evaluate_node_in_context(&args[case_index * 2 + 1], cell);
+            criteria.push(criterion);
+            // NB: We cannot do:
+            // fn_criteria.push(build_criteria(&criterion));
+            // because criterion doesn't live long enough
+            let result = self.evaluate_node_in_context(&args[case_index * 2], cell);
+            if result.is_error() {
+                return result;
+            }
+            if let CalcResult::Range { left, right } = result {
+                if left.sheet != right.sheet {
+                    return CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Ranges are in different sheets".to_string(),
+                    );
+                }
+                // TODO test ranges are of the same size as sum_range
+                ranges.push(Range { left, right });
+            } else {
+                return CalcResult::new_error(Error::VALUE, cell, "Expected a range".to_string());
+            }
+        }
+        for criterion in criteria.iter() {
+            fn_criteria.push(build_criteria(criterion));
+        }
+
+        let mut total = 0.0;
+        let first_range = &ranges[0];
+        let left_row = first_range.left.row;
+        let left_column = first_range.left.column;
+        let right_row = first_range.right.row;
+        let right_column = first_range.right.column;
+
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
+            Ok(s) => s.dimension(),
+            Err(_) => {
+                return CalcResult::new_error(
+                    Error::ERROR,
+                    cell,
+                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
+                )
+            }
+        };
+        let max_row = dimension.max_row;
+        let max_column = dimension.max_column;
+
+        let open_row = left_row == 1 && right_row == LAST_ROW;
+        let open_column = left_column == 1 && right_column == LAST_COLUMN;
+
+        for row in left_row..right_row + 1 {
+            if open_row && row > max_row {
+                // If the row is larger than the max row in the sheet then all cells are empty.
+                // We compute it only once
+                let mut is_true = true;
+                for fn_criterion in fn_criteria.iter() {
+                    if !fn_criterion(&CalcResult::EmptyCell) {
+                        is_true = false;
+                        break;
+                    }
+                }
+                if is_true {
+                    total += ((LAST_ROW - max_row) * (right_column - left_column + 1)) as f64;
+                }
+                break;
+            }
+            for column in left_column..right_column + 1 {
+                if open_column && column > max_column {
+                    // If the column is larger than the max column in the sheet then all cells are empty.
+                    // We compute it only once
+                    let mut is_true = true;
+                    for fn_criterion in fn_criteria.iter() {
+                        if !fn_criterion(&CalcResult::EmptyCell) {
+                            is_true = false;
+                            break;
+                        }
+                    }
+                    if is_true {
+                        total += (LAST_COLUMN - max_column) as f64;
+                    }
+                    break;
+                }
+                let mut is_true = true;
+                for case_index in 0..case_count {
+                    // We check if value in range n meets criterion n
+                    let range = &ranges[case_index];
+                    let fn_criterion = &fn_criteria[case_index];
+                    let value = self.evaluate_cell(CellReferenceIndex {
+                        sheet: range.left.sheet,
+                        row: range.left.row + row - first_range.left.row,
+                        column: range.left.column + column - first_range.left.column,
+                    });
+                    if !fn_criterion(&value) {
+                        is_true = false;
+                        break;
+                    }
+                }
+                if is_true {
+                    total += 1.0;
+                }
+            }
+        }
+        CalcResult::Number(total)
+    }
+
+    pub(crate) fn apply_ifs<F>(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        mut apply: F,
+    ) -> Result<(), CalcResult>
+    where
+        F: FnMut(f64),
+    {
+        let args_count = args.len();
+        if args_count < 3 || args_count % 2 == 0 {
+            return Err(CalcResult::new_args_number_error(cell));
+        }
+        let arg_0 = self.evaluate_node_in_context(&args[0], cell);
+        if arg_0.is_error() {
+            return Err(arg_0);
+        }
+        let sum_range = if let CalcResult::Range { left, right } = arg_0 {
+            if left.sheet != right.sheet {
+                return Err(CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Ranges are in different sheets".to_string(),
+                ));
+            }
+            Range { left, right }
+        } else {
+            return Err(CalcResult::new_error(
+                Error::VALUE,
+                cell,
+                "Expected a range".to_string(),
+            ));
+        };
+
+        let case_count = (args_count - 1) / 2;
+        // NB: this is a beautiful example of the borrow checker
+        // The order of these two definitions cannot be swapped.
+        let mut criteria = Vec::new();
+        let mut fn_criteria = Vec::new();
+        let ranges = &mut Vec::new();
+        for case_index in 1..=case_count {
+            let criterion = self.evaluate_node_in_context(&args[case_index * 2], cell);
+            // NB: criterion might be an error. That's ok
+            criteria.push(criterion);
+            // NB: We cannot do:
+            // fn_criteria.push(build_criteria(&criterion));
+            // because criterion doesn't live long enough
+            let result = self.evaluate_node_in_context(&args[case_index * 2 - 1], cell);
+            if result.is_error() {
+                return Err(result);
+            }
+            if let CalcResult::Range { left, right } = result {
+                if left.sheet != right.sheet {
+                    return Err(CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Ranges are in different sheets".to_string(),
+                    ));
+                }
+                // TODO test ranges are of the same size as sum_range
+                ranges.push(Range { left, right });
+            } else {
+                return Err(CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Expected a range".to_string(),
+                ));
+            }
+        }
+        for criterion in criteria.iter() {
+            fn_criteria.push(build_criteria(criterion));
+        }
+
+        let left_row = sum_range.left.row;
+        let left_column = sum_range.left.column;
+        let mut right_row = sum_range.right.row;
+        let mut right_column = sum_range.right.column;
+
+        if left_row == 1 && right_row == LAST_ROW {
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_row,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
+        }
+        if left_column == 1 && right_column == LAST_COLUMN {
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_column,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
+        }
+
+        for row in left_row..right_row + 1 {
+            for column in left_column..right_column + 1 {
+                let mut is_true = true;
+                for case_index in 0..case_count {
+                    // We check if value in range n meets criterion n
+                    let range = &ranges[case_index];
+                    let fn_criterion = &fn_criteria[case_index];
+                    let value = self.evaluate_cell(CellReferenceIndex {
+                        sheet: range.left.sheet,
+                        row: range.left.row + row - sum_range.left.row,
+                        column: range.left.column + column - sum_range.left.column,
+                    });
+                    if !fn_criterion(&value) {
+                        is_true = false;
+                        break;
+                    }
+                }
+                if is_true {
+                    let v = self.evaluate_cell(CellReferenceIndex {
+                        sheet: sum_range.left.sheet,
+                        row,
+                        column,
+                    });
+                    match v {
+                        CalcResult::Number(n) => apply(n),
+                        CalcResult::Error { .. } => return Err(v),
+                        _ => {}
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn fn_averageifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let mut total = 0.0;
+        let mut count = 0.0;
+
+        let average = |value: f64| {
+            total += value;
+            count += 1.0;
+        };
+        if let Err(e) = self.apply_ifs(args, cell, average) {
+            return e;
+        }
+
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "division by 0".to_string(),
+            };
+        }
+        CalcResult::Number(total / count)
+    }
+
+    pub(crate) fn fn_minifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let mut min = f64::INFINITY;
+        let apply_min = |value: f64| min = value.min(min);
+        if let Err(e) = self.apply_ifs(args, cell, apply_min) {
+            return e;
+        }
+
+        if min.is_infinite() {
+            min = 0.0;
+        }
+        CalcResult::Number(min)
+    }
+
+    pub(crate) fn fn_maxifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let mut max = -f64::INFINITY;
+        let apply_max = |value: f64| max = value.max(max);
+        if let Err(e) = self.apply_ifs(args, cell, apply_max) {
+            return e;
+        }
+        if max.is_infinite() {
+            max = 0.0;
+        }
+        CalcResult::Number(max)
+    }
+
+    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut product = 1.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    product *= value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        product *= if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    product *= value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        product *= t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(product.powf(1.0 / count))
+    }
+}

base/src/functions/statistical/beta.rs

@@ -1,213 +0,0 @@
-use statrs::distribution::{Beta, Continuous, ContinuousCDF};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // BETA.DIST(x, alpha, beta, cumulative, [A], [B])
-    pub(crate) fn fn_beta_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let arg_count = args.len();
-        if !(4..=6).contains(&arg_count) {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let alpha = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let beta_param = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // cumulative argument: interpret like Excel
-        let cumulative = match self.evaluate_node_in_context(&args[3], cell) {
-            CalcResult::Boolean(b) => b,
-            CalcResult::Number(n) => n != 0.0,
-            CalcResult::String(s) => {
-                let up = s.to_ascii_uppercase();
-                if up == "TRUE" {
-                    true
-                } else if up == "FALSE" {
-                    false
-                } else {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "cumulative must be TRUE/FALSE or numeric".to_string(),
-                    };
-                }
-            }
-            error @ CalcResult::Error { .. } => return error,
-            _ => {
-                return CalcResult::Error {
-                    error: Error::VALUE,
-                    origin: cell,
-                    message: "Invalid cumulative argument".to_string(),
-                }
-            }
-        };
-
-        // Optional A, B
-        let a = if arg_count >= 5 {
-            match self.get_number_no_bools(&args[4], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        } else {
-            0.0
-        };
-
-        let b = if arg_count >= 6 {
-            match self.get_number_no_bools(&args[5], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        } else {
-            1.0
-        };
-
-        // Excel: alpha <= 0 or beta <= 0 → #NUM!
-        if alpha <= 0.0 || beta_param <= 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "alpha and beta must be > 0 in BETA.DIST".to_string(),
-            );
-        }
-
-        // Excel: if x < A, x > B, or A = B → #NUM!
-        if b == a || x < a || x > b {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "x must be between A and B and A < B in BETA.DIST".to_string(),
-            );
-        }
-
-        // Transform to standard Beta(0,1)
-        let width = b - a;
-        let t = (x - a) / width;
-
-        let dist = match Beta::new(alpha, beta_param) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Beta distribution".to_string(),
-                )
-            }
-        };
-
-        let result = if cumulative {
-            dist.cdf(t)
-        } else {
-            // general-interval beta pdf: f_X(x) = f_T(t) / (B - A), t=(x-A)/(B-A)
-            dist.pdf(t) / width
-        };
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for BETA.DIST".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_beta_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let arg_count = args.len();
-        if !(3..=5).contains(&arg_count) {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let alpha = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let beta_param = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let a = if arg_count >= 4 {
-            match self.get_number_no_bools(&args[3], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        } else {
-            0.0
-        };
-
-        let b = if arg_count >= 5 {
-            match self.get_number_no_bools(&args[4], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        } else {
-            1.0
-        };
-
-        if alpha <= 0.0 || beta_param <= 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "alpha and beta must be > 0 in BETA.INV".to_string(),
-            );
-        }
-
-        // probability <= 0 or probability > 1 → #NUM!
-        if p <= 0.0 || p > 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in (0,1] in BETA.INV".to_string(),
-            );
-        }
-
-        if b <= a {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "A must be < B in BETA.INV".to_string(),
-            );
-        }
-
-        let dist = match Beta::new(alpha, beta_param) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Beta distribution".to_string(),
-                )
-            }
-        };
-
-        let t = dist.inverse_cdf(p);
-        if t.is_nan() || t.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for BETA.INV".to_string(),
-            );
-        }
-
-        // Map back from [0,1] to [A,B]
-        let x = a + t * (b - a);
-        CalcResult::Number(x)
-    }
-}

base/src/functions/statistical/binom.rs

@@ -1,311 +0,0 @@
-use statrs::distribution::{Binomial, Discrete, DiscreteCDF};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_binom_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // number_s
-        let number_s = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // trials
-        let trials = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // probability_s
-        let p = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // cumulative (logical)
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        // Domain checks
-        if trials < 0.0
-            || number_s < 0.0
-            || number_s > trials
-            || p.is_nan()
-            || !(0.0..=1.0).contains(&p)
-        {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid parameters for BINOM.DIST".to_string(),
-            );
-        }
-
-        // Limit to u64
-        if trials > u64::MAX as f64 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Number of trials too large".to_string(),
-            );
-        }
-
-        let n = trials as u64;
-        let k = number_s as u64;
-
-        let dist = match Binomial::new(p, n) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for binomial distribution".to_string(),
-                )
-            }
-        };
-
-        let prob = if cumulative { dist.cdf(k) } else { dist.pmf(k) };
-
-        if prob.is_nan() || prob.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for BINOM.DIST".to_string(),
-            );
-        }
-
-        CalcResult::Number(prob)
-    }
-
-    pub(crate) fn fn_binom_dist_range(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() < 3 || args.len() > 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // trials
-        let trials = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // probability_s
-        let p = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // number_s (lower)
-        let number_s = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // number_s2 (upper, optional)
-        let number_s2 = if args.len() == 4 {
-            match self.get_number_no_bools(&args[3], cell) {
-                Ok(f) => f.trunc(),
-                Err(e) => return e,
-            }
-        } else {
-            number_s
-        };
-
-        if trials < 0.0
-            || number_s < 0.0
-            || number_s2 < 0.0
-            || number_s > number_s2
-            || number_s2 > trials
-            || p.is_nan()
-            || !(0.0..=1.0).contains(&p)
-        {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid parameters for BINOM.DIST.RANGE".to_string(),
-            );
-        }
-
-        if trials > u64::MAX as f64 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Number of trials too large".to_string(),
-            );
-        }
-
-        let n = trials as u64;
-        let lower = number_s as u64;
-        let upper = number_s2 as u64;
-
-        let dist = match Binomial::new(p, n) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for binomial distribution".to_string(),
-                )
-            }
-        };
-
-        let prob = if lower == 0 {
-            dist.cdf(upper)
-        } else {
-            let cdf_upper = dist.cdf(upper);
-            let cdf_below_lower = dist.cdf(lower - 1);
-            cdf_upper - cdf_below_lower
-        };
-
-        if prob.is_nan() || prob.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for BINOM.DIST.RANGE".to_string(),
-            );
-        }
-
-        CalcResult::Number(prob)
-    }
-
-    pub(crate) fn fn_binom_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // trials
-        let trials = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // probability_s
-        let p = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // alpha
-        let alpha = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if trials < 0.0
-            || trials > u64::MAX as f64
-            || p.is_nan()
-            || !(0.0..=1.0).contains(&p)
-            || alpha.is_nan()
-            || !(0.0..=1.0).contains(&alpha)
-        {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid parameters for BINOM.INV".to_string(),
-            );
-        }
-
-        let n = trials as u64;
-
-        let dist = match Binomial::new(p, n) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for binomial distribution".to_string(),
-                )
-            }
-        };
-
-        // DiscreteCDF::inverse_cdf returns u64 for binomial
-        let k = statrs::distribution::DiscreteCDF::inverse_cdf(&dist, alpha);
-
-        CalcResult::Number(k as f64)
-    }
-
-    pub(crate) fn fn_negbinom_dist(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        use statrs::distribution::{Discrete, DiscreteCDF, NegativeBinomial};
-
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let number_f = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let number_s = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let probability_s = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if number_f < 0.0 || number_s < 1.0 || !(0.0..=1.0).contains(&probability_s) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for NEGBINOM.DIST".to_string(),
-            };
-        }
-
-        // Guard against absurdly large failures that won't fit in u64
-        if number_f > (u64::MAX as f64) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for NEGBINOM.DIST".to_string(),
-            };
-        }
-
-        let dist = match NegativeBinomial::new(number_s, probability_s) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameter for NEGBINOM.DIST".to_string(),
-                }
-            }
-        };
-
-        let f_u = number_f as u64;
-        let result = if cumulative {
-            dist.cdf(f_u)
-        } else {
-            dist.pmf(f_u)
-        };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for NEGBINOM.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/chisq.rs

@@ -1,397 +0,0 @@
-use statrs::distribution::{ChiSquared, Continuous, ContinuousCDF};
-
-use crate::expressions::parser::ArrayNode;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // CHISQ.DIST(x, deg_freedom, cumulative)
-    pub(crate) fn fn_chisq_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[2], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "x must be >= 0 in CHISQ.DIST".to_string(),
-            );
-        }
-        if df < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in CHISQ.DIST".to_string(),
-            );
-        }
-
-        let dist = match ChiSquared::new(df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Chi-squared distribution".to_string(),
-                )
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for CHISQ.DIST".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // CHISQ.DIST.RT(x, deg_freedom)
-    pub(crate) fn fn_chisq_dist_rt(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df_raw = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = df_raw.trunc();
-
-        if x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "x must be >= 0 in CHISQ.DIST.RT".to_string(),
-            );
-        }
-        if df < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in CHISQ.DIST.RT".to_string(),
-            );
-        }
-
-        let dist = match ChiSquared::new(df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Chi-squared distribution".to_string(),
-                )
-            }
-        };
-
-        // Right-tail probability: P(X > x).
-        // Use sf(x) directly for better numerical properties than 1 - cdf(x).
-        let result = dist.sf(x);
-
-        if result.is_nan() || result.is_infinite() || result < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for CHISQ.DIST.RT".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // CHISQ.INV(probability, deg_freedom)
-    pub(crate) fn fn_chisq_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // if probability < 0 or > 1 → #NUM!
-        if !(0.0..=1.0).contains(&p) {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in [0,1] in CHISQ.INV".to_string(),
-            );
-        }
-        if df < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in CHISQ.INV".to_string(),
-            );
-        }
-
-        let dist = match ChiSquared::new(df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Chi-squared distribution".to_string(),
-                )
-            }
-        };
-
-        let x = dist.inverse_cdf(p);
-
-        if x.is_nan() || x.is_infinite() || x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for CHISQ.INV".to_string(),
-            );
-        }
-
-        CalcResult::Number(x)
-    }
-
-    // CHISQ.INV.RT(probability, deg_freedom)
-    pub(crate) fn fn_chisq_inv_rt(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df_raw = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = df_raw.trunc();
-
-        // if probability < 0 or > 1 → #NUM!
-        if !(0.0..=1.0).contains(&p) {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in [0,1] in CHISQ.INV.RT".to_string(),
-            );
-        }
-        if df < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in CHISQ.INV.RT".to_string(),
-            );
-        }
-
-        let dist = match ChiSquared::new(df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Chi-squared distribution".to_string(),
-                )
-            }
-        };
-
-        // Right-tail inverse: p = P(X > x) = SF(x) = 1 - CDF(x)
-        // So x = inverse_cdf(1 - p).
-        let x = dist.inverse_cdf(1.0 - p);
-
-        if x.is_nan() || x.is_infinite() || x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for CHISQ.INV.RT".to_string(),
-            );
-        }
-
-        CalcResult::Number(x)
-    }
-
-    pub(crate) fn values_from_range(
-        &mut self,
-        left: CellReferenceIndex,
-        right: CellReferenceIndex,
-    ) -> Result<Vec<Option<f64>>, CalcResult> {
-        let mut values = Vec::new();
-        for row_offset in 0..=(right.row - left.row) {
-            for col_offset in 0..=(right.column - left.column) {
-                let cell_ref = CellReferenceIndex {
-                    sheet: left.sheet,
-                    row: left.row + row_offset,
-                    column: left.column + col_offset,
-                };
-                let cell_value = self.evaluate_cell(cell_ref);
-                match cell_value {
-                    CalcResult::Number(v) => {
-                        values.push(Some(v));
-                    }
-                    error @ CalcResult::Error { .. } => return Err(error),
-                    _ => {
-                        values.push(None);
-                    }
-                }
-            }
-        }
-        Ok(values)
-    }
-
-    pub(crate) fn values_from_array(
-        &mut self,
-        array: Vec<Vec<ArrayNode>>,
-    ) -> Result<Vec<Option<f64>>, Error> {
-        let mut values = Vec::new();
-        for row in array {
-            for item in row {
-                match item {
-                    ArrayNode::Number(f) => {
-                        values.push(Some(f));
-                    }
-                    ArrayNode::Error(error) => {
-                        return Err(error);
-                    }
-                    _ => {
-                        values.push(None);
-                    }
-                }
-            }
-        }
-        Ok(values)
-    }
-
-    // CHISQ.TEST(actual_range, expected_range)
-    pub(crate) fn fn_chisq_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (width, height, values_left, values_right) = match self.fn_get_two_matrices(args, cell)
-        {
-            Ok(v) => v,
-            Err(r) => return r,
-        };
-
-        let mut values = Vec::with_capacity(values_left.len());
-
-        // Now we have:
-        // - values: flattened (observed, expected)
-        // - width, height: shape
-        for i in 0..values_left.len() {
-            match (values_left[i], values_right[i]) {
-                (Some(v1), Some(v2)) => {
-                    values.push((v1, v2));
-                }
-                _ => {
-                    values.push((1.0, 1.0));
-                }
-            }
-        }
-        if width == 0 || height == 0 || values.len() < 2 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "CHISQ.TEST requires at least two data points".to_string(),
-            );
-        }
-
-        let mut chi2 = 0.0;
-        for (obs, exp) in &values {
-            if *obs < 0.0 || *exp < 0.0 {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Negative value in CHISQ.TEST data".to_string(),
-                );
-            }
-            if *exp == 0.0 {
-                return CalcResult::new_error(
-                    Error::DIV,
-                    cell,
-                    "Zero expected value in CHISQ.TEST".to_string(),
-                );
-            }
-            let diff = obs - exp;
-            chi2 += (diff * diff) / exp;
-        }
-
-        if chi2 < 0.0 && chi2 > -1e-12 {
-            chi2 = 0.0;
-        }
-
-        let total = width * height;
-        if total <= 1 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "CHISQ.TEST degrees of freedom is zero".to_string(),
-            );
-        }
-
-        let df = if width > 1 && height > 1 {
-            (width - 1) * (height - 1)
-        } else {
-            total - 1
-        };
-
-        let dist = match ChiSquared::new(df as f64) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid degrees of freedom in CHISQ.TEST".to_string(),
-                );
-            }
-        };
-
-        let mut p = 1.0 - dist.cdf(chi2);
-
-        // clamp tiny fp noise
-        if p < 0.0 && p > -1e-15 {
-            p = 0.0;
-        }
-        if p > 1.0 && p < 1.0 + 1e-15 {
-            p = 1.0;
-        }
-
-        CalcResult::Number(p)
-    }
-}

base/src/functions/statistical/correl.rs

@@ -1,227 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // CORREL(array1, array2) - Returns the correlation coefficient of two data sets
-    pub(crate) fn fn_correl(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-
-        let mut n = 0.0;
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        let mut sum_x2 = 0.0;
-        let mut sum_y2 = 0.0;
-        let mut sum_xy = 0.0;
-
-        for (x_opt, y_opt) in values_left.into_iter().zip(values_right.into_iter()) {
-            if let (Some(x), Some(y)) = (x_opt, y_opt) {
-                n += 1.0;
-                sum_x += x;
-                sum_y += y;
-                sum_x2 += x * x;
-                sum_y2 += y * y;
-                sum_xy += x * y;
-            }
-        }
-
-        // Need at least 2 valid pairs
-        if n < 2.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "CORREL requires at least two numeric data points in each range".to_string(),
-            );
-        }
-
-        let num = n * sum_xy - sum_x * sum_y;
-        let denom_x = n * sum_x2 - sum_x * sum_x;
-        let denom_y = n * sum_y2 - sum_y * sum_y;
-        let denom = (denom_x * denom_y).sqrt();
-
-        if denom == 0.0 || !denom.is_finite() {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Division by zero in CORREL".to_string(),
-            );
-        }
-
-        let r = num / denom;
-        CalcResult::Number(r)
-    }
-
-    // SLOPE(known_y's, known_x's) - Returns the slope of the linear regression line
-    pub(crate) fn fn_slope(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_rows, _cols, values_y, values_x) = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-
-        let mut n = 0.0;
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        let mut sum_x2 = 0.0;
-        let mut sum_xy = 0.0;
-
-        let len = values_y.len().min(values_x.len());
-        for i in 0..len {
-            if let (Some(y), Some(x)) = (values_y[i], values_x[i]) {
-                n += 1.0;
-                sum_x += x;
-                sum_y += y;
-                sum_x2 += x * x;
-                sum_xy += x * y;
-            }
-        }
-
-        if n < 2.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "SLOPE requires at least two numeric data points".to_string(),
-            );
-        }
-
-        let denom = n * sum_x2 - sum_x * sum_x;
-        if denom == 0.0 || !denom.is_finite() {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Division by zero in SLOPE".to_string(),
-            );
-        }
-
-        let num = n * sum_xy - sum_x * sum_y;
-        let slope = num / denom;
-
-        CalcResult::Number(slope)
-    }
-
-    // INTERCEPT(known_y's, known_x's) - Returns the y-intercept of the linear regression line
-    pub(crate) fn fn_intercept(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_rows, _cols, values_y, values_x) = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-
-        let mut n = 0.0;
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        let mut sum_x2 = 0.0;
-        let mut sum_xy = 0.0;
-
-        let len = values_y.len().min(values_x.len());
-        for i in 0..len {
-            if let (Some(y), Some(x)) = (values_y[i], values_x[i]) {
-                n += 1.0;
-                sum_x += x;
-                sum_y += y;
-                sum_x2 += x * x;
-                sum_xy += x * y;
-            }
-        }
-
-        if n < 2.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "INTERCEPT requires at least two numeric data points".to_string(),
-            );
-        }
-
-        let denom = n * sum_x2 - sum_x * sum_x;
-        if denom == 0.0 || !denom.is_finite() {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Division by zero in INTERCEPT".to_string(),
-            );
-        }
-
-        let num = n * sum_xy - sum_x * sum_y;
-        let slope = num / denom;
-        let intercept = (sum_y - slope * sum_x) / n;
-
-        CalcResult::Number(intercept)
-    }
-
-    // STEYX(known_y's, known_x's) - Returns the standard error of the predicted y-values
-    pub(crate) fn fn_steyx(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_rows, _cols, values_y, values_x) = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-
-        let mut n = 0.0;
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        let mut sum_x2 = 0.0;
-        let mut sum_xy = 0.0;
-
-        // We need the actual pairs again later for residuals
-        let mut pairs: Vec<(f64, f64)> = Vec::new();
-
-        let len = values_y.len().min(values_x.len());
-        for i in 0..len {
-            if let (Some(y), Some(x)) = (values_y[i], values_x[i]) {
-                n += 1.0;
-                sum_x += x;
-                sum_y += y;
-                sum_x2 += x * x;
-                sum_xy += x * y;
-                pairs.push((x, y));
-            }
-        }
-
-        // Need at least 3 points for STEYX (n - 2 in denominator)
-        if n < 3.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STEYX requires at least three numeric data points".to_string(),
-            );
-        }
-
-        let denom = n * sum_x2 - sum_x * sum_x;
-        if denom == 0.0 || !denom.is_finite() {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Division by zero in STEYX".to_string(),
-            );
-        }
-
-        let num = n * sum_xy - sum_x * sum_y;
-        let slope = num / denom;
-        let intercept = (sum_y - slope * sum_x) / n;
-
-        // Sum of squared residuals: Σ (y - ŷ)^2, ŷ = intercept + slope * x
-        let mut sse = 0.0;
-        for (x, y) in pairs {
-            let y_hat = intercept + slope * x;
-            let diff = y - y_hat;
-            sse += diff * diff;
-        }
-
-        let dof = n - 2.0;
-        if dof <= 0.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STEYX has non-positive degrees of freedom".to_string(),
-            );
-        }
-
-        let sey = (sse / dof).sqrt();
-        if !sey.is_finite() {
-            return CalcResult::new_error(Error::DIV, cell, "Numerical error in STEYX".to_string());
-        }
-
-        CalcResult::Number(sey)
-    }
-}

base/src/functions/statistical/covariance.rs

@@ -1,264 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_covariance_p(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values1_opts = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in first array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "First argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let values2_opts = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in second array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Second argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        // Same number of cells
-        if values1_opts.len() != values2_opts.len() {
-            return CalcResult::new_error(
-                Error::NA,
-                cell,
-                "COVARIANCE.P requires arrays of the same size".to_string(),
-            );
-        }
-
-        // Count numeric data points in each array (ignoring text/booleans/empty)
-        let count1 = values1_opts.iter().filter(|v| v.is_some()).count();
-        let count2 = values2_opts.iter().filter(|v| v.is_some()).count();
-
-        if count1 == 0 || count2 == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "COVARIANCE.P requires at least one numeric value in each array".to_string(),
-            );
-        }
-
-        if count1 != count2 {
-            return CalcResult::new_error(
-                Error::NA,
-                cell,
-                "COVARIANCE.P arrays must have the same number of numeric data points".to_string(),
-            );
-        }
-
-        // Build paired numeric vectors, position by position
-        let mut xs: Vec<f64> = Vec::with_capacity(count1);
-        let mut ys: Vec<f64> = Vec::with_capacity(count2);
-
-        for (v1_opt, v2_opt) in values1_opts.into_iter().zip(values2_opts.into_iter()) {
-            if let (Some(x), Some(y)) = (v1_opt, v2_opt) {
-                xs.push(x);
-                ys.push(y);
-            }
-        }
-
-        let n = xs.len();
-        if n == 0 {
-            // Should be impossible given the checks above, but guard anyway
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "COVARIANCE.P has no paired numeric data points".to_string(),
-            );
-        }
-
-        let n_f = n as f64;
-
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        for i in 0..n {
-            sum_x += xs[i];
-            sum_y += ys[i];
-        }
-        let mean_x = sum_x / n_f;
-        let mean_y = sum_y / n_f;
-
-        let mut sum_prod = 0.0;
-        for i in 0..n {
-            let dx = xs[i] - mean_x;
-            let dy = ys[i] - mean_y;
-            sum_prod += dx * dy;
-        }
-
-        let cov = sum_prod / n_f;
-        CalcResult::Number(cov)
-    }
-
-    pub(crate) fn fn_covariance_s(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values1_opts = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in first array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "First argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let values2_opts = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in second array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Second argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        // Same number of cells
-        if values1_opts.len() != values2_opts.len() {
-            return CalcResult::new_error(
-                Error::NA,
-                cell,
-                "COVARIANCE.S requires arrays of the same size".to_string(),
-            );
-        }
-
-        // Count numeric data points in each array (ignoring text/booleans/empty)
-        let count1 = values1_opts.iter().filter(|v| v.is_some()).count();
-        let count2 = values2_opts.iter().filter(|v| v.is_some()).count();
-
-        if count1 == 0 || count2 == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "COVARIANCE.S requires numeric values in each array".to_string(),
-            );
-        }
-
-        if count1 != count2 {
-            return CalcResult::new_error(
-                Error::NA,
-                cell,
-                "COVARIANCE.S arrays must have the same number of numeric data points".to_string(),
-            );
-        }
-
-        // Build paired numeric vectors
-        let mut xs: Vec<f64> = Vec::with_capacity(count1);
-        let mut ys: Vec<f64> = Vec::with_capacity(count2);
-
-        for (v1_opt, v2_opt) in values1_opts.into_iter().zip(values2_opts.into_iter()) {
-            if let (Some(x), Some(y)) = (v1_opt, v2_opt) {
-                xs.push(x);
-                ys.push(y);
-            }
-        }
-
-        let n = xs.len();
-        if n < 2 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "COVARIANCE.S requires at least two paired data points".to_string(),
-            );
-        }
-
-        let n_f = n as f64;
-
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        for i in 0..n {
-            sum_x += xs[i];
-            sum_y += ys[i];
-        }
-        let mean_x = sum_x / n_f;
-        let mean_y = sum_y / n_f;
-
-        let mut sum_prod = 0.0;
-        for i in 0..n {
-            let dx = xs[i] - mean_x;
-            let dy = ys[i] - mean_y;
-            sum_prod += dx * dy;
-        }
-
-        let cov = sum_prod / (n_f - 1.0);
-
-        CalcResult::Number(cov)
-    }
-}

base/src/functions/statistical/devsq.rs

@@ -1,135 +0,0 @@
-use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::ArrayNode;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // DEVSQ(number1, [number2], ...)
-    pub(crate) fn fn_devsq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        // tiny helper so we don't repeat ourselves
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // We ignore booleans and strings
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // We ignore booleans and strings
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // We ignore booleans and strings
-                }
-            };
-        }
-
-        if count == 0 {
-            // No numeric data at all
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "DEVSQ with no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut result = sumsq - (sum * sum) / n;
-
-        // Numerical noise can make result slightly negative when it should be 0
-        if result < 0.0 && result > -1e-12 {
-            result = 0.0;
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/exponential.rs

@@ -1,54 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_expon_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // EXPON.DIST(x, lambda, cumulative)
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let lambda = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[2], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if x < 0.0 || lambda <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for EXPON.DIST".to_string(),
-            };
-        }
-
-        let result = if cumulative {
-            // CDF
-            1.0 - (-lambda * x).exp()
-        } else {
-            // PDF
-            lambda * (-lambda * x).exp()
-        };
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for EXPON.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/fisher.rs

@@ -1,418 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, FisherSnedecor};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::functions::statistical::t_dist::sample_var;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // FISHER(x) = 0.5 * ln((1 + x) / (1 - x))
-    pub(crate) fn fn_fisher(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if x <= -1.0 || x >= 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "x must be between -1 and 1 (exclusive) in FISHER".to_string(),
-            };
-        }
-
-        let ratio = (1.0 + x) / (1.0 - x);
-        let result = 0.5 * ratio.ln();
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for FISHER".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // FISHERINV(y) = (e^(2y) - 1) / (e^(2y) + 1) = tanh(y)
-    pub(crate) fn fn_fisher_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let y = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // Use tanh directly to avoid overflow from exp(2y)
-        let result = y.tanh();
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for FISHERINV".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // F.DIST(x, deg_freedom1, deg_freedom2, cumulative)
-    pub(crate) fn fn_f_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df1 = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let df2 = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        // Excel domain checks
-        if x < 0.0 {
-            return CalcResult::new_error(Error::NUM, cell, "x must be >= 0 in F.DIST".to_string());
-        }
-        if df1 < 1.0 || df2 < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in F.DIST".to_string(),
-            );
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution".to_string(),
-                )
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for F.DIST".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_f_dist_rt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // F.DIST.RT(x, deg_freedom1, deg_freedom2)
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df1 = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let df2 = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "x must be >= 0 in F.DIST.RT".to_string(),
-            );
-        }
-        if df1 < 1.0 || df2 < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in F.DIST.RT".to_string(),
-            );
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution".to_string(),
-                )
-            }
-        };
-
-        // Right-tail probability: P(F > x) = 1 - CDF(x)
-        let result = 1.0 - dist.cdf(x);
-
-        if result.is_nan() || result.is_infinite() || result < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for F.DIST.RT".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // F.INV(probability, deg_freedom1, deg_freedom2)
-    pub(crate) fn fn_f_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let df1 = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let df2 = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // probability < 0 or > 1 → #NUM!
-        if !(0.0..=1.0).contains(&p) {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in [0,1] in F.INV".to_string(),
-            );
-        }
-        if df1 < 1.0 || df2 < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in F.INV".to_string(),
-            );
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution".to_string(),
-                )
-            }
-        };
-
-        let x = dist.inverse_cdf(p);
-        if x.is_nan() || x.is_infinite() || x < 0.0 {
-            return CalcResult::new_error(Error::NUM, cell, "Invalid result for F.INV".to_string());
-        }
-
-        CalcResult::Number(x)
-    }
-
-    // F.INV.RT(probability, deg_freedom1, deg_freedom2)
-    pub(crate) fn fn_f_inv_rt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let df1 = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-        let df2 = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if p <= 0.0 || p > 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in (0,1] in F.INV.RT".to_string(),
-            );
-        }
-        if df1 < 1.0 || df2 < 1.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "degrees of freedom must be >= 1 in F.INV.RT".to_string(),
-            );
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution".to_string(),
-                )
-            }
-        };
-
-        // p is right-tail: p = P(F > x) = 1 - CDF(x)
-        let x = dist.inverse_cdf(1.0 - p);
-        if x.is_nan() || x.is_infinite() || x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for F.INV.RT".to_string(),
-            );
-        }
-
-        CalcResult::Number(x)
-    }
-
-    // F.TEST(array1, array2)
-    pub(crate) fn fn_f_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values1_opts = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in first array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "First argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        // Get second sample as Vec<Option<f64>>
-        let values2_opts = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in second array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Second argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let values1: Vec<f64> = values1_opts.into_iter().flatten().collect();
-        let values2: Vec<f64> = values2_opts.into_iter().flatten().collect();
-
-        let n1 = values1.len();
-        let n2 = values2.len();
-
-        // If fewer than 2 numeric values in either sample -> #DIV/0!
-        if n1 < 2 || n2 < 2 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "F.TEST requires at least two numeric values in each sample".to_string(),
-            );
-        }
-
-        let v1 = sample_var(&values1);
-        let v2 = sample_var(&values2);
-
-        if v1 <= 0.0 || v2 <= 0.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Variance of one sample is zero in F.TEST".to_string(),
-            );
-        }
-
-        // F ratio: larger variance / smaller variance
-        let mut f = v1 / v2;
-        let mut df1 = (n1 - 1) as f64;
-        let mut df2 = (n2 - 1) as f64;
-
-        if f < 1.0 {
-            f = 1.0 / f;
-            std::mem::swap(&mut df1, &mut df2);
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution in F.TEST".to_string(),
-                );
-            }
-        };
-
-        // One-tailed right-tail probability
-        let tail = 1.0 - dist.cdf(f);
-        // F.TEST is two-tailed: p = 2 * tail (with F >= 1)
-        let mut p = 2.0 * tail;
-
-        // Clamp tiny FP noise
-        if p < 0.0 && p > -1e-15 {
-            p = 0.0;
-        }
-        if p > 1.0 && p < 1.0 + 1e-15 {
-            p = 1.0;
-        }
-
-        CalcResult::Number(p)
-    }
-}

base/src/functions/statistical/gamma.rs

@@ -1,194 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, Gamma};
-use statrs::function::gamma::{gamma, ln_gamma};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_gamma(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        if x < 0.0 && x.floor() == x {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for Gamma function".to_string(),
-            };
-        }
-        let result = gamma(x);
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for Gamma function".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_gamma_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // GAMMA.DIST(x, alpha, beta, cumulative)
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let alpha = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let beta_scale = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "x must be >= 0 in GAMMA.DIST".to_string(),
-            );
-        }
-        if alpha <= 0.0 || beta_scale <= 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "alpha and beta must be > 0 in GAMMA.DIST".to_string(),
-            );
-        }
-
-        let rate = 1.0 / beta_scale;
-
-        let dist = match Gamma::new(alpha, rate) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Gamma distribution".to_string(),
-                )
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for GAMMA.DIST".to_string(),
-            );
-        }
-
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_gamma_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // GAMMA.INV(probability, alpha, beta)
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let alpha = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let beta_scale = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if !(0.0..=1.0).contains(&p) {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "probability must be in [0,1] in GAMMA.INV".to_string(),
-            );
-        }
-
-        if alpha <= 0.0 || beta_scale <= 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "alpha and beta must be > 0 in GAMMA.INV".to_string(),
-            );
-        }
-
-        let rate = 1.0 / beta_scale;
-
-        let dist = match Gamma::new(alpha, rate) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Gamma distribution".to_string(),
-                )
-            }
-        };
-
-        let x = dist.inverse_cdf(p);
-        if x.is_nan() || x.is_infinite() || x < 0.0 {
-            return CalcResult::new_error(
-                Error::NUM,
-                cell,
-                "Invalid result for GAMMA.INV".to_string(),
-            );
-        }
-
-        CalcResult::Number(x)
-    }
-
-    pub(crate) fn fn_gamma_ln(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        if x < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for Gamma function".to_string(),
-            };
-        }
-        let result = ln_gamma(x);
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for Gamma Ln function".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_gamma_ln_precise(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        self.fn_gamma_ln(args, cell)
-    }
-}

base/src/functions/statistical/gauss.rs

@@ -1,39 +0,0 @@
-use statrs::distribution::{ContinuousCDF, Normal};
-
-use crate::expressions::token::Error;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
-
-impl Model {
-    pub(crate) fn fn_gauss(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let z = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let dist = match Normal::new(0.0, 1.0) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::ERROR,
-                    origin: cell,
-                    message: "Failed to construct standard normal distribution".to_string(),
-                }
-            }
-        };
-
-        let result = dist.cdf(z) - 0.5;
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for GAUSS".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/geomean.rs

@@ -1,87 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let mut count = 0.0;
-        let mut product = 1.0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    count += 1.0;
-                    product *= value;
-                }
-                CalcResult::Boolean(b) => {
-                    if let Node::ReferenceKind { .. } = arg {
-                    } else {
-                        product *= if b { 1.0 } else { 0.0 };
-                        count += 1.0;
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    count += 1.0;
-                                    product *= value;
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {
-                                    return CalcResult::new_error(
-                                        Error::ERROR,
-                                        cell,
-                                        "Unexpected Range".to_string(),
-                                    );
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                CalcResult::String(s) => {
-                    if let Node::ReferenceKind { .. } = arg {
-                        // Do nothing
-                    } else if let Ok(t) = s.parse::<f64>() {
-                        product *= t;
-                        count += 1.0;
-                    } else {
-                        return CalcResult::Error {
-                            error: Error::VALUE,
-                            origin: cell,
-                            message: "Argument cannot be cast into number".to_string(),
-                        };
-                    }
-                }
-                _ => {
-                    // Ignore everything else
-                }
-            };
-        }
-        if count == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Division by Zero".to_string(),
-            };
-        }
-        CalcResult::Number(product.powf(1.0 / count))
-    }
-}

base/src/functions/statistical/hypegeom.rs

@@ -1,108 +0,0 @@
-use statrs::distribution::{Discrete, DiscreteCDF, Hypergeometric};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // =HYPGEOM.DIST(sample_s, number_sample, population_s, number_pop, cumulative)
-    pub(crate) fn fn_hyp_geom_dist(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 5 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // sample_s (number of successes in the sample)
-        let sample_s = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // number_sample (sample size)
-        let number_sample = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // population_s (number of successes in the population)
-        let population_s = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // number_pop (population size)
-        let number_pop = match self.get_number_no_bools(&args[3], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[4], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if sample_s < 0.0 || sample_s > f64::min(number_sample, population_s) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
-            };
-        }
-
-        if sample_s < f64::max(0.0, number_sample + population_s - number_pop) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
-            };
-        }
-
-        if number_sample <= 0.0 || number_sample > number_pop {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
-            };
-        }
-
-        if population_s <= 0.0 || population_s > number_pop {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for HYPGEOM.DIST".to_string(),
-            };
-        }
-
-        let n_pop = number_pop as u64;
-        let k_pop = population_s as u64;
-        let n_sample = number_sample as u64;
-        let k = sample_s as u64;
-
-        let dist = match Hypergeometric::new(n_pop, k_pop, n_sample) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for hypergeometric distribution".to_string(),
-                )
-            }
-        };
-
-        let prob = if cumulative { dist.cdf(k) } else { dist.pmf(k) };
-
-        if !prob.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for HYPGEOM.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(prob)
-    }
-}

base/src/functions/statistical/if_ifs.rs

@@ -1,337 +0,0 @@
-use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::types::CellReferenceIndex;
-use crate::functions::util::build_criteria;
-use crate::{
-    calc_result::{CalcResult, Range},
-    expressions::parser::Node,
-    expressions::token::Error,
-    model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_countif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() == 2 {
-            let arguments = vec![args[0].clone(), args[1].clone()];
-            self.fn_countifs(&arguments, cell)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
-    /// AVERAGEIF(criteria_range, criteria, [average_range])
-    /// if average_rage is missing then criteria_range will be used
-    pub(crate) fn fn_averageif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() == 2 {
-            let arguments = vec![args[0].clone(), args[0].clone(), args[1].clone()];
-            self.fn_averageifs(&arguments, cell)
-        } else if args.len() == 3 {
-            let arguments = vec![args[2].clone(), args[0].clone(), args[1].clone()];
-            self.fn_averageifs(&arguments, cell)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
-    // 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.is_multiple_of(2) {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let case_count = args_count / 2;
-        // NB: this is a beautiful example of the borrow checker
-        // The order of these two definitions cannot be swapped.
-        let mut criteria = Vec::new();
-        let mut fn_criteria = Vec::new();
-        let ranges = &mut Vec::new();
-        for case_index in 0..case_count {
-            let criterion = self.evaluate_node_in_context(&args[case_index * 2 + 1], cell);
-            criteria.push(criterion);
-            // NB: We cannot do:
-            // fn_criteria.push(build_criteria(&criterion));
-            // because criterion doesn't live long enough
-            let result = self.evaluate_node_in_context(&args[case_index * 2], cell);
-            if result.is_error() {
-                return result;
-            }
-            if let CalcResult::Range { left, right } = result {
-                if left.sheet != right.sheet {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Ranges are in different sheets".to_string(),
-                    );
-                }
-                // TODO test ranges are of the same size as sum_range
-                ranges.push(Range { left, right });
-            } else {
-                return CalcResult::new_error(Error::VALUE, cell, "Expected a range".to_string());
-            }
-        }
-        for criterion in criteria.iter() {
-            fn_criteria.push(build_criteria(criterion));
-        }
-
-        let mut total = 0.0;
-        let first_range = &ranges[0];
-        let left_row = first_range.left.row;
-        let left_column = first_range.left.column;
-        let right_row = first_range.right.row;
-        let right_column = first_range.right.column;
-
-        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
-            Ok(s) => s.dimension(),
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::ERROR,
-                    cell,
-                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
-                )
-            }
-        };
-        let max_row = dimension.max_row;
-        let max_column = dimension.max_column;
-
-        let open_row = left_row == 1 && right_row == LAST_ROW;
-        let open_column = left_column == 1 && right_column == LAST_COLUMN;
-
-        for row in left_row..right_row + 1 {
-            if open_row && row > max_row {
-                // If the row is larger than the max row in the sheet then all cells are empty.
-                // We compute it only once
-                let mut is_true = true;
-                for fn_criterion in fn_criteria.iter() {
-                    if !fn_criterion(&CalcResult::EmptyCell) {
-                        is_true = false;
-                        break;
-                    }
-                }
-                if is_true {
-                    total += ((LAST_ROW - max_row) * (right_column - left_column + 1)) as f64;
-                }
-                break;
-            }
-            for column in left_column..right_column + 1 {
-                if open_column && column > max_column {
-                    // If the column is larger than the max column in the sheet then all cells are empty.
-                    // We compute it only once
-                    let mut is_true = true;
-                    for fn_criterion in fn_criteria.iter() {
-                        if !fn_criterion(&CalcResult::EmptyCell) {
-                            is_true = false;
-                            break;
-                        }
-                    }
-                    if is_true {
-                        total += (LAST_COLUMN - max_column) as f64;
-                    }
-                    break;
-                }
-                let mut is_true = true;
-                for case_index in 0..case_count {
-                    // We check if value in range n meets criterion n
-                    let range = &ranges[case_index];
-                    let fn_criterion = &fn_criteria[case_index];
-                    let value = self.evaluate_cell(CellReferenceIndex {
-                        sheet: range.left.sheet,
-                        row: range.left.row + row - first_range.left.row,
-                        column: range.left.column + column - first_range.left.column,
-                    });
-                    if !fn_criterion(&value) {
-                        is_true = false;
-                        break;
-                    }
-                }
-                if is_true {
-                    total += 1.0;
-                }
-            }
-        }
-        CalcResult::Number(total)
-    }
-
-    pub(crate) fn apply_ifs<F>(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-        mut apply: F,
-    ) -> Result<(), CalcResult>
-    where
-        F: FnMut(f64),
-    {
-        let args_count = args.len();
-        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);
-        if arg_0.is_error() {
-            return Err(arg_0);
-        }
-        let sum_range = if let CalcResult::Range { left, right } = arg_0 {
-            if left.sheet != right.sheet {
-                return Err(CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Ranges are in different sheets".to_string(),
-                ));
-            }
-            Range { left, right }
-        } else {
-            return Err(CalcResult::new_error(
-                Error::VALUE,
-                cell,
-                "Expected a range".to_string(),
-            ));
-        };
-
-        let case_count = (args_count - 1) / 2;
-        // NB: this is a beautiful example of the borrow checker
-        // The order of these two definitions cannot be swapped.
-        let mut criteria = Vec::new();
-        let mut fn_criteria = Vec::new();
-        let ranges = &mut Vec::new();
-        for case_index in 1..=case_count {
-            let criterion = self.evaluate_node_in_context(&args[case_index * 2], cell);
-            // NB: criterion might be an error. That's ok
-            criteria.push(criterion);
-            // NB: We cannot do:
-            // fn_criteria.push(build_criteria(&criterion));
-            // because criterion doesn't live long enough
-            let result = self.evaluate_node_in_context(&args[case_index * 2 - 1], cell);
-            if result.is_error() {
-                return Err(result);
-            }
-            if let CalcResult::Range { left, right } = result {
-                if left.sheet != right.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                // TODO test ranges are of the same size as sum_range
-                ranges.push(Range { left, right });
-            } else {
-                return Err(CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Expected a range".to_string(),
-                ));
-            }
-        }
-        for criterion in criteria.iter() {
-            fn_criteria.push(build_criteria(criterion));
-        }
-
-        let left_row = sum_range.left.row;
-        let left_column = sum_range.left.column;
-        let mut right_row = sum_range.right.row;
-        let mut right_column = sum_range.right.column;
-
-        if left_row == 1 && right_row == LAST_ROW {
-            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
-                Ok(s) => s.dimension().max_row,
-                Err(_) => {
-                    return Err(CalcResult::new_error(
-                        Error::ERROR,
-                        cell,
-                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
-                    ));
-                }
-            };
-        }
-        if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
-                Ok(s) => s.dimension().max_column,
-                Err(_) => {
-                    return Err(CalcResult::new_error(
-                        Error::ERROR,
-                        cell,
-                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
-                    ));
-                }
-            };
-        }
-
-        for row in left_row..right_row + 1 {
-            for column in left_column..right_column + 1 {
-                let mut is_true = true;
-                for case_index in 0..case_count {
-                    // We check if value in range n meets criterion n
-                    let range = &ranges[case_index];
-                    let fn_criterion = &fn_criteria[case_index];
-                    let value = self.evaluate_cell(CellReferenceIndex {
-                        sheet: range.left.sheet,
-                        row: range.left.row + row - sum_range.left.row,
-                        column: range.left.column + column - sum_range.left.column,
-                    });
-                    if !fn_criterion(&value) {
-                        is_true = false;
-                        break;
-                    }
-                }
-                if is_true {
-                    let v = self.evaluate_cell(CellReferenceIndex {
-                        sheet: sum_range.left.sheet,
-                        row,
-                        column,
-                    });
-                    match v {
-                        CalcResult::Number(n) => apply(n),
-                        CalcResult::Error { .. } => return Err(v),
-                        _ => {}
-                    }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub(crate) fn fn_averageifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut total = 0.0;
-        let mut count = 0.0;
-
-        let average = |value: f64| {
-            total += value;
-            count += 1.0;
-        };
-        if let Err(e) = self.apply_ifs(args, cell, average) {
-            return e;
-        }
-
-        if count == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "division by 0".to_string(),
-            };
-        }
-        CalcResult::Number(total / count)
-    }
-
-    pub(crate) fn fn_minifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut min = f64::INFINITY;
-        let apply_min = |value: f64| min = value.min(min);
-        if let Err(e) = self.apply_ifs(args, cell, apply_min) {
-            return e;
-        }
-
-        if min.is_infinite() {
-            min = 0.0;
-        }
-        CalcResult::Number(min)
-    }
-
-    pub(crate) fn fn_maxifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut max = -f64::INFINITY;
-        let apply_max = |value: f64| max = value.max(max);
-        if let Err(e) = self.apply_ifs(args, cell, apply_max) {
-            return e;
-        }
-        if max.is_infinite() {
-            max = 0.0;
-        }
-        CalcResult::Number(max)
-    }
-}

base/src/functions/statistical/log_normal.rs

@@ -1,124 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, LogNormal};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_log_norm_dist(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let mean = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        // Excel domain checks
-        if x <= 0.0 || std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for LOGNORM.DIST".to_string(),
-            };
-        }
-
-        let dist = match LogNormal::new(mean, std_dev) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameter for LOGNORM.DIST".to_string(),
-                }
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for LOGNORM.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_log_norm_inv(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        use statrs::distribution::{ContinuousCDF, LogNormal};
-
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let mean = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // Excel domain checks
-        if p <= 0.0 || p >= 1.0 || std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for LOGNORM.INV".to_string(),
-            };
-        }
-
-        let dist = match LogNormal::new(mean, std_dev) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameter for LOGNORM.INV".to_string(),
-                }
-            }
-        };
-
-        let result = dist.inverse_cdf(p);
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameter for LOGNORM.INV".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/mod.rs

@@ -1,26 +0,0 @@
-mod beta;
-mod binom;
-mod chisq;
-mod correl;
-mod count_and_average;
-mod covariance;
-mod devsq;
-mod exponential;
-mod fisher;
-mod gamma;
-mod gauss;
-mod geomean;
-mod hypegeom;
-mod if_ifs;
-mod log_normal;
-mod normal;
-mod pearson;
-mod phi;
-mod poisson;
-mod rank_eq_avg;
-mod standard_dev;
-mod standardize;
-mod t_dist;
-mod variance;
-mod weibull;
-mod z_test;

base/src/functions/statistical/normal.rs

@@ -1,325 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, Normal, StudentsT};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // NORM.DIST(x, mean, standard_dev, cumulative)
-    pub(crate) fn fn_norm_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let mean = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        // Excel: standard_dev must be > 0
-        if std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "standard_dev must be > 0 in NORM.DIST".to_string(),
-            };
-        }
-
-        let dist = match Normal::new(mean, std_dev) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for NORM.DIST".to_string(),
-                }
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for NORM.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // NORM.INV(probability, mean, standard_dev)
-    pub(crate) fn fn_norm_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let mean = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if p <= 0.0 || p >= 1.0 || std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for NORM.INV".to_string(),
-            };
-        }
-
-        let dist = match Normal::new(mean, std_dev) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for NORM.INV".to_string(),
-                }
-            }
-        };
-
-        let x = dist.inverse_cdf(p);
-
-        if !x.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for NORM.INV".to_string(),
-            };
-        }
-
-        CalcResult::Number(x)
-    }
-
-    // NORM.S.DIST(z, cumulative)
-    pub(crate) fn fn_norm_s_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let z = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let cumulative = match self.get_boolean(&args[1], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        let dist = match Normal::new(0.0, 1.0) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::ERROR,
-                    origin: cell,
-                    message: "Failed to construct standard normal distribution".to_string(),
-                }
-            }
-        };
-
-        let result = if cumulative { dist.cdf(z) } else { dist.pdf(z) };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for NORM.S.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // NORM.S.INV(probability)
-    pub(crate) fn fn_norm_s_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if p <= 0.0 || p >= 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "probability must be in (0,1) in NORM.S.INV".to_string(),
-            };
-        }
-
-        let dist = match Normal::new(0.0, 1.0) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::ERROR,
-                    origin: cell,
-                    message: "Failed to construct standard normal distribution".to_string(),
-                }
-            }
-        };
-
-        let z = dist.inverse_cdf(p);
-
-        if !z.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for NORM.S.INV".to_string(),
-            };
-        }
-
-        CalcResult::Number(z)
-    }
-
-    pub(crate) fn fn_confidence_norm(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let alpha = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let size = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.floor(),
-            Err(e) => return e,
-        };
-
-        if alpha <= 0.0 || alpha >= 1.0 || std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for CONFIDENCE.NORM".to_string(),
-            };
-        }
-        if size < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Sample size must be at least 1".to_string(),
-            };
-        }
-
-        let normal = match Normal::new(0.0, 1.0) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::ERROR,
-                    cell,
-                    "Failed to construct normal distribution".to_string(),
-                )
-            }
-        };
-
-        let quantile = normal.inverse_cdf(1.0 - alpha / 2.0);
-        if !quantile.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid quantile for CONFIDENCE.NORM".to_string(),
-            };
-        }
-
-        let margin = quantile * std_dev / size.sqrt();
-        CalcResult::Number(margin)
-    }
-
-    pub(crate) fn fn_confidence_t(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let alpha = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let size = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // Domain checks
-        if alpha <= 0.0 || alpha >= 1.0 || std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for CONFIDENCE.T".to_string(),
-            };
-        }
-
-        // Need at least 2 observations so df = n - 1 > 0
-        if size < 2.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Sample size must be at least 2".to_string(),
-            };
-        }
-
-        let df = size - 1.0;
-
-        let t_dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::ERROR,
-                    cell,
-                    "Failed to construct Student's t distribution".to_string(),
-                )
-            }
-        };
-
-        // Two-sided CI => use 1 - alpha/2
-        let t_crit = t_dist.inverse_cdf(1.0 - alpha / 2.0);
-        if !t_crit.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid quantile for CONFIDENCE.T".to_string(),
-            };
-        }
-
-        let margin = t_crit * std_dev / size.sqrt();
-        CalcResult::Number(margin)
-    }
-}

base/src/functions/statistical/pearson.rs

@@ -1,113 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // PEARSON(array1, array2)
-    pub(crate) fn fn_pearson(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) {
-            Ok(result) => result,
-            Err(e) => return e,
-        };
-
-        // Flatten into (x, y) pairs, skipping non-numeric entries (None)
-        let mut n: f64 = 0.0;
-        let mut sum_x = 0.0;
-        let mut sum_y = 0.0;
-        let mut sum_x2 = 0.0;
-        let mut sum_y2 = 0.0;
-        let mut sum_xy = 0.0;
-
-        let len = values_left.len().min(values_right.len());
-        for i in 0..len {
-            match (values_left[i], values_right[i]) {
-                (Some(x), Some(y)) => {
-                    n += 1.0;
-                    sum_x += x;
-                    sum_y += y;
-                    sum_x2 += x * x;
-                    sum_y2 += y * y;
-                    sum_xy += x * y;
-                }
-                _ => {
-                    // Ignore pairs where at least one side is non-numeric
-                }
-            }
-        }
-
-        if n < 2.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "PEARSON requires at least two numeric pairs".to_string(),
-            );
-        }
-
-        // Pearson correlation:
-        // r = [ n*Σxy - (Σx)(Σy) ] / sqrt( [n*Σx² - (Σx)²] [n*Σy² - (Σy)²] )
-        let num = n * sum_xy - sum_x * sum_y;
-        let denom_x = n * sum_x2 - sum_x * sum_x;
-        let denom_y = n * sum_y2 - sum_y * sum_y;
-
-        if denom_x.abs() < 1e-15 || denom_y.abs() < 1e-15 {
-            // Zero variance in at least one series
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "PEARSON cannot be computed when one series has zero variance".to_string(),
-            );
-        }
-
-        let denom = (denom_x * denom_y).sqrt();
-
-        CalcResult::Number(num / denom)
-    }
-
-    // RSQ(array1, array2) = CORREL(array1, array2)^2
-    pub(crate) fn fn_rsq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (_rows, _cols, values1, values2) = match self.fn_get_two_matrices(args, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-
-        let mut n = 0.0_f64;
-        let mut sum_x = 0.0_f64;
-        let mut sum_y = 0.0_f64;
-        let mut sum_x2 = 0.0_f64;
-        let mut sum_y2 = 0.0_f64;
-        let mut sum_xy = 0.0_f64;
-
-        let len = values1.len().min(values2.len());
-        for i in 0..len {
-            if let (Some(x), Some(y)) = (values1[i], values2[i]) {
-                n += 1.0;
-                sum_x += x;
-                sum_y += y;
-                sum_x2 += x * x;
-                sum_y2 += y * y;
-                sum_xy += x * y;
-            }
-        }
-
-        if n < 2.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "RSQ requires at least two numeric data points in each range".to_string(),
-            );
-        }
-
-        let num = n * sum_xy - sum_x * sum_y;
-        let denom_x = n * sum_x2 - sum_x * sum_x;
-        let denom_y = n * sum_y2 - sum_y * sum_y;
-        let denom = (denom_x * denom_y).sqrt();
-
-        if denom == 0.0 || !denom.is_finite() {
-            return CalcResult::new_error(Error::DIV, cell, "Division by zero in RSQ".to_string());
-        }
-
-        let r = num / denom;
-        CalcResult::Number(r * r)
-    }
-}

base/src/functions/statistical/phi.rs

@@ -1,21 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
-
-impl Model {
-    // PHI(x) = standard normal PDF at x
-    pub(crate) fn fn_phi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // Standard normal PDF: (1 / sqrt(2π)) * exp(-x^2 / 2)
-        let result = (-(x * x) / 2.0).exp() / (2.0 * std::f64::consts::PI).sqrt();
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/poisson.rs

@@ -1,94 +0,0 @@
-use statrs::distribution::{Discrete, DiscreteCDF, Poisson};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // =POISSON.DIST(x, mean, cumulative)
-    pub(crate) fn fn_poisson_dist(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // x
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        // mean (lambda)
-        let lambda = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[2], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if x < 0.0 || lambda < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for POISSON.DIST".to_string(),
-            };
-        }
-
-        // Guard against insane k for u64
-        if x < 0.0 || x > (u64::MAX as f64) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for POISSON.DIST".to_string(),
-            };
-        }
-
-        let k = x as u64;
-
-        // Special-case lambda = 0: degenerate distribution at 0
-        if lambda == 0.0 {
-            let result = if cumulative {
-                // For x >= 0, P(X <= x) = 1
-                1.0
-            } else {
-                // P(X = 0) = 1, P(X = k>0) = 0
-                if k == 0 {
-                    1.0
-                } else {
-                    0.0
-                }
-            };
-            return CalcResult::Number(result);
-        }
-
-        let dist = match Poisson::new(lambda) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for POISSON.DIST".to_string(),
-                }
-            }
-        };
-
-        let prob = if cumulative { dist.cdf(k) } else { dist.pmf(k) };
-
-        if !prob.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for POISSON.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(prob)
-    }
-}

base/src/functions/statistical/rank_eq_avg.rs

@@ -1,202 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // Helper to collect numeric values from the 2nd argument of RANK.*
-    fn collect_rank_values(
-        &mut self,
-        arg: &Node,
-        cell: CellReferenceIndex,
-    ) -> Result<Vec<f64>, CalcResult> {
-        let values = match self.evaluate_node_in_context(arg, cell) {
-            CalcResult::Array(array) => match self.values_from_array(array) {
-                Ok(v) => v,
-                Err(e) => {
-                    return Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: format!("Unsupported array argument: {}", e),
-                    })
-                }
-            },
-            CalcResult::Range { left, right } => self.values_from_range(left, right)?,
-            CalcResult::Boolean(value) => {
-                if !matches!(arg, Node::ReferenceKind { .. }) {
-                    vec![Some(if value { 1.0 } else { 0.0 })]
-                } else {
-                    return Err(CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    });
-                }
-            }
-            _ => {
-                return Err(CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Unsupported argument type".to_string(),
-                })
-            }
-        };
-
-        let numeric_values: Vec<f64> = values.into_iter().flatten().collect();
-        Ok(numeric_values)
-    }
-
-    // RANK.EQ(number, ref, [order])
-    pub(crate) fn fn_rank_eq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if !(2..=3).contains(&args.len()) {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // number
-        let number = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // ref
-        let mut values = match self.collect_rank_values(&args[1], cell) {
-            Ok(v) => v,
-            Err(e) => return e,
-        };
-
-        if values.is_empty() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "No numeric values for RANK.EQ".to_string(),
-            };
-        }
-
-        // order: default 0 (descending)
-        let order = if args.len() == 2 {
-            0.0
-        } else {
-            match self.get_number_no_bools(&args[2], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        };
-
-        values.retain(|v| !v.is_nan());
-
-        // "better" = greater (descending) or smaller (ascending)
-        let mut better = 0;
-        let mut equal = 0;
-
-        if order == 0.0 {
-            // descending
-            for v in &values {
-                if *v > number {
-                    better += 1;
-                } else if *v == number {
-                    equal += 1;
-                }
-            }
-        } else {
-            // ascending
-            for v in &values {
-                if *v < number {
-                    better += 1;
-                } else if *v == number {
-                    equal += 1;
-                }
-            }
-        }
-
-        if equal == 0 {
-            return CalcResult::Error {
-                error: Error::NA,
-                origin: cell,
-                message: "Number not found in reference for RANK.EQ".to_string(),
-            };
-        }
-
-        let rank = (better as f64) + 1.0;
-        CalcResult::Number(rank)
-    }
-
-    // RANK.AVG(number, ref, [order])
-    pub(crate) fn fn_rank_avg(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if !(2..=3).contains(&args.len()) {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        // number
-        let number = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        // ref
-        let mut values = match self.collect_rank_values(&args[1], cell) {
-            Ok(v) => v,
-            Err(e) => return e,
-        };
-
-        if values.is_empty() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "No numeric values for RANK.AVG".to_string(),
-            };
-        }
-
-        // order: default 0 (descending)
-        let order = if args.len() == 2 {
-            0.0
-        } else {
-            match self.get_number_no_bools(&args[2], cell) {
-                Ok(f) => f,
-                Err(e) => return e,
-            }
-        };
-
-        values.retain(|v| !v.is_nan());
-
-        // > or < depending on order
-        let mut better = 0;
-        let mut equal = 0;
-
-        if order == 0.0 {
-            // descending
-            for v in &values {
-                if *v > number {
-                    better += 1;
-                } else if *v == number {
-                    equal += 1;
-                }
-            }
-        } else {
-            // ascending
-            for v in &values {
-                if *v < number {
-                    better += 1;
-                } else if *v == number {
-                    equal += 1;
-                }
-            }
-        }
-
-        if equal == 0 {
-            return CalcResult::Error {
-                error: Error::NA,
-                origin: cell,
-                message: "Number not found in reference for RANK.AVG".to_string(),
-            };
-        }
-
-        // For ties, average of the ranks. If the equal values occupy positions
-        // (better+1) ..= (better+equal), the average is:
-        // better + (equal + 1) / 2
-        let better_f = better as f64;
-        let equal_f = equal as f64;
-        let rank = better_f + (equal_f + 1.0) / 2.0;
-
-        CalcResult::Number(rank)
-    }
-}

base/src/functions/statistical/standard_dev.rs

@@ -1,519 +0,0 @@
-use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::ArrayNode;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_stdev_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric
-                }
-            }
-        }
-
-        if count == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STDEV.P with no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / n;
-
-        // clamp tiny negatives from FP noise
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var.sqrt())
-    }
-
-    pub(crate) fn fn_stdev_s(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric
-                }
-            }
-        }
-
-        if count <= 1 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STDEV.S requires at least two numeric values".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / (n - 1.0);
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var.sqrt())
-    }
-
-    pub(crate) fn fn_stdeva(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                CalcResult::String(_) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, 0.0);
-                                }
-                                CalcResult::Boolean(value) => {
-                                    let val = if value { 1.0 } else { 0.0 };
-                                    accumulate(&mut sum, &mut sumsq, &mut count, val);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric for now
-                }
-            }
-        }
-
-        if count <= 1 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STDEVA requires at least two numeric values".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / (n - 1.0);
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var.sqrt())
-    }
-
-    pub(crate) fn fn_stdevpa(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                CalcResult::String(_) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, 0.0);
-                                }
-                                CalcResult::Boolean(value) => {
-                                    let val = if value { 1.0 } else { 0.0 };
-                                    accumulate(&mut sum, &mut sumsq, &mut count, val);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric for now
-                }
-            }
-        }
-
-        if count == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "STDEVPA with no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / n;
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var.sqrt())
-    }
-}

base/src/functions/statistical/standardize.rs

@@ -1,38 +0,0 @@
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_standardize(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // STANDARDIZE(x, mean, standard_dev)
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let mean = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-        let std_dev = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        if std_dev <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "standard_dev must be > 0 in STANDARDIZE".to_string(),
-            };
-        }
-
-        let z = (x - mean) / std_dev;
-
-        CalcResult::Number(z)
-    }
-}

base/src/functions/statistical/t_dist.rs

@@ -1,588 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, StudentsT};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-fn mean(xs: &[f64]) -> f64 {
-    let n = xs.len();
-    if n == 0 {
-        return 0.0;
-    }
-    let mut s = 0.0;
-    for &x in xs {
-        s += x;
-    }
-    s / (n as f64)
-}
-
-pub(crate) fn sample_var(xs: &[f64]) -> f64 {
-    let n = xs.len();
-    if n < 2 {
-        return 0.0;
-    }
-    let m = mean(xs);
-    let mut s = 0.0;
-    for &x in xs {
-        let d = x - m;
-        s += d * d;
-    }
-    s / ((n - 1) as f64)
-}
-
-enum TTestType {
-    Paired,
-    TwoSampleEqualVar,
-    TwoSampleUnequalVar,
-}
-
-enum TTestTails {
-    OneTailed,
-    TwoTailed,
-}
-
-impl Model {
-    // T.DIST(x, deg_freedom, cumulative)
-    pub(crate) fn fn_t_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[2], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if df < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "deg_freedom must be >= 1 in T.DIST".to_string(),
-            };
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for T.DIST".to_string(),
-                }
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for T.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // T.DIST.2T(x, deg_freedom)
-    pub(crate) fn fn_t_dist_2t(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if x < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "x must be >= 0 in T.DIST.2T".to_string(),
-            };
-        }
-
-        if df < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "deg_freedom must be >= 1 in T.DIST.2T".to_string(),
-            };
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for T.DIST.2T".to_string(),
-                }
-            }
-        };
-
-        let upper_tail = 1.0 - dist.cdf(x);
-        let mut result = 2.0 * upper_tail;
-
-        result = result.clamp(0.0, 1.0);
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for T.DIST.2T".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // T.DIST.RT(x, deg_freedom)
-    pub(crate) fn fn_t_dist_rt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if df < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "deg_freedom must be >= 1 in T.DIST.RT".to_string(),
-            };
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for T.DIST.RT".to_string(),
-                }
-            }
-        };
-
-        let result = 1.0 - dist.cdf(x);
-
-        if !result.is_finite() || result < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for T.DIST.RT".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-
-    // T.INV(probability, deg_freedom)
-    pub(crate) fn fn_t_inv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if p <= 0.0 || p >= 1.0 || df < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for T.INV".to_string(),
-            };
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for T.INV".to_string(),
-                }
-            }
-        };
-
-        let x = dist.inverse_cdf(p);
-
-        if !x.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for T.INV".to_string(),
-            };
-        }
-
-        CalcResult::Number(x)
-    }
-
-    // T.INV.2T(probability, deg_freedom)
-    pub(crate) fn fn_t_inv_2t(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let p = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let df = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(e) => return e,
-        };
-
-        if p <= 0.0 || p > 1.0 || df < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for T.INV.2T".to_string(),
-            };
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for T.INV.2T".to_string(),
-                }
-            }
-        };
-
-        // Two-sided: F(x) = 1 - p/2
-        let target_cdf = 1.0 - p / 2.0;
-        let x = dist.inverse_cdf(target_cdf);
-
-        if !x.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for T.INV.2T".to_string(),
-            };
-        }
-
-        CalcResult::Number(x.abs())
-    }
-
-    // T.TEST(array1, array2, tails, type)
-    pub(crate) fn fn_t_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values1_opts = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in first array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "First argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let values2_opts = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in second array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Second argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let tails = match self.get_number(&args[2], cell) {
-            Ok(f) => {
-                let tf = f.trunc();
-                if tf == 1.0 {
-                    TTestTails::OneTailed
-                } else if tf == 2.0 {
-                    TTestTails::TwoTailed
-                } else {
-                    return CalcResult::new_error(
-                        Error::NUM,
-                        cell,
-                        "tails must be 1 or 2".to_string(),
-                    );
-                }
-            }
-            Err(e) => return e,
-        };
-        let test_type = match self.get_number(&args[3], cell) {
-            Ok(f) => {
-                let tf = f.trunc();
-                match tf {
-                    1.0 => TTestType::Paired,
-                    2.0 => TTestType::TwoSampleEqualVar,
-                    3.0 => TTestType::TwoSampleUnequalVar,
-                    _ => {
-                        return CalcResult::new_error(
-                            Error::NUM,
-                            cell,
-                            "type must be 1, 2, or 3".to_string(),
-                        );
-                    }
-                }
-            }
-            Err(e) => return e,
-        };
-
-        let (values1, values2): (Vec<f64>, Vec<f64>) = if matches!(test_type, TTestType::Paired) {
-            values1_opts
-                .into_iter()
-                .zip(values2_opts)
-                .filter_map(|(o1, o2)| match (o1, o2) {
-                    (Some(v1), Some(v2)) => Some((v1, v2)),
-                    _ => None, // skip if either is None
-                })
-                .unzip()
-        } else {
-            // keep only numeric entries, ignore non-numeric (Option::None)
-            let v1: Vec<f64> = values1_opts.into_iter().flatten().collect();
-            let v2: Vec<f64> = values2_opts.into_iter().flatten().collect();
-            (v1, v2)
-        };
-
-        let n1 = values1.len();
-        let n2 = values2.len();
-
-        if n1 == 0 || n2 == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "T.TEST requires non-empty samples".to_string(),
-            );
-        }
-
-        let (t_stat, df) = match test_type {
-            TTestType::Paired => {
-                if n1 != n2 {
-                    return CalcResult::new_error(
-                        Error::NA,
-                        cell,
-                        "For paired T.TEST, both samples must have the same length".to_string(),
-                    );
-                }
-                if n1 < 2 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Paired T.TEST requires at least two pairs".to_string(),
-                    );
-                }
-
-                let mut diffs = Vec::with_capacity(n1);
-                for i in 0..n1 {
-                    diffs.push(values1[i] - values2[i]);
-                }
-
-                let nd = diffs.len();
-                let md = mean(&diffs);
-                let vd = sample_var(&diffs);
-                if vd <= 0.0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Zero variance in paired T.TEST".to_string(),
-                    );
-                }
-                let sd = vd.sqrt();
-                let t_stat = md / (sd / (nd as f64).sqrt());
-                let df = (nd - 1) as f64;
-                (t_stat, df)
-            }
-
-            // 2: two-sample, equal variance (homoscedastic)
-            TTestType::TwoSampleEqualVar => {
-                if n1 < 2 || n2 < 2 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Two-sample T.TEST type 2 requires at least two values in each sample"
-                            .to_string(),
-                    );
-                }
-
-                let m1 = mean(&values1);
-                let m2 = mean(&values2);
-                let v1 = sample_var(&values1);
-                let v2 = sample_var(&values2);
-
-                let df_i = (n1 + n2 - 2) as i32;
-                if df_i <= 0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Degrees of freedom must be positive in T.TEST type 2".to_string(),
-                    );
-                }
-                let df = df_i as f64;
-
-                let sp2 = (((n1 - 1) as f64) * v1 + ((n2 - 1) as f64) * v2) / df; // pooled variance
-
-                if sp2 <= 0.0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Zero pooled variance in T.TEST type 2".to_string(),
-                    );
-                }
-
-                let denom = (sp2 * (1.0 / (n1 as f64) + 1.0 / (n2 as f64))).sqrt();
-                if denom == 0.0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Zero denominator in T.TEST type 2".to_string(),
-                    );
-                }
-
-                let t_stat = (m1 - m2) / denom;
-                (t_stat, df)
-            }
-
-            // two-sample, unequal variance (Welch)
-            TTestType::TwoSampleUnequalVar => {
-                if n1 < 2 || n2 < 2 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Two-sample T.TEST type 3 requires at least two values in each sample"
-                            .to_string(),
-                    );
-                }
-
-                let m1 = mean(&values1);
-                let m2 = mean(&values2);
-                let v1 = sample_var(&values1);
-                let v2 = sample_var(&values2);
-
-                let s1n = v1 / (n1 as f64);
-                let s2n = v2 / (n2 as f64);
-                let denom = (s1n + s2n).sqrt();
-                if denom == 0.0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Zero denominator in T.TEST type 3".to_string(),
-                    );
-                }
-
-                let t_stat = (m1 - m2) / denom;
-
-                let num_df = (s1n + s2n).powi(2);
-                let den_df = (s1n * s1n) / ((n1 - 1) as f64) + (s2n * s2n) / ((n2 - 1) as f64);
-                if den_df == 0.0 {
-                    return CalcResult::new_error(
-                        Error::DIV,
-                        cell,
-                        "Invalid degrees of freedom in T.TEST type 3".to_string(),
-                    );
-                }
-                let df = num_df / den_df;
-                (t_stat, df)
-            }
-        };
-
-        if df <= 0.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Degrees of freedom must be positive in T.TEST".to_string(),
-            );
-        }
-
-        let dist = match StudentsT::new(0.0, 1.0, df) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for Student's t distribution".to_string(),
-                );
-            }
-        };
-
-        let t_abs = t_stat.abs();
-        let cdf = dist.cdf(t_abs);
-
-        let mut p = match tails {
-            TTestTails::OneTailed => 1.0 - cdf,
-            TTestTails::TwoTailed => 2.0 * (1.0 - cdf),
-        };
-
-        // clamp tiny fp noise
-        if p < 0.0 && p > -1e-15 {
-            p = 0.0;
-        }
-        if p > 1.0 && p < 1.0 + 1e-15 {
-            p = 1.0;
-        }
-
-        CalcResult::Number(p)
-    }
-}

base/src/functions/statistical/variance.rs

@@ -1,518 +0,0 @@
-use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::ArrayNode;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    pub(crate) fn fn_var_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric
-                }
-            }
-        }
-
-        if count == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "VAR.P with no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / n;
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var)
-    }
-
-    pub(crate) fn fn_var_s(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric
-                }
-            }
-        }
-
-        if count <= 1 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "VAR.S requires at least two numeric values".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / (n - 1.0);
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var)
-    }
-
-    pub(crate) fn fn_vara(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..=row2 {
-                        for column in column1..=column2 {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                CalcResult::String(_) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, 0.0);
-                                }
-                                CalcResult::Boolean(value) => {
-                                    let val = if value { 1.0 } else { 0.0 };
-                                    accumulate(&mut sum, &mut sumsq, &mut count, val);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric for now (A semantics to be added)
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric for now (A semantics to be added)
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric for now (A semantics to be added)
-                }
-            }
-        }
-
-        if count <= 1 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "VARA requires at least two numeric values".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / (n - 1.0);
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var)
-    }
-
-    pub(crate) fn fn_varpa(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut sum = 0.0;
-        let mut sumsq = 0.0;
-        let mut count: u64 = 0;
-
-        #[inline]
-        fn accumulate(sum: &mut f64, sumsq: &mut f64, count: &mut u64, value: f64) {
-            *sum += value;
-            *sumsq += value * value;
-            *count += 1;
-        }
-
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-
-                    let row1 = left.row;
-                    let mut row2 = right.row;
-                    let column1 = left.column;
-                    let mut column2 = right.column;
-
-                    if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-                    if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
-                    }
-
-                    for row in row1..row2 + 1 {
-                        for column in column1..(column2 + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                CalcResult::String(_) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, 0.0);
-                                }
-                                CalcResult::Boolean(value) => {
-                                    let val = if value { 1.0 } else { 0.0 };
-                                    accumulate(&mut sum, &mut sumsq, &mut count, val);
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    accumulate(&mut sum, &mut sumsq, &mut count, value);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    }
-                                }
-                                _ => {
-                                    // ignore non-numeric for now
-                                }
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    // ignore non-numeric for now
-                }
-            }
-        }
-
-        if count == 0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "VARPA with no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mut var = (sumsq - (sum * sum) / n) / n;
-
-        if var < 0.0 && var > -1e-12 {
-            var = 0.0;
-        }
-
-        CalcResult::Number(var)
-    }
-}

base/src/functions/statistical/weibull.rs

@@ -1,71 +0,0 @@
-use statrs::distribution::{Continuous, ContinuousCDF, Weibull};
-
-use crate::expressions::types::CellReferenceIndex;
-use crate::{
-    calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
-};
-
-impl Model {
-    // WEIBULL.DIST(x, alpha, beta, cumulative)
-    pub(crate) fn fn_weibull_dist(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> CalcResult {
-        if args.len() != 4 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let x = match self.get_number_no_bools(&args[0], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let alpha = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let beta = match self.get_number_no_bools(&args[2], cell) {
-            Ok(f) => f,
-            Err(e) => return e,
-        };
-
-        let cumulative = match self.get_boolean(&args[3], cell) {
-            Ok(b) => b,
-            Err(e) => return e,
-        };
-
-        if x < 0.0 || alpha <= 0.0 || beta <= 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid parameters for WEIBULL.DIST".to_string(),
-            };
-        }
-
-        // statrs::Weibull: shape = k (alpha), scale = lambda (beta)
-        let dist = match Weibull::new(alpha, beta) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Invalid parameters for WEIBULL.DIST".to_string(),
-                }
-            }
-        };
-
-        let result = if cumulative { dist.cdf(x) } else { dist.pdf(x) };
-
-        if !result.is_finite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid result for WEIBULL.DIST".to_string(),
-            };
-        }
-
-        CalcResult::Number(result)
-    }
-}

base/src/functions/statistical/z_test.rs

@@ -1,171 +0,0 @@
-use statrs::distribution::{ContinuousCDF, Normal};
-
-use crate::expressions::token::Error;
-use crate::expressions::types::CellReferenceIndex;
-use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
-
-impl Model {
-    // Z.TEST(array, x, [sigma])
-    pub(crate) fn fn_z_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // 2 or 3 arguments
-        if args.len() < 2 || args.len() > 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let array_arg = self.evaluate_node_in_context(&args[0], cell);
-
-        // Flatten first argument into Vec<Option<f64>> (numeric / non-numeric)
-        let values = match array_arg {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(array) => match self.values_from_array(array) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in array argument: {:?}", error),
-                    );
-                }
-            },
-            CalcResult::Number(v) => vec![Some(v)],
-            error @ CalcResult::Error { .. } => return error,
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Z.TEST first argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        // Collect basic stats on numeric entries
-        let mut sum = 0.0;
-        let mut count: u64 = 0;
-
-        for x in values.iter().flatten() {
-            sum += x;
-            count += 1;
-        }
-
-        // Excel: if array has no numeric values -> #N/A
-        if count == 0 {
-            return CalcResult::new_error(
-                Error::NA,
-                cell,
-                "Z.TEST array has no numeric data".to_string(),
-            );
-        }
-
-        let n = count as f64;
-        let mean = sum / n;
-
-        // x argument (hypothesized population mean)
-        let x_value = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Number(v) => v,
-            error @ CalcResult::Error { .. } => return error,
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Z.TEST second argument (x) must be numeric".to_string(),
-                );
-            }
-        };
-
-        // Optional sigma
-        let mut sigma: Option<f64> = None;
-        if args.len() == 3 {
-            match self.evaluate_node_in_context(&args[2], cell) {
-                CalcResult::Number(v) => {
-                    if v == 0.0 {
-                        return CalcResult::new_error(
-                            Error::NUM,
-                            cell,
-                            "Z.TEST sigma cannot be zero".to_string(),
-                        );
-                    }
-                    sigma = Some(v);
-                }
-                error @ CalcResult::Error { .. } => return error,
-                _ => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        "Z.TEST sigma (third argument) must be numeric".to_string(),
-                    );
-                }
-            }
-        }
-
-        // If sigma omitted, use sample standard deviation STDEV(array)
-        let sigma_value = if let Some(s) = sigma {
-            s
-        } else {
-            // Excel: if only one numeric value and sigma omitted -> #DIV/0!
-            if count <= 1 {
-                return CalcResult::new_error(
-                    Error::DIV,
-                    cell,
-                    "Z.TEST requires at least two values when sigma is omitted".to_string(),
-                );
-            }
-
-            // Compute sum of squared deviations
-            let mut sumsq_dev = 0.0;
-            for x in values.iter().flatten() {
-                let d = x - mean;
-                sumsq_dev += d * d;
-            }
-
-            let var = sumsq_dev / (n - 1.0);
-            if var <= 0.0 {
-                return CalcResult::new_error(
-                    Error::DIV,
-                    cell,
-                    "Z.TEST standard deviation is zero".to_string(),
-                );
-            }
-
-            var.sqrt()
-        };
-
-        // Compute z statistic: (mean - x) / (sigma / sqrt(n))
-        let denom = sigma_value / n.sqrt();
-        if denom == 0.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Z.TEST denominator is zero".to_string(),
-            );
-        }
-
-        let z = (mean - x_value) / denom;
-
-        // Standard normal CDF
-        let dist = match Normal::new(0.0, 1.0) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Cannot create standard normal distribution in Z.TEST".to_string(),
-                );
-            }
-        };
-
-        let mut p = 1.0 - dist.cdf(z);
-
-        // clamp tiny FP noise
-        if p < 0.0 && p > -1e-15 {
-            p = 0.0;
-        }
-        if p > 1.0 && p < 1.0 + 1e-15 {
-            p = 1.0;
-        }
-
-        CalcResult::Number(p)
-    }
-}

base/src/functions/subtotal.rs

@@ -182,13 +182,6 @@ 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(),
-                            })
-                        }
                     }
                 }
             }
@@ -433,13 +426,6 @@ 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(),
-                            }
-                        }
                     }
                 }
             }