Compare commits
5 Commits
main
...
feature/ni
| Author | SHA1 | Date | |
|---|---|---|---|
|
b0ad2848ba | ||
|
|
b079d98908 | ||
|
|
1c731e11fd | ||
|
|
8e6af0cd74 | ||
|
|
835137fa30 |
115
.github/workflows/npm.yml
vendored
115
.github/workflows/npm.yml
vendored
@@ -31,38 +31,82 @@ jobs:
|
||||
- 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
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
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
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
yarn build --target x86_64-unknown-linux-musl
|
||||
- host: macos-latest
|
||||
target: aarch64-apple-darwin
|
||||
build: yarn build --target aarch64-apple-darwin
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
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
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
rustup target add aarch64-unknown-linux-gnu &&
|
||||
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
|
||||
sudo apt-get install -y gcc-arm-linux-gnueabihf libc6-dev-armhf-cross
|
||||
build: |
|
||||
set -e
|
||||
rustup toolchain install 1.90.0
|
||||
rustup default 1.90.0
|
||||
export CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc
|
||||
export AR_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-ar
|
||||
export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc
|
||||
export PKG_CONFIG_ALLOW_CROSS=1
|
||||
yarn build --target armv7-unknown-linux-gnueabihf
|
||||
# - host: ubuntu-latest
|
||||
# target: armv7-unknown-linux-musleabihf
|
||||
# build: |
|
||||
# set -e
|
||||
# rustup toolchain install 1.90.0
|
||||
# rustup default 1.90.0
|
||||
# # Use Zig as the MUSL cross C toolchain
|
||||
# export CC_armv7_unknown_linux_musleabihf="zig cc -target armv7-linux-musleabihf -mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
# export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_MUSLEABIHF_LINKER="zig cc -target armv7-linux-musleabihf -mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
# export AR_armv7_unknown_linux_musleabihf="zig ar"
|
||||
# export PKG_CONFIG_ALLOW_CROSS=1
|
||||
# yarn build --target armv7-unknown-linux-musleabihf
|
||||
- host: ubuntu-latest
|
||||
target: aarch64-linux-android
|
||||
build: yarn build --target aarch64-linux-android
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
yarn build --target aarch64-linux-android
|
||||
- host: ubuntu-latest
|
||||
target: armv7-linux-androideabi
|
||||
build: yarn build --target armv7-linux-androideabi
|
||||
build: |
|
||||
set -e &&
|
||||
rustup toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
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 toolchain install 1.90.0 &&
|
||||
rustup default 1.90.0 &&
|
||||
rustup target add aarch64-unknown-linux-musl &&
|
||||
yarn build --target aarch64-unknown-linux-musl
|
||||
- host: windows-latest
|
||||
@@ -92,7 +136,7 @@ jobs:
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
if: ${{ !matrix.settings.docker }}
|
||||
with:
|
||||
toolchain: stable
|
||||
toolchain: 1.90.0
|
||||
targets: ${{ matrix.settings.target }}
|
||||
- name: Cache cargo
|
||||
uses: actions/cache@v4
|
||||
@@ -144,7 +188,6 @@ jobs:
|
||||
- host: windows-latest
|
||||
target: x86_64-pc-windows-msvc
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ${{ matrix.settings.host }}
|
||||
defaults:
|
||||
@@ -179,7 +222,6 @@ jobs:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
@@ -213,7 +255,6 @@ jobs:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
@@ -249,7 +290,6 @@ jobs:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
@@ -320,48 +360,6 @@ jobs:
|
||||
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:
|
||||
@@ -410,7 +408,6 @@ jobs:
|
||||
- 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
|
||||
|
||||
94
Cargo.lock
generated
94
Cargo.lock
generated
@@ -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"
|
||||
@@ -227,9 +218,9 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
|
||||
|
||||
[[package]]
|
||||
name = "convert_case"
|
||||
version = "0.6.0"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
|
||||
checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
|
||||
dependencies = [
|
||||
"unicode-segmentation",
|
||||
]
|
||||
@@ -297,14 +288,20 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ctor"
|
||||
version = "0.2.9"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
|
||||
checksum = "67773048316103656a637612c4a62477603b777d91d9c62ff2290f9cde178fdb"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"syn",
|
||||
"ctor-proc-macro",
|
||||
"dtor",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ctor-proc-macro"
|
||||
version = "0.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2931af7e13dc045d8e9d26afccc6fa115d64e115c9c84b1166288b46f6782c2"
|
||||
|
||||
[[package]]
|
||||
name = "deranged"
|
||||
version = "0.3.11"
|
||||
@@ -325,6 +322,21 @@ dependencies = [
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "dtor"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e58a0764cddb55ab28955347b45be00ade43d4d6f3ba4bf3dc354e4ec9432934"
|
||||
dependencies = [
|
||||
"dtor-proc-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "dtor-proc-macro"
|
||||
version = "0.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.10.0"
|
||||
@@ -452,7 +464,6 @@ dependencies = [
|
||||
"ryu",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"statrs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -547,33 +558,34 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "napi"
|
||||
version = "2.16.13"
|
||||
version = "3.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
|
||||
checksum = "f1b74e3dce5230795bb4d2821b941706dee733c7308752507254b0497f39cad7"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"ctor",
|
||||
"napi-derive",
|
||||
"napi-build",
|
||||
"napi-sys",
|
||||
"once_cell",
|
||||
"nohash-hasher",
|
||||
"rustc-hash",
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi-build"
|
||||
version = "2.1.4"
|
||||
version = "2.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
|
||||
checksum = "dcae8ad5609d14afb3a3b91dee88c757016261b151e9dcecabf1b2a31a6cab14"
|
||||
|
||||
[[package]]
|
||||
name = "napi-derive"
|
||||
version = "2.16.13"
|
||||
version = "3.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
|
||||
checksum = "7552d5a579b834614bbd496db5109f1b9f1c758f08224b0dee1e408333adf0d0"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"convert_case",
|
||||
"ctor",
|
||||
"napi-derive-backend",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -582,28 +594,32 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "napi-derive-backend"
|
||||
version = "1.0.75"
|
||||
version = "2.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
|
||||
checksum = "5f6a81ac7486b70f2532a289603340862c06eea5a1e650c1ffeda2ce1238516a"
|
||||
dependencies = [
|
||||
"convert_case",
|
||||
"once_cell",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"regex",
|
||||
"semver",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi-sys"
|
||||
version = "2.4.0"
|
||||
version = "3.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
|
||||
checksum = "3e4e7135a8f97aa0f1509cce21a8a1f9dcec1b50d8dee006b48a5adb69a9d64d"
|
||||
dependencies = [
|
||||
"libloading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nohash-hasher"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
|
||||
|
||||
[[package]]
|
||||
name = "num-conv"
|
||||
version = "0.1.0"
|
||||
@@ -881,6 +897,12 @@ version = "0.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
|
||||
|
||||
[[package]]
|
||||
name = "rustc-hash"
|
||||
version = "2.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
|
||||
|
||||
[[package]]
|
||||
name = "rustversion"
|
||||
version = "1.0.21"
|
||||
@@ -975,16 +997,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"
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 8.1 KiB After Width: | Height: | Size: 5.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 7.4 KiB After Width: | Height: | Size: 4.7 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 538 B After Width: | Height: | Size: 441 B |
Binary file not shown.
|
Before Width: | Height: | Size: 1019 B After Width: | Height: | Size: 729 B |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB After Width: | Height: | Size: 15 KiB |
BIN
assets/logo.png
BIN
assets/logo.png
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB After Width: | Height: | Size: 33 KiB |
@@ -19,7 +19,6 @@ regex = { version = "1.0", optional = true}
|
||||
regex-lite = { version = "0.1.6", optional = true}
|
||||
bitcode = "0.6.3"
|
||||
csv = "1.3.0"
|
||||
statrs = { version = "0.18.0", default-features = false, features = [] }
|
||||
|
||||
[features]
|
||||
default = ["use_regex_full"]
|
||||
|
||||
@@ -5,7 +5,6 @@ use crate::{
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
formatter::format::parse_formatted_number,
|
||||
model::Model,
|
||||
};
|
||||
|
||||
@@ -15,23 +14,6 @@ pub(crate) enum NumberOrArray {
|
||||
}
|
||||
|
||||
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, ¤cies) {
|
||||
return Some(v);
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
pub(crate) fn get_number_or_array(
|
||||
&mut self,
|
||||
node: &Node,
|
||||
@@ -39,9 +21,9 @@ impl Model {
|
||||
) -> 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(
|
||||
CalcResult::String(s) => match s.parse::<f64>() {
|
||||
Ok(f) => Ok(NumberOrArray::Number(f)),
|
||||
_ => Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Expecting number".to_string(),
|
||||
@@ -107,16 +89,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(),
|
||||
|
||||
@@ -12,9 +12,6 @@ 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
|
||||
|
||||
@@ -471,20 +471,6 @@ impl Parser {
|
||||
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 {
|
||||
@@ -504,20 +490,6 @@ impl Parser {
|
||||
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 {
|
||||
|
||||
@@ -711,7 +711,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
|
||||
Function::Value => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Valuetotext => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Average => vec![Signature::Vector; arg_count],
|
||||
Function::Avedev => vec![Signature::Vector; arg_count],
|
||||
Function::Averagea => vec![Signature::Vector; arg_count],
|
||||
Function::Averageif => args_signature_sumif(arg_count),
|
||||
Function::Averageifs => vec![Signature::Vector; arg_count],
|
||||
@@ -835,178 +834,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
|
||||
Function::Geomean => vec![Signature::Vector; arg_count],
|
||||
Function::Networkdays => args_signature_networkdays(arg_count),
|
||||
Function::NetworkdaysIntl => args_signature_networkdays_intl(arg_count),
|
||||
Function::Acot => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Acoth => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cot => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Coth => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Csc => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Csch => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sec => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sech => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Exp => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Fact => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Factdouble => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sign => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Radians => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Degrees => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Int => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Even => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Odd => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Ceiling => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::CeilingMath => args_signature_scalars(arg_count, 1, 2),
|
||||
Function::CeilingPrecise => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Floor => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::FloorMath => args_signature_scalars(arg_count, 1, 2),
|
||||
Function::FloorPrecise => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::IsoCeiling => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Mod => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Quotient => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Mround => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Trunc => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Gcd => vec![Signature::Vector; arg_count],
|
||||
Function::Lcm => vec![Signature::Vector; arg_count],
|
||||
Function::Base => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Decimal => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Roman => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Arabic => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Combin => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Combina => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Sumsq => vec![Signature::Vector; arg_count],
|
||||
Function::N => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sheets => args_signature_scalars(arg_count, 0, 1),
|
||||
Function::Cell => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Info => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Daverage => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dcount => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dget => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dmax => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dmin => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dsum => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dcounta => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dproduct => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dstdev => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dvar => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dvarp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::Dstdevp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
|
||||
Function::BetaDist => args_signature_scalars(arg_count, 4, 2),
|
||||
Function::BetaInv => args_signature_scalars(arg_count, 3, 2),
|
||||
Function::BinomDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::BinomDistRange => args_signature_scalars(arg_count, 3, 1),
|
||||
Function::BinomInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::ChisqDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::ChisqDistRT => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::ChisqInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::ChisqInvRT => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::ChisqTest => {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::ConfidenceNorm => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::ConfidenceT => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::CovarianceP => {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::CovarianceS => {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::Devsq => vec![Signature::Vector; arg_count],
|
||||
Function::ExponDist => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::FDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::FDistRT => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::FInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::FInvRT => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::FTest => vec![Signature::Vector; 2],
|
||||
Function::Fisher => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::FisherInv => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Gamma => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::GammaDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::GammaInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::GammaLn => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::GammaLnPrecise => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::HypGeomDist => args_signature_scalars(arg_count, 5, 0),
|
||||
Function::LogNormDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::LogNormInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::NegbinomDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::NormDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::NormInv => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::NormSdist => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::NormSInv => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Pearson => {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::Phi => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::PoissonDist => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Standardize => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::StDevP => vec![Signature::Vector; arg_count],
|
||||
Function::StDevS => vec![Signature::Vector; arg_count],
|
||||
Function::Stdeva => vec![Signature::Vector; arg_count],
|
||||
Function::Stdevpa => vec![Signature::Vector; arg_count],
|
||||
Function::TDist => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::TDist2T => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::TDistRT => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::TInv => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::TInv2T => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::TTest => {
|
||||
if arg_count == 4 {
|
||||
vec![
|
||||
Signature::Vector,
|
||||
Signature::Vector,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::VarP => vec![Signature::Vector; arg_count],
|
||||
Function::VarS => vec![Signature::Vector; arg_count],
|
||||
Function::VarpA => vec![Signature::Vector; arg_count],
|
||||
Function::VarA => vec![Signature::Vector; arg_count],
|
||||
Function::WeibullDist => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::ZTest => {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Scalar]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
Function::Sumx2my2 => vec![Signature::Vector; 2],
|
||||
Function::Sumx2py2 => vec![Signature::Vector; 2],
|
||||
Function::Sumxmy2 => vec![Signature::Vector; 2],
|
||||
Function::Correl => vec![Signature::Vector; 2],
|
||||
Function::Rsq => vec![Signature::Vector; 2],
|
||||
Function::Intercept => vec![Signature::Vector; 2],
|
||||
Function::Slope => vec![Signature::Vector; 2],
|
||||
Function::Steyx => vec![Signature::Vector; 2],
|
||||
Function::Gauss => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Harmean => vec![Signature::Vector; arg_count],
|
||||
Function::Kurt => vec![Signature::Vector; arg_count],
|
||||
Function::Large => vec![Signature::Vector, Signature::Scalar],
|
||||
Function::MaxA => vec![Signature::Vector; arg_count],
|
||||
Function::Median => vec![Signature::Vector; arg_count],
|
||||
Function::MinA => vec![Signature::Vector; arg_count],
|
||||
Function::RankAvg => vec![Signature::Scalar, Signature::Vector, Signature::Scalar],
|
||||
Function::RankEq => vec![Signature::Scalar, Signature::Vector, Signature::Scalar],
|
||||
Function::Skew => vec![Signature::Vector; arg_count],
|
||||
Function::SkewP => vec![Signature::Vector; arg_count],
|
||||
Function::Small => vec![Signature::Vector, Signature::Scalar],
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1032,7 +859,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Atan => scalar_arguments(args),
|
||||
Function::Atan2 => scalar_arguments(args),
|
||||
Function::Atanh => scalar_arguments(args),
|
||||
Function::Choose => scalar_arguments(args),
|
||||
Function::Choose => scalar_arguments(args), // static_analysis_choose(args, cell),
|
||||
Function::Column => not_implemented(args),
|
||||
Function::Columns => not_implemented(args),
|
||||
Function::Cos => scalar_arguments(args),
|
||||
@@ -1079,6 +906,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Lookup => not_implemented(args),
|
||||
Function::Match => not_implemented(args),
|
||||
Function::Offset => static_analysis_offset(args),
|
||||
// FIXME: Row could return an array
|
||||
Function::Row => StaticResult::Scalar,
|
||||
Function::Rows => not_implemented(args),
|
||||
Function::Vlookup => not_implemented(args),
|
||||
@@ -1107,7 +935,6 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Valuetotext => not_implemented(args),
|
||||
Function::Average => not_implemented(args),
|
||||
Function::Averagea => not_implemented(args),
|
||||
Function::Avedev => not_implemented(args),
|
||||
Function::Averageif => not_implemented(args),
|
||||
Function::Averageifs => not_implemented(args),
|
||||
Function::Count => not_implemented(args),
|
||||
@@ -1229,134 +1056,5 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Geomean => not_implemented(args),
|
||||
Function::Networkdays => not_implemented(args),
|
||||
Function::NetworkdaysIntl => not_implemented(args),
|
||||
Function::Acot => scalar_arguments(args),
|
||||
Function::Acoth => scalar_arguments(args),
|
||||
Function::Cot => scalar_arguments(args),
|
||||
Function::Coth => scalar_arguments(args),
|
||||
Function::Csc => scalar_arguments(args),
|
||||
Function::Csch => scalar_arguments(args),
|
||||
Function::Sec => scalar_arguments(args),
|
||||
Function::Sech => scalar_arguments(args),
|
||||
Function::Exp => scalar_arguments(args),
|
||||
Function::Fact => scalar_arguments(args),
|
||||
Function::Factdouble => scalar_arguments(args),
|
||||
Function::Sign => scalar_arguments(args),
|
||||
Function::Radians => scalar_arguments(args),
|
||||
Function::Degrees => scalar_arguments(args),
|
||||
Function::Int => scalar_arguments(args),
|
||||
Function::Even => scalar_arguments(args),
|
||||
Function::Odd => scalar_arguments(args),
|
||||
Function::Ceiling => scalar_arguments(args),
|
||||
Function::CeilingMath => scalar_arguments(args),
|
||||
Function::CeilingPrecise => scalar_arguments(args),
|
||||
Function::Floor => scalar_arguments(args),
|
||||
Function::FloorMath => scalar_arguments(args),
|
||||
Function::FloorPrecise => scalar_arguments(args),
|
||||
Function::IsoCeiling => scalar_arguments(args),
|
||||
Function::Mod => scalar_arguments(args),
|
||||
Function::Quotient => scalar_arguments(args),
|
||||
Function::Mround => scalar_arguments(args),
|
||||
Function::Trunc => scalar_arguments(args),
|
||||
Function::Gcd => not_implemented(args),
|
||||
Function::Lcm => not_implemented(args),
|
||||
Function::Base => scalar_arguments(args),
|
||||
Function::Decimal => scalar_arguments(args),
|
||||
Function::Roman => scalar_arguments(args),
|
||||
Function::Arabic => scalar_arguments(args),
|
||||
Function::Combin => scalar_arguments(args),
|
||||
Function::Combina => scalar_arguments(args),
|
||||
Function::Sumsq => StaticResult::Scalar,
|
||||
Function::N => scalar_arguments(args),
|
||||
Function::Sheets => scalar_arguments(args),
|
||||
Function::Cell => scalar_arguments(args),
|
||||
Function::Info => scalar_arguments(args),
|
||||
Function::Dget => not_implemented(args),
|
||||
Function::Dmax => not_implemented(args),
|
||||
Function::Dmin => not_implemented(args),
|
||||
Function::Dcount => not_implemented(args),
|
||||
Function::Daverage => not_implemented(args),
|
||||
Function::Dsum => not_implemented(args),
|
||||
Function::Dcounta => not_implemented(args),
|
||||
Function::Dproduct => not_implemented(args),
|
||||
Function::Dstdev => not_implemented(args),
|
||||
Function::Dvar => not_implemented(args),
|
||||
Function::Dvarp => not_implemented(args),
|
||||
Function::Dstdevp => not_implemented(args),
|
||||
Function::BetaDist => StaticResult::Scalar,
|
||||
Function::BetaInv => StaticResult::Scalar,
|
||||
Function::BinomDist => StaticResult::Scalar,
|
||||
Function::BinomDistRange => StaticResult::Scalar,
|
||||
Function::BinomInv => StaticResult::Scalar,
|
||||
Function::ChisqDist => StaticResult::Scalar,
|
||||
Function::ChisqDistRT => StaticResult::Scalar,
|
||||
Function::ChisqInv => StaticResult::Scalar,
|
||||
Function::ChisqInvRT => StaticResult::Scalar,
|
||||
Function::ChisqTest => StaticResult::Scalar,
|
||||
Function::ConfidenceNorm => StaticResult::Scalar,
|
||||
Function::ConfidenceT => StaticResult::Scalar,
|
||||
Function::CovarianceP => StaticResult::Scalar,
|
||||
Function::CovarianceS => StaticResult::Scalar,
|
||||
Function::Devsq => StaticResult::Scalar,
|
||||
Function::ExponDist => StaticResult::Scalar,
|
||||
Function::FDist => StaticResult::Scalar,
|
||||
Function::FDistRT => StaticResult::Scalar,
|
||||
Function::FInv => StaticResult::Scalar,
|
||||
Function::FInvRT => StaticResult::Scalar,
|
||||
Function::FTest => StaticResult::Scalar,
|
||||
Function::Fisher => StaticResult::Scalar,
|
||||
Function::FisherInv => StaticResult::Scalar,
|
||||
Function::Gamma => StaticResult::Scalar,
|
||||
Function::GammaDist => StaticResult::Scalar,
|
||||
Function::GammaInv => StaticResult::Scalar,
|
||||
Function::GammaLn => StaticResult::Scalar,
|
||||
Function::GammaLnPrecise => StaticResult::Scalar,
|
||||
Function::HypGeomDist => StaticResult::Scalar,
|
||||
Function::LogNormDist => StaticResult::Scalar,
|
||||
Function::LogNormInv => StaticResult::Scalar,
|
||||
Function::NegbinomDist => StaticResult::Scalar,
|
||||
Function::NormDist => StaticResult::Scalar,
|
||||
Function::NormInv => StaticResult::Scalar,
|
||||
Function::NormSdist => StaticResult::Scalar,
|
||||
Function::NormSInv => StaticResult::Scalar,
|
||||
Function::Pearson => StaticResult::Scalar,
|
||||
Function::Phi => StaticResult::Scalar,
|
||||
Function::PoissonDist => StaticResult::Scalar,
|
||||
Function::Standardize => StaticResult::Scalar,
|
||||
Function::StDevP => StaticResult::Scalar,
|
||||
Function::StDevS => StaticResult::Scalar,
|
||||
Function::Stdeva => StaticResult::Scalar,
|
||||
Function::Stdevpa => StaticResult::Scalar,
|
||||
Function::TDist => StaticResult::Scalar,
|
||||
Function::TDist2T => StaticResult::Scalar,
|
||||
Function::TDistRT => StaticResult::Scalar,
|
||||
Function::TInv => StaticResult::Scalar,
|
||||
Function::TInv2T => StaticResult::Scalar,
|
||||
Function::TTest => StaticResult::Scalar,
|
||||
Function::VarP => StaticResult::Scalar,
|
||||
Function::VarS => StaticResult::Scalar,
|
||||
Function::VarpA => StaticResult::Scalar,
|
||||
Function::VarA => StaticResult::Scalar,
|
||||
Function::WeibullDist => StaticResult::Scalar,
|
||||
Function::ZTest => StaticResult::Scalar,
|
||||
Function::Sumx2my2 => StaticResult::Scalar,
|
||||
Function::Sumx2py2 => StaticResult::Scalar,
|
||||
Function::Sumxmy2 => StaticResult::Scalar,
|
||||
Function::Correl => StaticResult::Scalar,
|
||||
Function::Rsq => StaticResult::Scalar,
|
||||
Function::Intercept => StaticResult::Scalar,
|
||||
Function::Slope => StaticResult::Scalar,
|
||||
Function::Steyx => StaticResult::Scalar,
|
||||
Function::Gauss => StaticResult::Scalar,
|
||||
Function::Harmean => StaticResult::Scalar,
|
||||
Function::Kurt => StaticResult::Scalar,
|
||||
Function::Large => StaticResult::Scalar,
|
||||
Function::MaxA => StaticResult::Scalar,
|
||||
Function::Median => StaticResult::Scalar,
|
||||
Function::MinA => StaticResult::Scalar,
|
||||
Function::RankAvg => StaticResult::Scalar,
|
||||
Function::RankEq => StaticResult::Scalar,
|
||||
Function::Skew => StaticResult::Scalar,
|
||||
Function::SkewP => StaticResult::Scalar,
|
||||
Function::Small => StaticResult::Scalar,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -520,7 +520,6 @@ fn stringify(
|
||||
let x = match **left {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| UnaryKind { .. }
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
@@ -536,6 +535,7 @@ fn stringify(
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| UnaryKind { .. }
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| OpSumKind { .. }
|
||||
@@ -630,6 +630,7 @@ fn stringify(
|
||||
| OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| OpPowerKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
@@ -642,7 +643,7 @@ fn stringify(
|
||||
| ParseErrorKind { .. }
|
||||
| EmptyArgKind => false,
|
||||
|
||||
OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
|
||||
OpSumKind { .. } | UnaryKind { .. } => true,
|
||||
};
|
||||
if needs_parentheses {
|
||||
format!(
|
||||
|
||||
@@ -3,7 +3,6 @@ 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;
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,6 +209,7 @@ fn test_names() {
|
||||
assert!(!is_valid_identifier("1true"));
|
||||
|
||||
assert!(!is_valid_identifier("test€"));
|
||||
assert!(!is_valid_identifier("truñe"));
|
||||
assert!(!is_valid_identifier("tr&ue"));
|
||||
|
||||
assert!(!is_valid_identifier("LOG10"));
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
@@ -160,11 +154,16 @@ 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();
|
||||
let date = match from_excel_date(value as i64) {
|
||||
Ok(d) => d,
|
||||
Err(e) => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(e),
|
||||
}
|
||||
}
|
||||
};
|
||||
for token in tokens {
|
||||
match token {
|
||||
TextToken::Literal(c) => {
|
||||
@@ -188,44 +187,15 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
}
|
||||
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::Day => {
|
||||
let day = date.day() as usize;
|
||||
text = format!("{text}{day}");
|
||||
}
|
||||
TextToken::DayPadded => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let day = date.day() as usize;
|
||||
text = format!("{text}{day:02}");
|
||||
}
|
||||
TextToken::DayNameShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut day = date.weekday().number_from_monday() as usize;
|
||||
if day == 7 {
|
||||
day = 0;
|
||||
@@ -233,16 +203,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 +210,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}");
|
||||
}
|
||||
TextToken::MonthPadded => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{text}{month:02}");
|
||||
}
|
||||
TextToken::MonthNameShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{}{}", text, &locale.dates.months_short[month - 1]);
|
||||
}
|
||||
TextToken::MonthName => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{}{}", text, &locale.dates.months[month - 1]);
|
||||
}
|
||||
TextToken::MonthLetter => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
let months_letter = &locale.dates.months_letter[month - 1];
|
||||
text = format!("{text}{months_letter}");
|
||||
}
|
||||
TextToken::YearShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
text = format!("{}{}", text, date.format("%y"));
|
||||
}
|
||||
TextToken::Year => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
text = format!("{}{}", text, date.year());
|
||||
}
|
||||
TextToken::Hour => {
|
||||
let mut hour = hours as i32;
|
||||
if p.use_ampm {
|
||||
if hour == 0 {
|
||||
hour = 12;
|
||||
} else if hour > 12 {
|
||||
hour -= 12;
|
||||
}
|
||||
}
|
||||
text = format!("{text}{hour}");
|
||||
}
|
||||
TextToken::HourPadded => {
|
||||
let mut hour = hours as i32;
|
||||
if p.use_ampm {
|
||||
if hour == 0 {
|
||||
hour = 12;
|
||||
} else if hour > 12 {
|
||||
hour -= 12;
|
||||
}
|
||||
}
|
||||
text = format!("{text}{hour:02}");
|
||||
}
|
||||
TextToken::Second => {
|
||||
let second = seconds as i32;
|
||||
text = format!("{text}{second}");
|
||||
}
|
||||
TextToken::SecondPadded => {
|
||||
let second = seconds as i32;
|
||||
text = format!("{text}{second:02}");
|
||||
}
|
||||
TextToken::AMPM => {
|
||||
let ampm = if hours < 12.0 { "AM" } else { "PM" };
|
||||
text = format!("{text}{ampm}");
|
||||
}
|
||||
TextToken::Minute => {
|
||||
let minute = minutes as i32;
|
||||
text = format!("{text}{minute}");
|
||||
}
|
||||
TextToken::MinutePadded => {
|
||||
let minute = minutes as i32;
|
||||
text = format!("{text}{minute:02}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Formatted {
|
||||
@@ -429,7 +277,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
|
||||
@@ -574,13 +422,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 +591,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
|
||||
@@ -805,8 +646,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)));
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
@@ -365,8 +361,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,63 +381,6 @@ 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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -1,3 +1,2 @@
|
||||
mod test_general;
|
||||
mod test_parse_formatted_number;
|
||||
mod test_time;
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,31 +4,10 @@ use chrono::Months;
|
||||
use chrono::NaiveDateTime;
|
||||
use chrono::NaiveTime;
|
||||
use chrono::Timelike;
|
||||
use chrono_tz::Tz;
|
||||
|
||||
const SECONDS_PER_DAY: i32 = 86_400;
|
||||
const SECONDS_PER_DAY_F64: f64 = SECONDS_PER_DAY as f64;
|
||||
|
||||
fn is_leap_year(year: i32) -> bool {
|
||||
(year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)
|
||||
}
|
||||
|
||||
fn is_feb_29_between_dates(start: chrono::NaiveDate, end: chrono::NaiveDate) -> bool {
|
||||
let start_year = start.year();
|
||||
let end_year = end.year();
|
||||
|
||||
for year in start_year..=end_year {
|
||||
if is_leap_year(year)
|
||||
&& (year < end_year
|
||||
|| (year == end_year && end.month() > 2)
|
||||
&& (year > start_year || (year == start_year && start.month() <= 2)))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helper macros to eliminate boilerplate in date/time component extraction
|
||||
// functions (DAY, MONTH, YEAR, HOUR, MINUTE, SECOND).
|
||||
@@ -771,12 +750,12 @@ impl Model {
|
||||
Ok(values)
|
||||
}
|
||||
|
||||
// Returns the current date/time as an Excel serial number in the given timezone.
|
||||
// Returns the current date/time as an Excel serial number in the model's configured timezone.
|
||||
// Used by TODAY() and NOW().
|
||||
pub(crate) fn current_excel_serial_with_timezone(&self, tz: Tz) -> Option<f64> {
|
||||
fn current_excel_serial(&self) -> Option<f64> {
|
||||
let seconds = get_milliseconds_since_epoch() / 1000;
|
||||
DateTime::from_timestamp(seconds, 0).map(|dt| {
|
||||
let local_time = dt.with_timezone(&tz);
|
||||
let local_time = dt.with_timezone(&self.tz);
|
||||
let days_from_1900 = local_time.num_days_from_ce() - EXCEL_DATE_BASE;
|
||||
let fraction = (local_time.num_seconds_from_midnight() as f64) / (60.0 * 60.0 * 24.0);
|
||||
days_from_1900 as f64 + fraction
|
||||
@@ -979,7 +958,7 @@ impl Model {
|
||||
message: "Wrong number of arguments".to_string(),
|
||||
};
|
||||
}
|
||||
match self.current_excel_serial_with_timezone(self.tz) {
|
||||
match self.current_excel_serial() {
|
||||
Some(serial) => CalcResult::Number(serial.floor()),
|
||||
None => CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
@@ -990,35 +969,14 @@ impl Model {
|
||||
}
|
||||
|
||||
pub(crate) fn fn_now(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() > 1 {
|
||||
if !args.is_empty() {
|
||||
return CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Wrong number of arguments".to_string(),
|
||||
};
|
||||
}
|
||||
let tz = match args.first() {
|
||||
Some(arg0) => {
|
||||
// Parse timezone argument
|
||||
let tz_str = match self.get_string(arg0, cell) {
|
||||
Ok(s) => s,
|
||||
Err(e) => return e,
|
||||
};
|
||||
let tz: Tz = match tz_str.parse() {
|
||||
Ok(tz) => tz,
|
||||
Err(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: format!("Invalid timezone: {}", &tz_str),
|
||||
}
|
||||
}
|
||||
};
|
||||
tz
|
||||
}
|
||||
None => self.tz,
|
||||
};
|
||||
match self.current_excel_serial_with_timezone(tz) {
|
||||
match self.current_excel_serial() {
|
||||
Some(serial) => CalcResult::Number(serial),
|
||||
None => CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
@@ -1609,44 +1567,18 @@ impl Model {
|
||||
}
|
||||
}
|
||||
1 => {
|
||||
// Procedure E
|
||||
|
||||
let start_year = start_date.year();
|
||||
let end_year = end_date.year();
|
||||
|
||||
let step_a = start_year != end_year;
|
||||
let step_b = start_year + 1 != end_year;
|
||||
let step_c = start_date.month() < end_date.month();
|
||||
let step_d = start_date.month() == end_date.month();
|
||||
let step_e = start_date.day() <= end_date.day();
|
||||
let step_f = step_a && (step_b || step_c || (step_d && step_e));
|
||||
if step_f {
|
||||
// 7.
|
||||
// return average of days in year between start_year and end_year, inclusive
|
||||
let mut total_days = 0;
|
||||
for year in start_year..=end_year {
|
||||
if is_leap_year(year) {
|
||||
total_days += 366;
|
||||
} else {
|
||||
total_days += 365;
|
||||
}
|
||||
let year_days = if start_date.year() == end_date.year() {
|
||||
if (start_date.year() % 4 == 0 && start_date.year() % 100 != 0)
|
||||
|| start_date.year() % 400 == 0
|
||||
{
|
||||
366.0
|
||||
} else {
|
||||
365.0
|
||||
}
|
||||
days / (total_days as f64 / (end_year - start_year + 1) as f64)
|
||||
} else if step_a && is_leap_year(start_year) {
|
||||
// 8.
|
||||
days / 366.0
|
||||
} else if is_feb_29_between_dates(start_date, end_date) {
|
||||
// 9. If a February 29 occurs between date1 and date2 then return 366
|
||||
days / 366.0
|
||||
} else if end_date.month() == 2 && end_date.day() == 29 {
|
||||
// 10. If date2 is February 29 then return 366
|
||||
days / 366.0
|
||||
} else if !step_a && is_leap_year(start_year) {
|
||||
days / 366.0
|
||||
} else {
|
||||
// 11.
|
||||
days / 365.0
|
||||
}
|
||||
365.0
|
||||
};
|
||||
days / year_days
|
||||
}
|
||||
2 => days / 360.0,
|
||||
3 => days / 365.0,
|
||||
@@ -1663,34 +1595,6 @@ impl Model {
|
||||
}
|
||||
_ => return CalcResult::new_error(Error::NUM, cell, "Invalid basis".to_string()),
|
||||
};
|
||||
CalcResult::Number(result.abs())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_is_leap_year() {
|
||||
assert!(is_leap_year(2000));
|
||||
assert!(!is_leap_year(1900));
|
||||
assert!(is_leap_year(2004));
|
||||
assert!(!is_leap_year(2001));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_feb_29_between_dates() {
|
||||
let d1 = chrono::NaiveDate::from_ymd_opt(2020, 2, 28).unwrap();
|
||||
let d2 = chrono::NaiveDate::from_ymd_opt(2020, 3, 1).unwrap();
|
||||
assert!(is_feb_29_between_dates(d1, d2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_feb_29_between_dates_false() {
|
||||
let d1 = chrono::NaiveDate::from_ymd_opt(2021, 2, 28).unwrap();
|
||||
let d2 = chrono::NaiveDate::from_ymd_opt(2021, 3, 1).unwrap();
|
||||
assert!(!is_feb_29_between_dates(d1, d2));
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
|
||||
53
base/src/functions/engineering/transcendental/erf.rs
Normal file
53
base/src/functions/engineering/transcendental/erf.rs
Normal file
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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},
|
||||
};
|
||||
|
||||
@@ -320,150 +320,4 @@ impl Model {
|
||||
message: "Invalid name".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_n(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(n) => n,
|
||||
CalcResult::String(_) => 0.0,
|
||||
CalcResult::Boolean(f) => {
|
||||
if f {
|
||||
1.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
CalcResult::Number(value)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_sheets(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count > 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if arg_count == 1 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Sheets function with an argument is not implemented".to_string(),
|
||||
};
|
||||
}
|
||||
let sheet_count = self.workbook.worksheets.len() as f64;
|
||||
CalcResult::Number(sheet_count)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count == 0 || arg_count > 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let reference = if arg_count == 2 {
|
||||
match self.evaluate_node_with_reference(&args[1], cell) {
|
||||
CalcResult::Range { left, right: _ } => {
|
||||
// we just take the left cell of the range
|
||||
left
|
||||
}
|
||||
_ => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Argument must be a reference".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
CellReferenceIndex {
|
||||
sheet: cell.sheet,
|
||||
row: cell.row,
|
||||
column: cell.column,
|
||||
}
|
||||
};
|
||||
let info_type = match self.get_string(&args[0], cell) {
|
||||
Ok(s) => s.to_uppercase(),
|
||||
Err(e) => return e,
|
||||
};
|
||||
match info_type.as_str() {
|
||||
"ADDRESS" => {
|
||||
if reference.sheet != cell.sheet {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "References to other sheets not implemented".to_string(),
|
||||
};
|
||||
}
|
||||
let column = match number_to_column(reference.column) {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid column".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let address = format!("${}${}", column, reference.row);
|
||||
CalcResult::String(address)
|
||||
}
|
||||
"COL" => CalcResult::Number(reference.column as f64),
|
||||
"COLOR" | "FILENAME" | "FORMAT" | "PARENTHESES" | "PREFIX" | "PROTECT" | "WIDTH" => {
|
||||
CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "info_type not implemented".to_string(),
|
||||
}
|
||||
}
|
||||
"CONTENTS" => self.evaluate_cell(reference),
|
||||
"ROW" => CalcResult::Number(reference.row as f64),
|
||||
"TYPE" => {
|
||||
let cell_type = match self.evaluate_cell(reference) {
|
||||
CalcResult::EmptyCell => "b",
|
||||
CalcResult::String(_) => "l",
|
||||
CalcResult::Number(_) => "v",
|
||||
CalcResult::Boolean(_) => "v",
|
||||
CalcResult::Error { .. } => "v",
|
||||
CalcResult::Range { .. } => "v",
|
||||
CalcResult::EmptyArg => "v",
|
||||
CalcResult::Array(_) => "v",
|
||||
};
|
||||
CalcResult::String(cell_type.to_string())
|
||||
}
|
||||
_ => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid info_type".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_info(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.is_empty() || args.len() > 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Info function not implemented".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -68,14 +68,14 @@ macro_rules! single_number_fn {
|
||||
},
|
||||
// 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) {
|
||||
let node = match s.parse::<f64>() {
|
||||
Ok(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),
|
||||
Err(_) => ArrayNode::Error(Error::VALUE),
|
||||
};
|
||||
data_row.push(node);
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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)
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
733
base/src/functions/statistical.rs
Normal file
733
base/src/functions/statistical.rs
Normal file
@@ -0,0 +1,733 @@
|
||||
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::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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 => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
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.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)
|
||||
}
|
||||
|
||||
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))
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,7 @@
|
||||
#[cfg(feature = "use_regex_lite")]
|
||||
use regex_lite as regex;
|
||||
|
||||
use crate::{
|
||||
calc_result::CalcResult, expressions::token::is_english_error_string,
|
||||
number_format::to_excel_precision,
|
||||
};
|
||||
use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
|
||||
|
||||
/// This test for exact match (modulo case).
|
||||
/// * strings are not cast into bools or numbers
|
||||
@@ -37,8 +34,6 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
|
||||
pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
|
||||
match (left, right) {
|
||||
(CalcResult::Number(value1), CalcResult::Number(value2)) => {
|
||||
let value1 = to_excel_precision(*value1, 15);
|
||||
let value2 = to_excel_precision(*value2, 15);
|
||||
if (value2 - value1).abs() < f64::EPSILON {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -2068,7 +2068,21 @@ impl Model {
|
||||
scope: Option<u32>,
|
||||
formula: &str,
|
||||
) -> Result<(), String> {
|
||||
let sheet_id = self.is_valid_defined_name(name, scope, formula)?;
|
||||
if !is_valid_identifier(name) {
|
||||
return Err("Invalid defined name".to_string());
|
||||
};
|
||||
let name_upper = name.to_uppercase();
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
// if the defined name already exist return error
|
||||
for df in defined_names {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
return Err("Defined name already exists".to_string());
|
||||
}
|
||||
}
|
||||
self.workbook.defined_names.push(DefinedName {
|
||||
name: name.to_string(),
|
||||
formula: formula.to_string(),
|
||||
@@ -2079,48 +2093,6 @@ impl Model {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Validates if a defined name can be created
|
||||
pub fn is_valid_defined_name(
|
||||
&self,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
formula: &str,
|
||||
) -> Result<Option<u32>, String> {
|
||||
if !is_valid_identifier(name) {
|
||||
return Err("Name: Invalid defined name".to_string());
|
||||
}
|
||||
let name_upper = name.to_uppercase();
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => match self.workbook.worksheet(index) {
|
||||
Ok(ws) => Some(ws.sheet_id),
|
||||
Err(_) => return Err("Scope: Invalid sheet index".to_string()),
|
||||
},
|
||||
None => None,
|
||||
};
|
||||
// if the defined name already exist return error
|
||||
for df in defined_names {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
return Err("Name: Defined name already exists".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
// Make sure the formula is valid
|
||||
match common::ParsedReference::parse_reference_formula(
|
||||
None,
|
||||
formula,
|
||||
&self.locale,
|
||||
|name| self.get_sheet_index_by_name(name),
|
||||
) {
|
||||
Ok(_) => {}
|
||||
Err(_) => {
|
||||
return Err("Formula: Invalid defined name formula".to_string());
|
||||
}
|
||||
};
|
||||
|
||||
Ok(sheet_id)
|
||||
}
|
||||
|
||||
/// Delete defined name of name and scope
|
||||
pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
|
||||
let name_upper = name.to_uppercase();
|
||||
@@ -2154,7 +2126,7 @@ impl Model {
|
||||
new_formula: &str,
|
||||
) -> Result<(), String> {
|
||||
if !is_valid_identifier(new_name) {
|
||||
return Err("Name: Invalid defined name".to_string());
|
||||
return Err("Invalid defined name".to_string());
|
||||
};
|
||||
let name_upper = name.to_uppercase();
|
||||
let new_name_upper = new_name.to_uppercase();
|
||||
@@ -2162,28 +2134,18 @@ impl Model {
|
||||
if name_upper != new_name_upper || scope != new_scope {
|
||||
for key in self.parsed_defined_names.keys() {
|
||||
if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
|
||||
return Err("Name: Defined name already exists".to_string());
|
||||
return Err("Defined name already exists".to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(
|
||||
self.workbook
|
||||
.worksheet(index)
|
||||
.map_err(|_| "Scope: Invalid sheet index")?
|
||||
.sheet_id,
|
||||
),
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
|
||||
let new_sheet_id = match new_scope {
|
||||
Some(index) => Some(
|
||||
self.workbook
|
||||
.worksheet(index)
|
||||
.map_err(|_| "Scope: Invalid sheet index")?
|
||||
.sheet_id,
|
||||
),
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
|
||||
|
||||
@@ -112,36 +112,29 @@ pub fn to_precision(value: f64, precision: usize) -> f64 {
|
||||
/// ```
|
||||
/// This intends to be equivalent to the js: `${parseFloat(value.toPrecision(precision)})`
|
||||
/// See ([ecma](https://tc39.es/ecma262/#sec-number.prototype.toprecision)).
|
||||
/// FIXME: There has to be a better algorithm :/
|
||||
pub fn to_excel_precision_str(value: f64) -> String {
|
||||
to_precision_str(value, 15)
|
||||
}
|
||||
|
||||
pub fn to_excel_precision(value: f64, precision: usize) -> f64 {
|
||||
if !value.is_finite() {
|
||||
return value;
|
||||
}
|
||||
|
||||
let s = format!("{:.*e}", precision.saturating_sub(1), value);
|
||||
s.parse::<f64>().unwrap_or(value)
|
||||
}
|
||||
|
||||
pub fn to_precision_str(value: f64, precision: usize) -> String {
|
||||
if !value.is_finite() {
|
||||
if value.is_infinite() {
|
||||
return "inf".to_string();
|
||||
} else {
|
||||
return "NaN".to_string();
|
||||
}
|
||||
if value.is_infinite() {
|
||||
return "inf".to_string();
|
||||
}
|
||||
|
||||
let s = format!("{:.*e}", precision.saturating_sub(1), value);
|
||||
let parsed = s.parse::<f64>().unwrap_or(value);
|
||||
|
||||
if value.is_nan() {
|
||||
return "NaN".to_string();
|
||||
}
|
||||
let exponent = value.abs().log10().floor();
|
||||
let base = value / 10.0_f64.powf(exponent);
|
||||
let base = format!("{0:.1$}", base, precision - 1);
|
||||
let value = format!("{base}e{exponent}").parse::<f64>().unwrap_or({
|
||||
// TODO: do this in a way that does not require a possible error
|
||||
0.0
|
||||
});
|
||||
// I would love to use the std library. There is not a speed concern here
|
||||
// problem is it doesn't do the right thing
|
||||
// Also ryu is my favorite _modern_ algorithm
|
||||
let mut buffer = ryu::Buffer::new();
|
||||
let text = buffer.format(parsed);
|
||||
let text = buffer.format(value);
|
||||
// The above algorithm converts 2 to 2.0 regrettably
|
||||
if let Some(stripped) = text.strip_suffix(".0") {
|
||||
return stripped.to_string();
|
||||
|
||||
@@ -133,7 +133,6 @@ fn fn_imcot() {
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg_attr(target_os = "windows", ignore)]
|
||||
#[test]
|
||||
fn fn_imtan() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
mod test_actions;
|
||||
mod test_arabic_roman;
|
||||
mod test_binary_search;
|
||||
mod test_cell;
|
||||
mod test_cell_clear_contents;
|
||||
@@ -10,7 +9,6 @@ mod test_currency;
|
||||
mod test_date_and_time;
|
||||
mod test_datedif_leap_month_end;
|
||||
mod test_days360_month_end;
|
||||
mod test_degrees_radians;
|
||||
mod test_error_propagation;
|
||||
mod test_fn_average;
|
||||
mod test_fn_averageifs;
|
||||
@@ -40,14 +38,12 @@ mod test_metadata;
|
||||
mod test_model_cell_clear_all;
|
||||
mod test_model_is_empty_cell;
|
||||
mod test_move_formula;
|
||||
mod test_mround_trunc_int;
|
||||
mod test_quote_prefix;
|
||||
mod test_row_column_styles;
|
||||
mod test_set_user_input;
|
||||
mod test_sheet_markup;
|
||||
mod test_sheets;
|
||||
mod test_styles;
|
||||
mod test_sumsq;
|
||||
mod test_trigonometric;
|
||||
mod test_true_false;
|
||||
mod test_weekday_return_types;
|
||||
@@ -58,18 +54,12 @@ mod test_yearfrac_basis;
|
||||
pub(crate) mod util;
|
||||
|
||||
mod engineering;
|
||||
mod statistical;
|
||||
mod test_fn_offset;
|
||||
mod test_number_format;
|
||||
|
||||
mod test_arrays;
|
||||
mod test_combin_combina;
|
||||
mod test_escape_quotes;
|
||||
mod test_even_odd;
|
||||
mod test_exp_sign;
|
||||
mod test_extend;
|
||||
mod test_floor;
|
||||
mod test_fn_datevalue_timevalue;
|
||||
mod test_fn_fv;
|
||||
mod test_fn_round;
|
||||
mod test_fn_type;
|
||||
@@ -78,17 +68,12 @@ mod test_geomean;
|
||||
mod test_get_cell_content;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_issue_483;
|
||||
mod test_ln;
|
||||
mod test_log;
|
||||
mod test_log10;
|
||||
mod test_mod_quotient;
|
||||
mod test_networkdays;
|
||||
mod test_now;
|
||||
mod test_percentage;
|
||||
mod test_set_functions_error_handling;
|
||||
mod test_sheet_names;
|
||||
mod test_today;
|
||||
mod test_trigonometric_reciprocals;
|
||||
mod test_types;
|
||||
mod user_model;
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
mod test_fn_avedev;
|
||||
mod test_fn_binom;
|
||||
mod test_fn_chisq;
|
||||
mod test_fn_chisq_test;
|
||||
mod test_fn_confidence;
|
||||
mod test_fn_covariance;
|
||||
mod test_fn_devsq;
|
||||
mod test_fn_expon_dist;
|
||||
mod test_fn_f;
|
||||
mod test_fn_f_test;
|
||||
mod test_fn_fisher;
|
||||
mod test_fn_gauss;
|
||||
mod test_fn_hyp_geom_dist;
|
||||
mod test_fn_log_norm;
|
||||
mod test_fn_norm_dist;
|
||||
mod test_fn_pearson;
|
||||
mod test_fn_phi;
|
||||
mod test_fn_poisson;
|
||||
mod test_fn_stdev;
|
||||
mod test_fn_t_dist;
|
||||
mod test_fn_t_test;
|
||||
mod test_fn_var;
|
||||
mod test_fn_weibull;
|
||||
mod test_fn_z_test;
|
||||
@@ -1,40 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn smoke_test() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=STDEV.P(10, 12, 23, 23, 16, 23, 21)");
|
||||
model._set("A2", "=STDEV.S(10, 12, 23, 23, 16, 23, 21)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"5.174505793");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"5.589105048");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A2", "24");
|
||||
model._set("A3", "25");
|
||||
model._set("A4", "27");
|
||||
model._set("A5", "23");
|
||||
model._set("A6", "45");
|
||||
model._set("A7", "23.5");
|
||||
model._set("A8", "34");
|
||||
model._set("A9", "23");
|
||||
model._set("A10", "23");
|
||||
model._set("A11", "TRUE");
|
||||
model._set("A12", "'23");
|
||||
model._set("A13", "Text");
|
||||
model._set("A14", "FALSE");
|
||||
model._set("A15", "45");
|
||||
|
||||
model._set("B1", "=AVEDEV(A2:A15)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"7.25");
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_binom_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=BINOM.DIST(6, 10, 0.5, TRUE)");
|
||||
model._set("A2", "=BINOM.DIST(6, 10, 0.5, FALSE)");
|
||||
model._set("A3", "=BINOM.DIST(6, 10, 0.5)"); // wrong args
|
||||
model._set("A4", "=BINOM.DIST(6, 10, 0.5, TRUE, FALSE)"); // too many args
|
||||
model.evaluate();
|
||||
|
||||
// P(X <= 6) for X ~ Bin(10, 0.5) = 0.828125
|
||||
assert_eq!(model._get_text("A1"), *"0.828125");
|
||||
|
||||
// P(X = 6) for X ~ Bin(10, 0.5) = 0.205078125
|
||||
assert_eq!(model._get_text("A2"), *"0.205078125");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_binom_dist_range_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=BINOM.DIST.RANGE(60, 0.75, 48)");
|
||||
model._set("A2", "=BINOM.DIST.RANGE(60, 0.75, 45, 50)");
|
||||
model._set("A3", "=BINOM.DIST.RANGE(60, 1.2, 45, 50)"); // p > 1 -> #NUM!
|
||||
model._set("A4", "=BINOM.DIST.RANGE(60, 0.75, 50, 45)"); // lower > upper -> #NUM!");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.083974967");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"0.523629793");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_binom_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=BINOM.INV(6, 0.5, 0.75)");
|
||||
model._set("A2", "=BINOM.INV(6, 0.5, -0.1)"); // alpha < 0 -> #NUM!
|
||||
model._set("A3", "=BINOM.INV(6, 1.2, 0.75)"); // p > 1 -> #NUM!
|
||||
model._set("A4", "=BINOM.INV(6, 0.5)"); // args error
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"4");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_negbinom_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: PMF (non-cumulative) and CDF (cumulative)
|
||||
model._set("A1", "=NEGBINOM.DIST(10, 5, 0.25, FALSE)");
|
||||
model._set("A2", "=NEGBINOM.DIST(10, 5, 0.25, TRUE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=NEGBINOM.DIST(10, 5, 0.25)");
|
||||
model._set("A4", "=NEGBINOM.DIST(10, 5, 0.25, TRUE, FALSE)");
|
||||
|
||||
// Domain errors:
|
||||
// p < 0 or p > 1 -> #NUM!
|
||||
model._set("A5", "=NEGBINOM.DIST(10, 5, 1.5, TRUE)");
|
||||
// number_f < 0 -> #NUM!
|
||||
model._set("A6", "=NEGBINOM.DIST(-1, 5, 0.25, TRUE)");
|
||||
// number_s < 1 -> #NUM!
|
||||
model._set("A7", "=NEGBINOM.DIST(10, 0, 0.25, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.05504866");
|
||||
assert_eq!(model._get_text("A2"), *"0.313514058");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: CDF
|
||||
model._set("A1", "=CHISQ.DIST(0.5, 4, TRUE)");
|
||||
|
||||
// Valid: PDF
|
||||
model._set("A2", "=CHISQ.DIST(0.5, 4, FALSE)");
|
||||
|
||||
// Valid: CDF with numeric cumulative (1 -> TRUE)
|
||||
model._set("A3", "=CHISQ.DIST(0.5, 4, 1)");
|
||||
|
||||
// Wrong number of args -> #ERROR!
|
||||
model._set("A4", "=CHISQ.DIST(0.5, 4)");
|
||||
model._set("A5", "=CHISQ.DIST(0.5, 4, TRUE, FALSE)");
|
||||
|
||||
// Domain errors
|
||||
// x < 0 -> #NUM!
|
||||
model._set("A6", "=CHISQ.DIST(-1, 4, TRUE)");
|
||||
// deg_freedom < 1 -> #NUM!
|
||||
model._set("A7", "=CHISQ.DIST(0.5, 0, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Values for df = 4
|
||||
// CDF(0.5) ≈ 0.026499021, PDF(0.5) ≈ 0.097350098
|
||||
assert_eq!(model._get_text("A1"), *"0.026499021");
|
||||
assert_eq!(model._get_text("A2"), *"0.097350098");
|
||||
assert_eq!(model._get_text("A3"), *"0.026499021");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_dist_rt_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid calls
|
||||
model._set("A1", "=CHISQ.DIST.RT(0.5, 4)");
|
||||
model._set("A2", "=CHISQ.DIST.RT(5, 4)");
|
||||
|
||||
// Too few / too many args -> #ERROR!
|
||||
model._set("A3", "=CHISQ.DIST.RT(0.5)");
|
||||
model._set("A4", "=CHISQ.DIST.RT(0.5, 4, 1)");
|
||||
|
||||
// Domain errors
|
||||
// x < 0 -> #NUM!
|
||||
model._set("A5", "=CHISQ.DIST.RT(-1, 4)");
|
||||
// deg_freedom < 1 -> #NUM!
|
||||
model._set("A6", "=CHISQ.DIST.RT(0.5, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// For df = 4:
|
||||
// right tail at 0.5 ≈ 0.973500979
|
||||
// right tail at 5.0 ≈ 0.287297495
|
||||
assert_eq!(model._get_text("A1"), *"0.973500979");
|
||||
assert_eq!(model._get_text("A2"), *"0.287297495");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid calls
|
||||
model._set("A1", "=CHISQ.INV(0.95, 4)");
|
||||
model._set("A2", "=CHISQ.INV(0.1, 10)");
|
||||
|
||||
// Wrong number of args -> #ERROR!
|
||||
model._set("A3", "=CHISQ.INV(0.95)");
|
||||
model._set("A4", "=CHISQ.INV(0.95, 4, 1)");
|
||||
|
||||
// Domain errors
|
||||
// probability < 0 or > 1 -> #NUM!
|
||||
model._set("A5", "=CHISQ.INV(-0.1, 4)");
|
||||
model._set("A6", "=CHISQ.INV(1.1, 4)");
|
||||
// deg_freedom < 1 -> #NUM!
|
||||
model._set("A7", "=CHISQ.INV(0.5, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Standard critical values:
|
||||
// CHISQ.INV(0.95, 4) ≈ 9.487729037
|
||||
// CHISQ.INV(0.1, 10) ≈ 4.865182052
|
||||
assert_eq!(model._get_text("A1"), *"9.487729037");
|
||||
assert_eq!(model._get_text("A2"), *"4.865182052");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_inv_rt_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid calls
|
||||
model._set("A1", "=CHISQ.INV.RT(0.05, 4)");
|
||||
model._set("A2", "=CHISQ.INV.RT(0.9, 10)");
|
||||
|
||||
// Wrong number of args -> #ERROR!
|
||||
model._set("A3", "=CHISQ.INV.RT(0.05)");
|
||||
model._set("A4", "=CHISQ.INV.RT(0.05, 4, 1)");
|
||||
|
||||
// Domain errors
|
||||
// probability < 0 or > 1 -> #NUM!
|
||||
model._set("A5", "=CHISQ.INV.RT(-0.1, 4)");
|
||||
model._set("A6", "=CHISQ.INV.RT(1.1, 4)");
|
||||
// deg_freedom < 1 -> #NUM!
|
||||
model._set("A7", "=CHISQ.INV.RT(0.5, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// For chi-square:
|
||||
// CHISQ.INV.RT(0.05, 4) = CHISQ.INV(0.95, 4) ≈ 9.487729037
|
||||
// CHISQ.INV.RT(0.9, 10) = CHISQ.INV(0.1, 10) ≈ 4.865182052
|
||||
assert_eq!(model._get_text("A1"), *"9.487729037");
|
||||
assert_eq!(model._get_text("A2"), *"4.865182052");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
@@ -1,127 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_test_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "48");
|
||||
model._set("A3", "32");
|
||||
model._set("A4", "12");
|
||||
model._set("A5", "1");
|
||||
model._set("A6", "'13");
|
||||
model._set("A7", "TRUE");
|
||||
model._set("A8", "1");
|
||||
model._set("A9", "13");
|
||||
model._set("A10", "15");
|
||||
|
||||
model._set("B2", "55");
|
||||
model._set("B3", "34");
|
||||
model._set("B4", "13");
|
||||
model._set("B5", "blah");
|
||||
model._set("B6", "13");
|
||||
model._set("B7", "1");
|
||||
model._set("B8", "TRUE");
|
||||
model._set("B9", "'14");
|
||||
model._set("B10", "16");
|
||||
|
||||
model._set("C1", "=CHISQ.TEST(A2:A10, B2:B10)");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("C1"), *"0.997129538");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "TRUE");
|
||||
model._set("A3", "4");
|
||||
model._set("A4", "'3");
|
||||
model._set("B2", "2");
|
||||
model._set("B3", "2");
|
||||
model._set("B4", "2");
|
||||
model._set("C1", "=CHISQ.TEST(A2:A4, B2:B4)");
|
||||
|
||||
model._set("G5", "=CHISQ.TEST({TRUE,4,\"3\"}, {2,2,2})");
|
||||
|
||||
// 1D arrays with different shapes
|
||||
model._set("G6", "=CHISQ.TEST({1,2,3}, {3;3;4})");
|
||||
|
||||
// 2D array
|
||||
model._set("G7", "=CHISQ.TEST({1,2;3,4},{2,3;2,2})");
|
||||
|
||||
// 1D arrays with same shape
|
||||
model._set("G8", "=CHISQ.TEST({1,2,3,4}, {2,3,4,5})");
|
||||
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("C1"), *"0.367879441");
|
||||
assert_eq!(model._get_text("G5"), *"0.367879441");
|
||||
|
||||
assert_eq!(model._get_text("G6"), *"0.383531573");
|
||||
|
||||
assert_eq!(model._get_text("G7"), *"0.067889155");
|
||||
|
||||
assert_eq!(model._get_text("G8"), *"0.733094495");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn more_arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("V20", "2");
|
||||
model._set("V21", "4");
|
||||
model._set("W20", "3");
|
||||
model._set("W21", "5");
|
||||
model._set("C1", "=CHISQ.TEST({1,2;3,4},V20:W21)");
|
||||
model._set("C2", "=CHISQ.TEST({1,2;3,4}, {2,3;4,5})");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("C1"), *"0.257280177");
|
||||
assert_eq!(model._get_text("C2"), *"0.257280177");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn array_ranges() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "TRUE");
|
||||
model._set("A3", "4");
|
||||
model._set("A4", "'3");
|
||||
model._set("B2", "2");
|
||||
model._set("B3", "2");
|
||||
model._set("B4", "2");
|
||||
model._set("C1", "=CHISQ.TEST(A2:A4, {2;2;2})");
|
||||
|
||||
model._set("G5", "=CHISQ.TEST({TRUE;4;\"3\"}, B2:B4)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"0.367879441");
|
||||
assert_eq!(model._get_text("G5"), *"0.367879441");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn array_2d_ranges() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "2");
|
||||
model._set("B2", "3");
|
||||
model._set("C2", "4");
|
||||
model._set("A3", "5");
|
||||
model._set("B3", "6");
|
||||
model._set("C3", "7");
|
||||
model._set("G1", "=CHISQ.TEST({1,2,3;4,2,6}, A2:C3)");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("G1"), *"0.129195493");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ranges_1d() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "1");
|
||||
model._set("A3", "2");
|
||||
model._set("A4", "3");
|
||||
model._set("B2", "4");
|
||||
model._set("C2", "5");
|
||||
model._set("D2", "6");
|
||||
model._set("G1", "=CHISQ.TEST(A2:A4, B2:D2)");
|
||||
model._set("G2", "=CHISQ.TEST(B2:D2, A2:A4)");
|
||||
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("G1"), *"0.062349477");
|
||||
assert_eq!(model._get_text("G2"), *"0.000261259");
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_confidence_norm_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=CONFIDENCE.NORM(0.05, 2.5, 50)");
|
||||
|
||||
// Some edge/error cases
|
||||
model._set("A2", "=CONFIDENCE.NORM(0, 2.5, 50)"); // alpha <= 0 -> #NUM!
|
||||
model._set("A3", "=CONFIDENCE.NORM(1, 2.5, 50)"); // alpha >= 1 -> #NUM!
|
||||
model._set("A4", "=CONFIDENCE.NORM(0.05, -1, 50)"); // std_dev <=0 -> #NUM!
|
||||
model._set("A5", "=CONFIDENCE.NORM(0.05, 2.5, 1)");
|
||||
model._set("A6", "=CONFIDENCE.NORM(0.05, 2.5, 0.99)"); // size < 1 -> #NUM!
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.692951912");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"4.899909961");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_confidence_t_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=CONFIDENCE.T(0.05, 50000, 100)");
|
||||
|
||||
// Some edge/error cases
|
||||
model._set("A2", "=CONFIDENCE.T(0, 50000, 100)"); // alpha <= 0 -> #NUM!
|
||||
model._set("A3", "=CONFIDENCE.T(1, 50000, 100)"); // alpha >= 1 -> #NUM!
|
||||
model._set("A4", "=CONFIDENCE.T(0.05, -1, 100)");
|
||||
model._set("A5", "=CONFIDENCE.T(0.05, 50000, 1)");
|
||||
model._set("A6", "=CONFIDENCE.T(0.05, 50000, 1.7)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"9921.08475793");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#DIV/0!");
|
||||
assert_eq!(model._get_text("A6"), *"#DIV/0!");
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_covariance_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "3");
|
||||
model._set("A2", "9");
|
||||
model._set("A3", "2");
|
||||
model._set("A4", "7");
|
||||
model._set("A5", "4");
|
||||
model._set("A6", "12");
|
||||
|
||||
model._set("B1", "5");
|
||||
model._set("B2", "15");
|
||||
model._set("B3", "6");
|
||||
model._set("B4", "17");
|
||||
model._set("B5", "8");
|
||||
model._set("B6", "20");
|
||||
|
||||
model._set("C1", "=COVARIANCE.P(A1:A6, B1:B6)");
|
||||
model._set("C2", "=COVARIANCE.S(A1:A6, B1:B6)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"19.194444444");
|
||||
assert_eq!(model._get_text("C2"), *"23.033333333");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrays_mixed() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A2", "2");
|
||||
model._set("A3", "4");
|
||||
model._set("A4", "6");
|
||||
model._set("A5", "8");
|
||||
|
||||
model._set("B2", "1");
|
||||
model._set("B3", "3");
|
||||
model._set("B4", "5");
|
||||
model._set("B5", "7");
|
||||
|
||||
model._set("C1", "=COVARIANCE.P(A2:A5, {1,3,5,7})");
|
||||
model._set("C2", "=COVARIANCE.S(A2:A5, {1,3,5,7})");
|
||||
model._set("C3", "=COVARIANCE.P(A2:A5, B2:B5)");
|
||||
model._set("C4", "=COVARIANCE.S(A2:A5, B2:B5)");
|
||||
model._set("C5", "=COVARIANCE.P({2,4,6,8}, B2:B5)");
|
||||
model._set("C6", "=COVARIANCE.S({2,4,6,8}, B2:B5)");
|
||||
model._set("C7", "=COVARIANCE.P({2,4,6,8}, {1,3,5,7})");
|
||||
model._set("C8", "=COVARIANCE.S({2,4,6,8}, {1,3,5,7})");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"5");
|
||||
assert_eq!(model._get_text("C2"), *"6.666666667");
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments_smoke_test() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DEVSQ()");
|
||||
model._set("A2", "=DEVSQ(1, 2, 3)");
|
||||
model._set("A3", "=DEVSQ(1, )");
|
||||
model._set("A4", "=DEVSQ(1, , 3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"2");
|
||||
assert_eq!(model._get_text("A3"), *"0");
|
||||
assert_eq!(model._get_text("A4"), *"2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ranges() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DEVSQ(A2:A8)");
|
||||
model._set("A2", "4");
|
||||
model._set("A3", "5");
|
||||
model._set("A4", "8");
|
||||
model._set("A5", "7");
|
||||
model._set("A6", "11");
|
||||
model._set("A7", "4");
|
||||
model._set("A8", "3");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("A1"), *"48");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DEVSQ({1, 2, 3})");
|
||||
model._set("A2", "=DEVSQ({1; 2; 3})");
|
||||
model._set("A3", "=DEVSQ({1, 2; 3, 4})");
|
||||
model._set("A4", "=DEVSQ({1, 2; 3, 4; 5, 6})");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"2");
|
||||
assert_eq!(model._get_text("A3"), *"5");
|
||||
assert_eq!(model._get_text("A4"), *"17.5");
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_expon_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// λ = 1, x = 0.5
|
||||
// CDF = 1 - e^-0.5 ≈ 0.393469340
|
||||
// PDF = e^-0.5 ≈ 0.606530660
|
||||
model._set("A1", "=EXPON.DIST(0.5, 1, TRUE)");
|
||||
model._set("A2", "=EXPON.DIST(0.5, 1, FALSE)");
|
||||
|
||||
// Wrong number of args
|
||||
model._set("A3", "=EXPON.DIST(0.5, 1)");
|
||||
model._set("A4", "=EXPON.DIST(0.5, 1, TRUE, FALSE)");
|
||||
|
||||
// Domain errors
|
||||
model._set("A5", "=EXPON.DIST(-1, 1, TRUE)"); // x < 0
|
||||
model._set("A6", "=EXPON.DIST(0.5, 0, TRUE)"); // lambda <= 0
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.39346934");
|
||||
assert_eq!(model._get_text("A2"), *"0.60653066");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_f_dist_sanity() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=F.DIST(15, 6, 4, TRUE)");
|
||||
model._set("A2", "=F.DIST(15, 6, 4, FALSE)");
|
||||
model._set("A3", "=F.DIST(15, 6, 4)");
|
||||
model._set("A4", "=F.DIST(15, 6, 4, TRUE, FALSE)");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("A1"), *"0.989741952");
|
||||
assert_eq!(model._get_text("A2"), *"0.001271447");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_f_dist_rt_sanity() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid call
|
||||
model._set("A1", "=F.DIST.RT(15, 6, 4)");
|
||||
// Too few args
|
||||
model._set("A2", "=F.DIST.RT(15, 6)");
|
||||
// Too many args
|
||||
model._set("A3", "=F.DIST.RT(15, 6, 4, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.010258048");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_f_inv_sanity() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid call: left-tail inverse
|
||||
model._set("A1", "=F.INV(0.9897419523940, 6, 4)");
|
||||
|
||||
// Too many args
|
||||
model._set("A2", "=F.INV(0.5, 6, 4, 2)");
|
||||
|
||||
// Too few args
|
||||
model._set("A3", "=F.INV(0.5, 6)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"15");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_f_inv_rt_sanity() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid call: left-tail inverse
|
||||
model._set("A1", "=F.INV.RT(0.0102580476059808, 6, 4)");
|
||||
|
||||
// Too many args
|
||||
model._set("A2", "=F.INV.RT(0.5, 6, 4, 2)");
|
||||
|
||||
// Too few args
|
||||
model._set("A3", "=F.INV.RT(0.5, 6)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"15");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_f_test_sanity() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid call
|
||||
model._set("A1", "=F.TEST(A2:A7, B2:B7)");
|
||||
model._set("A2", "9");
|
||||
model._set("A3", "12");
|
||||
model._set("A4", "14");
|
||||
model._set("A5", "16");
|
||||
model._set("A6", "18");
|
||||
model._set("A7", "20");
|
||||
model._set("B2", "11");
|
||||
model._set("B3", "10");
|
||||
model._set("B4", "15");
|
||||
model._set("B5", "17");
|
||||
model._set("B6", "19");
|
||||
model._set("B7", "21");
|
||||
|
||||
// Too few args
|
||||
model._set("A8", "=F.TEST(A2:A7)");
|
||||
|
||||
// Too many args
|
||||
model._set("A9", "=F.TEST(A2:A7, B2:B7, C2:C7)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.859284302");
|
||||
assert_eq!(model._get_text("A8"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A9"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
#[test]
|
||||
fn test_fn_fisher_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid inputs
|
||||
model._set("A1", "=FISHER(0.1)");
|
||||
model._set("A2", "=FISHER(-0.5)");
|
||||
model._set("A3", "=FISHER(0.8)");
|
||||
|
||||
// Domain errors: x <= -1 or x >= 1 -> #NUM!
|
||||
model._set("A4", "=FISHER(1)");
|
||||
model._set("A5", "=FISHER(-1)");
|
||||
model._set("A6", "=FISHER(2)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A7", "=FISHER(0.1, 2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.100335348");
|
||||
assert_eq!(model._get_text("A2"), *"-0.549306144");
|
||||
assert_eq!(model._get_text("A3"), *"1.098612289");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_fisher_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid inputs
|
||||
model._set("A1", "=FISHERINV(-1.5)");
|
||||
model._set("A2", "=FISHERINV(0.5)");
|
||||
model._set("A3", "=FISHERINV(2)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A4", "=FISHERINV(0.5, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"-0.905148254");
|
||||
assert_eq!(model._get_text("A2"), *"0.462117157");
|
||||
assert_eq!(model._get_text("A3"), *"0.96402758");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_gauss_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=GAUSS(-3)");
|
||||
model._set("A2", "=GAUSS(-2.3)");
|
||||
model._set("A3", "=GAUSS(-1.7)");
|
||||
model._set("A4", "=GAUSS(0)");
|
||||
model._set("A5", "=GAUSS(0.5)");
|
||||
model._set("A6", "=GAUSS(1)");
|
||||
model._set("A7", "=GAUSS(1.3)");
|
||||
model._set("A8", "=GAUSS(3)");
|
||||
model._set("A9", "=GAUSS(4)");
|
||||
|
||||
model._set("G6", "=GAUSS()");
|
||||
model._set("G7", "=GAUSS(1, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"-0.498650102");
|
||||
assert_eq!(model._get_text("A2"), *"-0.48927589");
|
||||
assert_eq!(model._get_text("A3"), *"-0.455434537");
|
||||
assert_eq!(model._get_text("A4"), *"0");
|
||||
assert_eq!(model._get_text("A5"), *"0.191462461");
|
||||
assert_eq!(model._get_text("A6"), *"0.341344746");
|
||||
assert_eq!(model._get_text("A7"), *"0.403199515");
|
||||
assert_eq!(model._get_text("A8"), *"0.498650102");
|
||||
assert_eq!(model._get_text("A9"), *"0.499968329");
|
||||
|
||||
assert_eq!(model._get_text("G6"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("G7"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_hyp_geom_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: PDF (non-cumulative)
|
||||
model._set("A1", "=HYPGEOM.DIST(1, 4, 12, 20, FALSE)");
|
||||
|
||||
// Valid: CDF (cumulative)
|
||||
model._set("A2", "=HYPGEOM.DIST(1, 4, 12, 20, TRUE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=HYPGEOM.DIST(1, 4, 12, 20)");
|
||||
model._set("A4", "=HYPGEOM.DIST(1, 4, 12, 20, TRUE, FALSE)");
|
||||
|
||||
// Domain errors:
|
||||
// sample_s > number_sample -> #NUM!
|
||||
model._set("A5", "=HYPGEOM.DIST(5, 4, 12, 20, TRUE)");
|
||||
|
||||
// population_s > number_pop -> #NUM!
|
||||
model._set("A6", "=HYPGEOM.DIST(1, 4, 25, 20, TRUE)");
|
||||
|
||||
// number_sample > number_pop -> #NUM!
|
||||
model._set("A7", "=HYPGEOM.DIST(1, 25, 12, 20, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// PDF: P(X = 1)
|
||||
assert_eq!(model._get_text("A1"), *"0.13869969");
|
||||
|
||||
// CDF: P(X <= 1)
|
||||
assert_eq!(model._get_text("A2"), *"0.153147575");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_log_norm_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: CDF and PDF
|
||||
model._set("A1", "=LOGNORM.DIST(4, 3.5, 1.2, TRUE)");
|
||||
model._set("A2", "=LOGNORM.DIST(4, 3.5, 1.2, FALSE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=LOGNORM.DIST(4, 3.5, 1.2)");
|
||||
model._set("A4", "=LOGNORM.DIST(4, 3.5, 1.2, TRUE, FALSE)");
|
||||
|
||||
// Domain errors:
|
||||
// x <= 0 -> #NUM!
|
||||
model._set("A5", "=LOGNORM.DIST(0, 3.5, 1.2, TRUE)");
|
||||
// std_dev <= 0 -> #NUM!
|
||||
model._set("A6", "=LOGNORM.DIST(4, 3.5, 0, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.039083556");
|
||||
assert_eq!(model._get_text("A2"), *"0.017617597");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_log_norm_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid call
|
||||
model._set("A1", "=LOGNORM.INV(0.5, 3.5, 1.2)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A2", "=LOGNORM.INV(0.5, 3.5)");
|
||||
model._set("A3", "=LOGNORM.INV(0.5, 3.5, 1.2, 0)");
|
||||
|
||||
// Domain errors:
|
||||
// probability <= 0 or >= 1 -> #NUM!
|
||||
model._set("A4", "=LOGNORM.INV(0, 3.5, 1.2)");
|
||||
model._set("A5", "=LOGNORM.INV(1, 3.5, 1.2)");
|
||||
// std_dev <= 0 -> #NUM!
|
||||
model._set("A6", "=LOGNORM.INV(0.5, 3.5, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"33.115451959");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
@@ -1,119 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_norm_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: standard normal as a special case
|
||||
model._set("A1", "=NORM.DIST(1, 0, 1, TRUE)");
|
||||
model._set("A2", "=NORM.DIST(1, 0, 1, FALSE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=NORM.DIST(1, 0, 1)");
|
||||
model._set("A4", "=NORM.DIST(1, 0, 1, TRUE, FALSE)");
|
||||
|
||||
// Domain errors: standard_dev <= 0 -> #NUM!
|
||||
model._set("A5", "=NORM.DIST(1, 0, 0, TRUE)");
|
||||
model._set("A6", "=NORM.DIST(1, 0, -1, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.841344746");
|
||||
assert_eq!(model._get_text("A2"), *"0.241970725");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_norm_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: median of standard normal
|
||||
model._set("A1", "=NORM.INV(0.5, 0, 1)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A2", "=NORM.INV(0.5, 0)");
|
||||
model._set("A3", "=NORM.INV(0.5, 0, 1, 0)");
|
||||
|
||||
// Domain errors:
|
||||
// probability <= 0 or >= 1 -> #NUM!
|
||||
model._set("A4", "=NORM.INV(0, 0, 1)");
|
||||
model._set("A5", "=NORM.INV(1, 0, 1)");
|
||||
// standard_dev <= 0 -> #NUM!
|
||||
model._set("A6", "=NORM.INV(0.5, 0, 0)");
|
||||
|
||||
model._set("A7", "=NORM.INV(0.7, 0.2, 1)");
|
||||
model._set("A8", "=NORM.INV(0.7, 0.2, 5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"0.724400513");
|
||||
assert_eq!(model._get_text("A8"), *"2.822002564");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_norm_s_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: CDF and PDF at z = 0
|
||||
model._set("A1", "=NORM.S.DIST(0, TRUE)");
|
||||
model._set("A2", "=NORM.S.DIST(0, FALSE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=NORM.S.DIST(0)");
|
||||
model._set("A4", "=NORM.S.DIST(0, TRUE, FALSE)");
|
||||
|
||||
model._set("A5", "=NORM.S.DIST(0.2, FALSE)");
|
||||
model._set("A6", "=NORM.S.DIST(2.2, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.5");
|
||||
assert_eq!(model._get_text("A2"), *"0.39894228");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A5"), *"0.391042694");
|
||||
assert_eq!(model._get_text("A6"), *"0.986096552");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_norm_s_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: symmetric points
|
||||
model._set("A1", "=NORM.S.INV(0.5)");
|
||||
model._set("A2", "=NORM.S.INV(0.841344746)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=NORM.S.INV()");
|
||||
model._set("A4", "=NORM.S.INV(0.5, 0)");
|
||||
|
||||
// Domain errors: probability <= 0 or >= 1 -> #NUM!
|
||||
model._set("A5", "=NORM.S.INV(0)");
|
||||
model._set("A6", "=NORM.S.INV(1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0");
|
||||
// Approximately 1
|
||||
assert_eq!(model._get_text("A2"), *"1");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_chisq_test_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "48");
|
||||
model._set("A3", "32");
|
||||
model._set("A4", "12");
|
||||
model._set("A5", "1");
|
||||
model._set("A6", "'13");
|
||||
model._set("A7", "TRUE");
|
||||
model._set("A8", "1");
|
||||
model._set("A9", "13");
|
||||
model._set("A10", "15");
|
||||
|
||||
model._set("B2", "55");
|
||||
model._set("B3", "34");
|
||||
model._set("B4", "13");
|
||||
model._set("B5", "blah");
|
||||
model._set("B6", "13");
|
||||
model._set("B7", "1");
|
||||
model._set("B8", "TRUE");
|
||||
model._set("B9", "'14");
|
||||
model._set("B10", "16");
|
||||
|
||||
model._set("C1", "=PEARSON(A2:A10, B2:B10)");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("C1"), *"0.998381439");
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_phi_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=PHI(0)");
|
||||
model._set("A2", "=PHI(1)");
|
||||
model._set("A3", "=PHI(-1)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A4", "=PHI()");
|
||||
model._set("A5", "=PHI(0, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Standard values
|
||||
assert_eq!(model._get_text("A1"), *"0.39894228");
|
||||
assert_eq!(model._get_text("A2"), *"0.241970725");
|
||||
assert_eq!(model._get_text("A3"), *"0.241970725");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_poisson_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// λ = 2, x = 3
|
||||
// P(X = 3) ≈ 0.180447045
|
||||
// P(X <= 3) ≈ 0.857123461
|
||||
model._set("A1", "=POISSON.DIST(3, 2, FALSE)");
|
||||
model._set("A2", "=POISSON.DIST(3, 2, TRUE)");
|
||||
|
||||
// Wrong arg count
|
||||
model._set("A3", "=POISSON.DIST(3, 2)");
|
||||
model._set("A4", "=POISSON.DIST(3, 2, TRUE, FALSE)");
|
||||
|
||||
// Domain errors
|
||||
model._set("A5", "=POISSON.DIST(-1, 2, TRUE)"); // x < 0
|
||||
model._set("A6", "=POISSON.DIST(3, -2, TRUE)"); // mean < 0
|
||||
|
||||
// λ = 0 special cases
|
||||
model._set("A7", "=POISSON.DIST(0, 0, FALSE)"); // 1
|
||||
model._set("A8", "=POISSON.DIST(1, 0, FALSE)"); // 0
|
||||
model._set("A9", "=POISSON.DIST(5, 0, TRUE)"); // 1
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.180447044");
|
||||
assert_eq!(model._get_text("A2"), *"0.85712346");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
|
||||
assert_eq!(model._get_text("A7"), *"1");
|
||||
assert_eq!(model._get_text("A8"), *"0");
|
||||
assert_eq!(model._get_text("A9"), *"1");
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn smoke_test() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=STDEV.P(10, 12, 23, 23, 16, 23, 21)");
|
||||
model._set("A2", "=STDEV.S(10, 12, 23, 23, 16, 23, 21)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"5.174505793");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"5.589105048");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A2", "24");
|
||||
model._set("A3", "25");
|
||||
model._set("A4", "27");
|
||||
model._set("A5", "23");
|
||||
model._set("A6", "45");
|
||||
model._set("A7", "23.5");
|
||||
model._set("A8", "34");
|
||||
model._set("A9", "23");
|
||||
model._set("A10", "23");
|
||||
model._set("A11", "TRUE");
|
||||
model._set("A12", "'23");
|
||||
model._set("A13", "Text");
|
||||
model._set("A14", "FALSE");
|
||||
model._set("A15", "45");
|
||||
|
||||
model._set("B1", "=STDEV.P(A2:A15)");
|
||||
model._set("B2", "=STDEV.S(A2:A15)");
|
||||
model._set("B3", "=STDEVA(A2:A15)");
|
||||
model._set("B4", "=STDEVPA(A2:A15)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"8.483071378");
|
||||
assert_eq!(model._get_text("B2"), *"8.941942369");
|
||||
assert_eq!(model._get_text("B3"), *"15.499955689");
|
||||
assert_eq!(model._get_text("B4"), *"14.936131032");
|
||||
}
|
||||
@@ -1,160 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_t_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: cumulative (left-tail CDF)
|
||||
model._set("A1", "=T.DIST(2, 10, TRUE)");
|
||||
// Valid: probability density function (PDF)
|
||||
model._set("B1", "=T.DIST(2, 10, FALSE)");
|
||||
|
||||
// Wrong number of arguments
|
||||
model._set("A2", "=T.DIST(2, 10)");
|
||||
model._set("A3", "=T.DIST(2, 10, TRUE, FALSE)");
|
||||
|
||||
// Domain error: df < 1 -> #NUM!
|
||||
model._set("A4", "=T.DIST(2, 0, TRUE)");
|
||||
model._set("A5", "=T.DIST(2, -1, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.963305983");
|
||||
assert_eq!(model._get_text("B1"), *"0.061145766");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_t_dist_rt_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: right tail probability
|
||||
model._set("A1", "=T.DIST.RT(2, 10)");
|
||||
|
||||
// Wrong number of arguments
|
||||
model._set("A2", "=T.DIST.RT(2)");
|
||||
model._set("A3", "=T.DIST.RT(2, 10, TRUE)");
|
||||
|
||||
// Domain error: df < 1
|
||||
model._set("A4", "=T.DIST.RT(2, 0)");
|
||||
model._set("A5", "=T.DIST.RT(2, -1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.036694017");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_t_dist_2t_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: two-tailed probability
|
||||
model._set("A1", "=T.DIST.2T(2, 10)");
|
||||
|
||||
// In the limit case of x = 0, the two-tailed probability is 1.0
|
||||
model._set("A4", "=T.DIST.2T(0, 10)");
|
||||
|
||||
// Wrong number of arguments
|
||||
model._set("A2", "=T.DIST.2T(2)");
|
||||
model._set("A3", "=T.DIST.2T(2, 10, TRUE)");
|
||||
|
||||
// Domain errors:
|
||||
// x < 0 -> #NUM!
|
||||
model._set("A5", "=T.DIST.2T(-0.001, 10)");
|
||||
// df < 1 -> #NUM!
|
||||
model._set("A6", "=T.DIST.2T(2, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.073388035");
|
||||
assert_eq!(model._get_text("A4"), *"1");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_t_inv_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: upper and lower tail
|
||||
model._set("A1", "=T.INV(0.95, 10)");
|
||||
model._set("A2", "=T.INV(0.05, 10)");
|
||||
// limit case:
|
||||
model._set("B2", "=T.INV(0.95, 1)");
|
||||
|
||||
// Wrong number of arguments
|
||||
model._set("A3", "=T.INV(0.95)");
|
||||
model._set("A4", "=T.INV(0.95, 10, 1)");
|
||||
|
||||
// Domain errors:
|
||||
// p <= 0 or >= 1
|
||||
model._set("A5", "=T.INV(0, 10)");
|
||||
model._set("A6", "=T.INV(1, 10)");
|
||||
// df < 1
|
||||
model._set("A7", "=T.INV(0.95, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"1.812461123");
|
||||
assert_eq!(model._get_text("A2"), *"-1.812461123");
|
||||
assert_eq!(model._get_text("B2"), *"6.313751515");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fn_t_inv_2t_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: two-tailed critical values
|
||||
model._set("A1", "=T.INV.2T(0.1, 10)");
|
||||
model._set("A2", "=T.INV.2T(0.05, 10)");
|
||||
|
||||
// p = 1 should give t = 0 (both tails outside are 1.0, so cut at the mean)
|
||||
model._set("A3", "=T.INV.2T(1, 10)");
|
||||
|
||||
model._set("A7", "=T.INV.2T(1.5, 10)");
|
||||
|
||||
// Wrong number of arguments
|
||||
model._set("A4", "=T.INV.2T(0.1)");
|
||||
model._set("A5", "=T.INV.2T(0.1, 10, 1)");
|
||||
|
||||
// Domain errors:
|
||||
// p <= 0 or p > 1
|
||||
model._set("A6", "=T.INV.2T(0, 10)");
|
||||
// df < 1
|
||||
model._set("A8", "=T.INV.2T(0.1, 0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"1.812461123");
|
||||
assert_eq!(model._get_text("A2"), *"2.228138852");
|
||||
assert_eq!(model._get_text("A3"), *"0");
|
||||
|
||||
// NB: Excel returns -0.699812061 for T.INV.2T(1.5, 10)
|
||||
// which seems inconsistent with its documented behavior
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A8"), *"#NUM!");
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
use crate::test::util::new_empty_model;
|
||||
#[test]
|
||||
fn test_fn_t_test_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "3");
|
||||
model._set("A3", "4");
|
||||
model._set("A4", "5");
|
||||
model._set("A5", "6");
|
||||
model._set("A6", "10");
|
||||
model._set("A7", "3");
|
||||
model._set("A8", "2");
|
||||
model._set("A9", "4");
|
||||
model._set("A10", "7");
|
||||
|
||||
model._set("B2", "6");
|
||||
model._set("B3", "19");
|
||||
model._set("B4", "3");
|
||||
model._set("B5", "2");
|
||||
model._set("B6", "13");
|
||||
model._set("B7", "4");
|
||||
model._set("B8", "5");
|
||||
model._set("B9", "17");
|
||||
model._set("B10", "3");
|
||||
|
||||
model._set("C1", "=T.TEST(A2:A10, B2:B10, 1, 1)");
|
||||
model._set("C2", "=T.TEST(A2:A10, B2:B10, 1, 2)");
|
||||
model._set("C3", "=T.TEST(A2:A10, B2:B10, 1, 3)");
|
||||
model._set("C4", "=T.TEST(A2:A10, B2:B10, 2, 1)");
|
||||
model._set("C5", "=T.TEST(A2:A10, B2:B10, 2, 2)");
|
||||
model._set("C6", "=T.TEST(A2:A10, B2:B10, 2, 3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"0.103836888");
|
||||
assert_eq!(model._get_text("C2"), *"0.100244599");
|
||||
assert_eq!(model._get_text("C3"), *"0.105360319");
|
||||
assert_eq!(model._get_text("C4"), *"0.207673777");
|
||||
assert_eq!(model._get_text("C5"), *"0.200489197");
|
||||
assert_eq!(model._get_text("C6"), *"0.210720639");
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn smoke_test() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=STDEV.P(10, 12, 23, 23, 16, 23, 21)");
|
||||
model._set("A2", "=STDEV.S(10, 12, 23, 23, 16, 23, 21)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"5.174505793");
|
||||
|
||||
assert_eq!(model._get_text("A2"), *"5.589105048");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A2", "24");
|
||||
model._set("A3", "25");
|
||||
model._set("A4", "27");
|
||||
model._set("A5", "23");
|
||||
model._set("A6", "45");
|
||||
model._set("A7", "23.5");
|
||||
model._set("A8", "34");
|
||||
model._set("A9", "23");
|
||||
model._set("A10", "23");
|
||||
model._set("A11", "TRUE");
|
||||
model._set("A12", "'23");
|
||||
model._set("A13", "Text");
|
||||
model._set("A14", "FALSE");
|
||||
model._set("A15", "45");
|
||||
|
||||
model._set("B1", "=VAR.P(A2:A15)");
|
||||
model._set("B2", "=VAR.S(A2:A15)");
|
||||
model._set("B3", "=VARA(A2:A15)");
|
||||
model._set("B4", "=VARPA(A2:A15)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"71.9625");
|
||||
assert_eq!(model._get_text("B2"), *"79.958333333");
|
||||
assert_eq!(model._get_text("B3"), *"240.248626374");
|
||||
assert_eq!(model._get_text("B4"), *"223.088010204");
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_weibull_dist_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Valid: CDF and PDF for x = 1, alpha = 2, beta = 1
|
||||
model._set("A1", "=WEIBULL.DIST(1, 2, 1, TRUE)");
|
||||
model._set("A2", "=WEIBULL.DIST(1, 2, 1, FALSE)");
|
||||
|
||||
// Wrong number of arguments -> #ERROR!
|
||||
model._set("A3", "=WEIBULL.DIST(1, 2, 1)");
|
||||
model._set("A4", "=WEIBULL.DIST(1, 2, 1, TRUE, FALSE)");
|
||||
|
||||
// Domain errors:
|
||||
// x < 0 -> #NUM!
|
||||
model._set("A5", "=WEIBULL.DIST(-1, 2, 1, TRUE)");
|
||||
// alpha <= 0 -> #NUM!
|
||||
model._set("A6", "=WEIBULL.DIST(1, 0, 1, TRUE)");
|
||||
model._set("A7", "=WEIBULL.DIST(1, -1, 1, TRUE)");
|
||||
// beta <= 0 -> #NUM!
|
||||
model._set("A8", "=WEIBULL.DIST(1, 2, 0, TRUE)");
|
||||
model._set("A9", "=WEIBULL.DIST(1, 2, -1, TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// 1 - e^-1
|
||||
assert_eq!(model._get_text("A1"), *"0.632120559");
|
||||
// 2 * e^-1
|
||||
assert_eq!(model._get_text("A2"), *"0.735758882");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A8"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A9"), *"#NUM!");
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_z_test_smoke() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "3");
|
||||
model._set("A3", "6");
|
||||
model._set("A4", "7");
|
||||
model._set("A5", "8");
|
||||
model._set("A6", "6");
|
||||
model._set("A7", "5");
|
||||
model._set("A8", "4");
|
||||
model._set("A9", "2");
|
||||
model._set("A10", "1");
|
||||
model._set("A11", "9");
|
||||
|
||||
model._set("G1", "=Z.TEST(A2:A11, 4)");
|
||||
model._set("G2", "=Z.TEST(A2:A11, 6)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("G1"), *"0.090574197");
|
||||
assert_eq!(model._get_text("G2"), *"0.863043389");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("D1", "=Z.TEST({5,2,3,4}, 4, 123)");
|
||||
model._set("D2", "=Z.TEST({5,2,3,4}, 4)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("D1"), *"0.503243397");
|
||||
assert_eq!(model._get_text("D2"), *"0.780710987");
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=ARABIC()");
|
||||
model._set("A2", "=ARABIC(\"V\")");
|
||||
model._set("A3", "=ARABIC(\"V\", 2)");
|
||||
|
||||
model._set("A4", "=ROMAN()");
|
||||
model._set("A5", "=ROMAN(5)");
|
||||
model._set("A6", "=ROMAN(5, 0)");
|
||||
model._set("A7", "=ROMAN(5, 0, 2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"5");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"V");
|
||||
assert_eq!(model._get_text("A6"), *"V");
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=CELL("address",A1)");
|
||||
model._set("A2", "=CELL()");
|
||||
|
||||
model._set("A3", "=INFO("system")");
|
||||
model._set("A4", "=INFO()");
|
||||
|
||||
model._set("A5", "=N(TRUE)");
|
||||
model._set("A6", "=N()");
|
||||
model._set("A7", "=N(1, 2)");
|
||||
|
||||
model._set("A8", "=SHEETS()");
|
||||
model._set("A9", "=SHEETS(1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"$A$1");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A5"), *"1");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A8"), *"1");
|
||||
assert_eq!(model._get_text("A9"), *"#N/IMPL!");
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=COMBIN(5,2)");
|
||||
model._set("A2", "=COMBINA(5,2)");
|
||||
model._set("A3", "=COMBIN()");
|
||||
model._set("A4", "=COMBINA()");
|
||||
model._set("A5", "=COMBIN(2)");
|
||||
model._set("A6", "=COMBINA(2)");
|
||||
model._set("A7", "=COMBIN(1, 2, 3)");
|
||||
model._set("A8", "=COMBINA(1, 2, 3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"10");
|
||||
assert_eq!(model._get_text("A2"), *"15");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A8"), *"#ERROR!");
|
||||
}
|
||||
@@ -542,6 +542,7 @@ fn test_yearfrac_function() {
|
||||
|
||||
// Edge cases
|
||||
model._set("A4", "=YEARFRAC(44561,44561,1)"); // Same date = 0
|
||||
model._set("A5", "=YEARFRAC(44926,44561,1)"); // Reverse = negative
|
||||
model._set("A6", "=YEARFRAC(44197,44562,1)"); // Exact year (2021)
|
||||
|
||||
// Error cases
|
||||
@@ -558,6 +559,7 @@ fn test_yearfrac_function() {
|
||||
|
||||
// Edge cases
|
||||
assert_eq!(model._get_text("A4"), *"0"); // Same date
|
||||
assert_eq!(model._get_text("A5"), *"-1"); // Negative
|
||||
assert_eq!(model._get_text("A6"), *"1"); // Exact year
|
||||
|
||||
// Error cases
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_degrees_radians_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DEGREES()");
|
||||
model._set("A2", "=RADIANS()");
|
||||
model._set("A3", "=RADIANS(180)");
|
||||
model._set("A4", "=RADIANS(180, 2)");
|
||||
model._set("A5", "=DEGREES(RADIANS(180))");
|
||||
model._set("A6", "=DEGREES(1, 2)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"3.141592654");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"180");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=EVEN(2)");
|
||||
model._set("A2", "=ODD(2)");
|
||||
model._set("A3", "=EVEN()");
|
||||
model._set("A4", "=ODD()");
|
||||
model._set("A5", "=EVEN(1, 2)");
|
||||
model._set("A6", "=ODD(1, 2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"3");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=EXP()");
|
||||
model._set("A2", "=SIGN()");
|
||||
|
||||
model._set("A3", "=EXP(0)");
|
||||
model._set("A4", "=SIGN(-10)");
|
||||
|
||||
model._set("A5", "=EXP(1, 2)");
|
||||
model._set("A6", "=SIGN(1, 2)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"1");
|
||||
assert_eq!(model._get_text("A4"), *"-1");
|
||||
|
||||
assert_eq!(model._get_text("A5"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user