FIX: Uses lookup tables and lngamma for large numbers

Fixes #574

base/examples/formulas_and_errors.rs

@@ -1,7 +1,7 @@
 use ironcalc_base::{types::CellType, Model};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut model = Model::new_empty("formulas-and-errors", "en", "UTC", "en")?;
+    let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
     // A1
     model.set_user_input(0, 1, 1, "1".to_string())?;
     // A2

base/examples/hello_world.rs

@@ -1,7 +1,7 @@
 use ironcalc_base::{cell::CellValue, Model};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut model = Model::new_empty("hello-world", "en", "UTC", "en")?;
+    let mut model = Model::new_empty("hello-world", "en", "UTC")?;
     // A1
     model.set_user_input(0, 1, 1, "Hello".to_string())?;
     // B1

base/src/actions.rs

@@ -1,7 +1,5 @@
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::stringify::{
-    to_localized_string, to_string_displaced, DisplaceData,
-};
+use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
 use crate::expressions::types::CellReferenceRC;
 use crate::model::Model;
 
@@ -10,7 +8,7 @@ use crate::model::Model;
 // In IronCalc, if one of the edges of the range is deleted will replace the edge with #REF!
 // I feel this is unimportant for now.
 
-impl<'a> Model<'a> {
+impl Model {
     fn shift_cell_formula(
         &mut self,
         sheet: u32,
@@ -31,7 +29,7 @@ impl<'a> Model<'a> {
                 column,
             };
             // FIXME: This is not a very performant way if the formula has changed :S.
-            let formula = to_localized_string(node, &cell_reference, self.locale, self.language);
+            let formula = to_string(node, &cell_reference);
             let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
             if formula != formula_displaced {
                 self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
@@ -110,9 +108,7 @@ impl<'a> Model<'a> {
         // FIXME: we need some user_input getter instead of get_text
         let formula_or_value = self
             .get_cell_formula(sheet, source_row, source_column)?
-            .unwrap_or_else(|| {
-                source_cell.get_localized_text(&self.workbook.shared_strings, self.language)
-            });
+            .unwrap_or_else(|| source_cell.get_text(&self.workbook.shared_strings, &self.language));
         self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
         self.workbook
             .worksheet_mut(sheet)?
@@ -494,11 +490,9 @@ impl<'a> Model<'a> {
                 .cell(r.row, column)
                 .ok_or("Expected Cell to exist")?;
             let style_idx = cell.get_style();
-            let formula_or_value =
-                self.get_cell_formula(sheet, r.row, column)?
-                    .unwrap_or_else(|| {
-                        cell.get_localized_text(&self.workbook.shared_strings, self.language)
-                    });
+            let formula_or_value = self
+                .get_cell_formula(sheet, r.row, column)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
             original_cells.push((r.row, formula_or_value, style_idx));
             self.cell_clear_all(sheet, r.row, column)?;
         }
@@ -583,9 +577,9 @@ impl<'a> Model<'a> {
                 .cell(row, *c)
                 .ok_or("Expected Cell to exist")?;
             let style_idx = cell.get_style();
-            let formula_or_value = self.get_cell_formula(sheet, row, *c)?.unwrap_or_else(|| {
-                cell.get_localized_text(&self.workbook.shared_strings, self.language)
-            });
+            let formula_or_value = self
+                .get_cell_formula(sheet, row, *c)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
             original_cells.push((*c, formula_or_value, style_idx));
             self.cell_clear_all(sheet, row, *c)?;
         }

base/src/arithmetic.rs

@@ -22,7 +22,7 @@ fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
     }
 }
 
-impl<'a> Model<'a> {
+impl Model {
     /// Applies `op` element‐wise for arrays/numbers.
     pub(crate) fn handle_arithmetic(
         &mut self,

base/src/cast.rs

@@ -14,7 +14,7 @@ pub(crate) enum NumberOrArray {
     Array(Vec<Vec<ArrayNode>>),
 }
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
         match s.trim().parse::<f64>() {
             Ok(f) => Some(f),
@@ -24,16 +24,8 @@ impl<'a> Model<'a> {
                 if !currencies.iter().any(|e| *e == currency) {
                     currencies.push(currency);
                 }
-                let (decimal_separator, group_separator) =
-                    if self.locale.numbers.symbols.decimal == "," {
-                        (b',', b'.')
-                    } else {
-                        (b'.', b',')
-                    };
                 // Try to parse as a formatted number (e.g., dates, currencies, percentages)
-                if let Ok((v, _number_format)) =
-                    parse_formatted_number(s, &currencies, decimal_separator, group_separator)
-                {
+                if let Ok((v, _number_format)) = parse_formatted_number(s, &currencies) {
                     return Some(v);
                 }
                 None

base/src/cell.rs

@@ -122,17 +122,11 @@ impl Cell {
         }
     }
 
-    pub fn get_localized_text(&self, shared_strings: &[String], language: &Language) -> String {
+    pub fn get_text(&self, shared_strings: &[String], language: &Language) -> String {
         match self.value(shared_strings, language) {
             CellValue::None => "".to_string(),
             CellValue::String(v) => v,
-            CellValue::Boolean(v) => {
-                if v {
-                    language.booleans.r#true.to_string()
-                } else {
-                    language.booleans.r#false.to_string()
-                }
-            }
+            CellValue::Boolean(v) => v.to_string().to_uppercase(),
             CellValue::Number(v) => to_excel_precision_str(v),
         }
     }
@@ -177,13 +171,7 @@ impl Cell {
         match self.value(shared_strings, language) {
             CellValue::None => "".to_string(),
             CellValue::String(value) => value,
-            CellValue::Boolean(value) => {
-                if value {
-                    language.booleans.r#true.to_string()
-                } else {
-                    language.booleans.r#false.to_string()
-                }
-            }
+            CellValue::Boolean(value) => value.to_string().to_uppercase(),
             CellValue::Number(value) => format_number(value),
         }
     }

base/src/constants.rs

@@ -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

base/src/expressions/lexer/mod.rs

@@ -79,24 +79,19 @@ pub enum LexerMode {
 
 /// Tokenize an input
 #[derive(Clone)]
-pub struct Lexer<'a> {
+pub struct Lexer {
     position: usize,
     next_token_position: Option<usize>,
     len: usize,
     chars: Vec<char>,
     mode: LexerMode,
-    locale: &'a Locale,
-    language: &'a Language,
+    locale: Locale,
+    language: Language,
 }
 
-impl<'a> Lexer<'a> {
+impl Lexer {
     /// Creates a new `Lexer` that returns the tokens of a formula.
-    pub fn new(
-        formula: &str,
-        mode: LexerMode,
-        locale: &'a Locale,
-        language: &'a Language,
-    ) -> Lexer<'a> {
+    pub fn new(formula: &str, mode: LexerMode, locale: &Locale, language: &Language) -> Lexer {
         let chars: Vec<char> = formula.chars().collect();
         let len = chars.len();
         Lexer {
@@ -105,8 +100,8 @@ impl<'a> Lexer<'a> {
             next_token_position: None,
             len,
             mode,
-            locale,
-            language,
+            locale: locale.clone(),
+            language: language.clone(),
         }
     }
 
@@ -115,16 +110,6 @@ impl<'a> Lexer<'a> {
         self.mode = mode;
     }
 
-    /// Sets the locale
-    pub fn set_locale(&mut self, locale: &'a Locale) {
-        self.locale = locale;
-    }
-
-    /// Sets the language
-    pub fn set_language(&mut self, language: &'a Language) {
-        self.language = language;
-    }
-
     // FIXME: I don't think we should have `is_a1_mode` and   `get_formula`.
     // The caller already knows those two
 
@@ -203,7 +188,6 @@ impl<'a> Lexer<'a> {
                     ':' => TokenType::Colon,
                     ';' => TokenType::Semicolon,
                     '@' => TokenType::At,
-                    '\\' => TokenType::Backslash,
                     ',' => {
                         if self.locale.numbers.symbols.decimal == "," {
                             match self.consume_number(',') {

base/src/expressions/lexer/ranges.rs

@@ -4,7 +4,7 @@ use crate::expressions::{token::TokenType, utils::column_to_number};
 use super::Lexer;
 use super::{ParsedRange, ParsedReference, Result};
 
-impl<'a> Lexer<'a> {
+impl Lexer {
     /// Consumes a reference in A1 style like:
     /// AS23, $AS23, AS$23, $AS$23, R12
     /// Or returns an error

base/src/expressions/lexer/structured_references.rs

@@ -16,7 +16,7 @@ use crate::expressions::token::{TableReference, TableSpecifier};
 use super::Result;
 use super::{Lexer, LexerError};
 
-impl<'a> Lexer<'a> {
+impl Lexer {
     fn consume_table_specifier(&mut self) -> Result<Option<TableSpecifier>> {
         if self.peek_char() == Some('#') {
             // It's a specifier

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

@@ -11,7 +11,7 @@ use crate::expressions::{
     types::ParsedReference,
 };
 
-fn new_lexer(formula: &str, a1_mode: bool) -> Lexer<'_> {
+fn new_lexer(formula: &str, a1_mode: bool) -> Lexer {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     let mode = if a1_mode {
@@ -655,9 +655,7 @@ fn test_comma() {
 
     // Used for testing locales where the comma is the decimal separator
     let mut lx = new_lexer("12,34", false);
-    let locale = get_locale("de").unwrap();
-    lx.locale = locale;
-
+    lx.locale.numbers.symbols.decimal = ",".to_string();
     assert_eq!(lx.next_token(), Number(12.34));
     assert_eq!(lx.next_token(), EOF);
 }

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

@@ -7,7 +7,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer<'_> {
+fn new_lexer(formula: &str) -> Lexer {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

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

@@ -6,11 +6,11 @@ use crate::{
         token::{Error, TokenType},
     },
     language::get_language,
-    locale::get_default_locale,
+    locale::get_locale,
 };
 
-fn new_language_lexer<'a>(formula: &str, language: &str) -> Lexer<'a> {
-    let locale = get_default_locale();
+fn new_language_lexer(formula: &str, language: &str) -> Lexer {
+    let locale = get_locale("en").unwrap();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)
 }

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

@@ -9,7 +9,7 @@ use crate::{
     locale::get_locale,
 };
 
-fn new_language_lexer<'a>(formula: &str, locale: &str, language: &str) -> Lexer<'a> {
+fn new_language_lexer(formula: &str, locale: &str, language: &str) -> Lexer {
     let locale = get_locale(locale).unwrap();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

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

@@ -10,7 +10,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer<'_> {
+fn new_lexer(formula: &str) -> Lexer {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

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

@@ -7,7 +7,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer<'_> {
+fn new_lexer(formula: &str) -> Lexer {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

base/src/expressions/parser/mod.rs

@@ -31,12 +31,8 @@ f_args  => e (',' e)*
 use std::collections::HashMap;
 
 use crate::functions::Function;
-use crate::language::get_default_language;
 use crate::language::get_language;
-use crate::language::Language;
-use crate::locale::get_default_locale;
 use crate::locale::get_locale;
-use crate::locale::Locale;
 use crate::types::Table;
 
 use super::lexer;
@@ -206,35 +202,28 @@ pub enum Node {
 }
 
 #[derive(Clone)]
-pub struct Parser<'a> {
-    lexer: lexer::Lexer<'a>,
+pub struct Parser {
+    lexer: lexer::Lexer,
     worksheets: Vec<String>,
     defined_names: Vec<DefinedNameS>,
     context: CellReferenceRC,
     tables: HashMap<String, Table>,
-    locale: &'a Locale,
-    language: &'a Language,
 }
 
-pub fn new_parser_english<'a>(
-    worksheets: Vec<String>,
-    defined_names: Vec<DefinedNameS>,
-    tables: HashMap<String, Table>,
-) -> Parser<'a> {
-    let locale = get_default_locale();
-    let language = get_default_language();
-    Parser::new(worksheets, defined_names, tables, locale, language)
-}
-
-impl<'a> Parser<'a> {
+impl Parser {
     pub fn new(
         worksheets: Vec<String>,
         defined_names: Vec<DefinedNameS>,
         tables: HashMap<String, Table>,
-        locale: &'a Locale,
-        language: &'a Language,
-    ) -> Parser<'a> {
-        let lexer = lexer::Lexer::new("", lexer::LexerMode::A1, locale, language);
+    ) -> Parser {
+        let lexer = lexer::Lexer::new(
+            "",
+            lexer::LexerMode::A1,
+            #[allow(clippy::expect_used)]
+            get_locale("en").expect(""),
+            #[allow(clippy::expect_used)]
+            get_language("en").expect(""),
+        );
         let context = CellReferenceRC {
             sheet: worksheets.first().map_or("", |v| v).to_string(),
             column: 1,
@@ -246,24 +235,12 @@ impl<'a> Parser<'a> {
             defined_names,
             context,
             tables,
-            locale,
-            language,
         }
     }
     pub fn set_lexer_mode(&mut self, mode: lexer::LexerMode) {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_locale(&mut self, locale: &'a Locale) {
-        self.locale = locale;
-        self.lexer.set_locale(locale);
-    }
-
-    pub fn set_language(&mut self, language: &'a Language) {
-        self.language = language;
-        self.lexer.set_language(language);
-    }
-
     pub fn set_worksheets_and_names(
         &mut self,
         worksheets: Vec<String>,
@@ -279,27 +256,6 @@ impl<'a> Parser<'a> {
         self.parse_expr()
     }
 
-    // Returns the token used to separate arguments in functions and arrays
-    // If the locale decimal separator is '.', then it is a comma ','
-    // Otherwise, it is a semicolon ';'
-    fn get_argument_separator_token(&self) -> TokenType {
-        if self.locale.numbers.symbols.decimal == "." {
-            TokenType::Comma
-        } else {
-            TokenType::Semicolon
-        }
-    }
-
-    // Returns the token used to separate columns in arrays
-    // If the locale decimal separator is '.', then it is a semicolon ';'
-    fn get_column_separator_token(&self) -> TokenType {
-        if self.locale.numbers.symbols.decimal == "." {
-            TokenType::Semicolon
-        } else {
-            TokenType::Backslash
-        }
-    }
-
     fn get_sheet_index_by_name(&self, name: &str) -> Option<u32> {
         let worksheets = &self.worksheets;
         for (i, sheet) in worksheets.iter().enumerate() {
@@ -508,7 +464,6 @@ impl<'a> Parser<'a> {
 
     fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
         let mut row = Vec::new();
-        let column_separator_token = self.get_argument_separator_token();
         // and array can only have numbers, string or booleans
         // otherwise it is a syntax error
         let first_element = match self.parse_expr() {
@@ -516,20 +471,6 @@ impl<'a> Parser<'a> {
             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 {
@@ -541,27 +482,14 @@ impl<'a> Parser<'a> {
         };
         row.push(first_element);
         let mut next_token = self.lexer.peek_token();
-        while next_token == column_separator_token {
+        // FIXME: this is not respecting the locale
+        while next_token == TokenType::Comma {
             self.lexer.advance_token();
             let value = match self.parse_expr() {
                 Node::BooleanKind(s) => ArrayNode::Boolean(s),
                 Node::NumberKind(s) => ArrayNode::Number(s),
                 Node::StringKind(s) => ArrayNode::String(s),
                 Node::ErrorKind(kind) => ArrayNode::Error(kind),
-                Node::UnaryKind {
-                    kind: OpUnary::Minus,
-                    right,
-                } => {
-                    if let Node::NumberKind(n) = *right {
-                        ArrayNode::Number(-n)
-                    } else {
-                        return Err(Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            message: "Invalid value in array".to_string(),
-                            position: self.lexer.get_position() as usize,
-                        });
-                    }
-                }
                 error @ Node::ParseErrorKind { .. } => return Err(error),
                 _ => {
                     return Err(Node::ParseErrorKind {
@@ -599,7 +527,6 @@ impl<'a> Parser<'a> {
             TokenType::String(s) => Node::StringKind(s),
             TokenType::LeftBrace => {
                 // It's an array. It's a collection of rows all of the same dimension
-                let column_separator_token = self.get_column_separator_token();
 
                 let first_row = match self.parse_array_row() {
                     Ok(s) => s,
@@ -609,8 +536,9 @@ impl<'a> Parser<'a> {
 
                 let mut matrix = Vec::new();
                 matrix.push(first_row);
+                // FIXME: this is not respecting the locale
                 let mut next_token = self.lexer.peek_token();
-                while next_token == column_separator_token {
+                while next_token == TokenType::Semicolon {
                     self.lexer.advance_token();
                     let row = match self.parse_array_row() {
                         Ok(s) => s,
@@ -759,7 +687,12 @@ impl<'a> Parser<'a> {
                             message: err.message,
                         };
                     }
-                    // We should do this *only* importing functions from xlsx
+                    if let Some(function_kind) = Function::get_function(&name) {
+                        return Node::FunctionKind {
+                            kind: function_kind,
+                            args,
+                        };
+                    }
                     if &name == "_xlfn.SINGLE" {
                         if args.len() != 1 {
                             return Node::ParseErrorKind {
@@ -774,17 +707,6 @@ impl<'a> Parser<'a> {
                             child: Box::new(args[0].clone()),
                         };
                     }
-                    // We should do this *only* importing functions from xlsx
-                    if let Some(function_kind) = self
-                        .language
-                        .functions
-                        .lookup(name.trim_start_matches("_xlfn."))
-                    {
-                        return Node::FunctionKind {
-                            kind: function_kind,
-                            args,
-                        };
-                    }
                     return Node::InvalidFunctionKind { name, args };
                 }
                 let context = &self.context;
@@ -899,7 +821,6 @@ impl<'a> Parser<'a> {
             | TokenType::RightBracket
             | TokenType::Colon
             | TokenType::Semicolon
-            | TokenType::Backslash
             | TokenType::RightBrace
             | TokenType::Comma
             | TokenType::Bang
@@ -1099,13 +1020,12 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_function_args(&mut self) -> Result<Vec<Node>, Node> {
-        let arg_separator_token = &self.get_argument_separator_token();
         let mut args: Vec<Node> = Vec::new();
         let mut next_token = self.lexer.peek_token();
         if next_token == TokenType::RightParenthesis {
             return Ok(args);
         }
-        if &self.lexer.peek_token() == arg_separator_token {
+        if self.lexer.peek_token() == TokenType::Comma {
             args.push(Node::EmptyArgKind);
         } else {
             let t = self.parse_expr();
@@ -1115,11 +1035,11 @@ impl<'a> Parser<'a> {
             args.push(t);
         }
         next_token = self.lexer.peek_token();
-        while &next_token == arg_separator_token {
+        while next_token == TokenType::Comma {
             self.lexer.advance_token();
-            if &self.lexer.peek_token() == arg_separator_token {
+            if self.lexer.peek_token() == TokenType::Comma {
                 args.push(Node::EmptyArgKind);
-                next_token = arg_separator_token.clone();
+                next_token = TokenType::Comma;
             } else if self.lexer.peek_token() == TokenType::RightParenthesis {
                 args.push(Node::EmptyArgKind);
                 return Ok(args);

base/src/expressions/parser/move_formula.rs

@@ -5,8 +5,6 @@ use super::{
 use crate::{
     constants::{LAST_COLUMN, LAST_ROW},
     expressions::token::OpUnary,
-    language::Language,
-    locale::Locale,
 };
 use crate::{
     expressions::types::{Area, CellReferenceRC},
@@ -40,78 +38,38 @@ pub(crate) struct MoveContext<'a> {
 /// We are moving a formula in (row, column) to (row+row_delta, column + column_delta).
 /// All references that do not point to a cell in area will be left untouched.
 /// All references that point to a cell in area will be displaced
-pub(crate) fn move_formula(
-    node: &Node,
-    move_context: &MoveContext,
-    locale: &Locale,
-    language: &Language,
-) -> String {
-    to_string_moved(node, move_context, locale, language)
+pub(crate) fn move_formula(node: &Node, move_context: &MoveContext) -> String {
+    to_string_moved(node, move_context)
 }
 
-fn move_function(
-    name: &str,
-    args: &Vec<Node>,
-    move_context: &MoveContext,
-    locale: &Locale,
-    language: &Language,
-) -> String {
+fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> String {
     let mut first = true;
     let mut arguments = "".to_string();
     for el in args {
         if !first {
-            arguments = format!(
-                "{},{}",
-                arguments,
-                to_string_moved(el, move_context, locale, language)
-            );
+            arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
         } else {
             first = false;
-            arguments = to_string_moved(el, move_context, locale, language);
+            arguments = to_string_moved(el, move_context);
         }
     }
     format!("{name}({arguments})")
 }
 
-fn format_number_locale(number: f64, locale: &Locale) -> String {
-    let s = to_excel_precision_str(number);
-    let decimal = &locale.numbers.symbols.decimal;
-    if decimal == "." {
-        s
-    } else {
-        s.replace('.', decimal)
-    }
-}
-
-pub(crate) fn to_string_array_node(
-    node: &ArrayNode,
-    locale: &Locale,
-    language: &Language,
-) -> String {
+pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
     match node {
-        ArrayNode::Boolean(value) => {
-            if *value {
-                language.booleans.r#true.to_ascii_uppercase()
-            } else {
-                language.booleans.r#false.to_ascii_uppercase()
-            }
-        }
-        ArrayNode::Number(number) => format_number_locale(*number, locale),
+        ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
+        ArrayNode::Number(number) => to_excel_precision_str(*number),
         ArrayNode::String(value) => format!("\"{value}\""),
         ArrayNode::Error(kind) => format!("{kind}"),
     }
 }
 
-fn to_string_moved(
-    node: &Node,
-    move_context: &MoveContext,
-    locale: &Locale,
-    language: &Language,
-) -> String {
+fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
     use self::Node::*;
     match node {
         BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
-        NumberKind(number) => format_number_locale(*number, locale),
+        NumberKind(number) => to_excel_precision_str(*number),
         StringKind(value) => format!("\"{value}\""),
         ReferenceKind {
             sheet_name,
@@ -371,81 +329,55 @@ fn to_string_moved(
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
-            to_string_moved(left, move_context, locale, language),
-            to_string_moved(right, move_context, locale, language),
+            to_string_moved(left, move_context),
+            to_string_moved(right, move_context),
         ),
         OpConcatenateKind { left, right } => format!(
             "{}&{}",
-            to_string_moved(left, move_context, locale, language),
-            to_string_moved(right, move_context, locale, language),
+            to_string_moved(left, move_context),
+            to_string_moved(right, move_context),
         ),
         OpSumKind { kind, left, right } => format!(
             "{}{}{}",
-            to_string_moved(left, move_context, locale, language),
+            to_string_moved(left, move_context),
             kind,
-            to_string_moved(right, move_context, locale, language),
+            to_string_moved(right, move_context),
         ),
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } => format!(
-                    "({})",
-                    to_string_moved(left, move_context, locale, language)
-                ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    to_string_moved(left, move_context, locale, language)
-                ),
-                _ => to_string_moved(left, move_context, locale, language),
+                OpSumKind { .. } => format!("({})", to_string_moved(left, move_context)),
+                CompareKind { .. } => format!("({})", to_string_moved(left, move_context)),
+                _ => to_string_moved(left, move_context),
             };
             let y = match **right {
-                OpSumKind { .. } => format!(
-                    "({})",
-                    to_string_moved(right, move_context, locale, language)
-                ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    to_string_moved(right, move_context, locale, language)
-                ),
-                OpProductKind { .. } => format!(
-                    "({})",
-                    to_string_moved(right, move_context, locale, language)
-                ),
+                OpSumKind { .. } => format!("({})", to_string_moved(right, move_context)),
+                CompareKind { .. } => format!("({})", to_string_moved(right, move_context)),
+                OpProductKind { .. } => format!("({})", to_string_moved(right, move_context)),
                 UnaryKind { .. } => {
-                    format!(
-                        "({})",
-                        to_string_moved(right, move_context, locale, language)
-                    )
+                    format!("({})", to_string_moved(right, move_context))
                 }
-                _ => to_string_moved(right, move_context, locale, language),
+                _ => to_string_moved(right, move_context),
             };
             format!("{x}{kind}{y}")
         }
         OpPowerKind { left, right } => format!(
             "{}^{}",
-            to_string_moved(left, move_context, locale, language),
-            to_string_moved(right, move_context, locale, language),
+            to_string_moved(left, move_context),
+            to_string_moved(right, move_context),
         ),
-        InvalidFunctionKind { name, args } => {
-            move_function(name, args, move_context, locale, language)
-        }
+        InvalidFunctionKind { name, args } => move_function(name, args, move_context),
         FunctionKind { kind, args } => {
-            let name = &kind.to_localized_name(language);
-            move_function(name, args, move_context, locale, language)
+            let name = &kind.to_string();
+            move_function(name, args, move_context)
         }
         ArrayKind(args) => {
             let mut first_row = true;
             let mut matrix_string = String::new();
 
             // Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
-            let row_separator = if locale.numbers.symbols.decimal == "." {
-                ';'
-            } else {
-                '/'
-            };
-            let col_separator = if row_separator == ';' { ',' } else { ';' };
             for row in args {
                 if !first_row {
-                    matrix_string.push(col_separator);
+                    matrix_string.push(',');
                 } else {
                     first_row = false;
                 }
@@ -455,13 +387,13 @@ fn to_string_moved(
                 let mut row_string = String::new();
                 for el in row {
                     if !first_col {
-                        row_string.push(row_separator);
+                        row_string.push(',');
                     } else {
                         first_col = false;
                     }
 
                     // Reuse your existing element-stringification function
-                    row_string.push_str(&to_string_array_node(el, locale, language));
+                    row_string.push_str(&to_string_array_node(el));
                 }
 
                 // Enclose the row in braces
@@ -478,19 +410,13 @@ fn to_string_moved(
         WrongVariableKind(name) => name.to_string(),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
-            to_string_moved(left, move_context, locale, language),
+            to_string_moved(left, move_context),
             kind,
-            to_string_moved(right, move_context, locale, language),
+            to_string_moved(right, move_context),
         ),
         UnaryKind { kind, right } => match kind {
-            OpUnary::Minus => format!(
-                "-{}",
-                to_string_moved(right, move_context, locale, language)
-            ),
-            OpUnary::Percentage => format!(
-                "{}%",
-                to_string_moved(right, move_context, locale, language)
-            ),
+            OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
+            OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
         },
         ErrorKind(kind) => format!("{kind}"),
         ParseErrorKind {
@@ -503,10 +429,7 @@ fn to_string_moved(
             automatic: _,
             child,
         } => {
-            format!(
-                "@{}",
-                to_string_moved(child, move_context, locale, language)
-            )
+            format!("@{}", to_string_moved(child, move_context))
         }
     }
 }

base/src/expressions/parser/static_analysis.rs

@@ -872,10 +872,12 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         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],
@@ -888,6 +890,7 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         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),
@@ -926,7 +929,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         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),
@@ -987,26 +989,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
                 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 +1014,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 +1061,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),
@@ -1270,6 +1253,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Sheets => scalar_arguments(args),
         Function::Cell => scalar_arguments(args),
         Function::Info => scalar_arguments(args),
+
         Function::Dget => not_implemented(args),
         Function::Dmax => not_implemented(args),
         Function::Dmin => not_implemented(args),
@@ -1282,6 +1266,7 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         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,
@@ -1302,7 +1287,6 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         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,
@@ -1338,25 +1322,5 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         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,
     }
 }

base/src/expressions/parser/stringify.rs

@@ -3,8 +3,6 @@ use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::move_formula::to_string_array_node;
 use crate::expressions::parser::static_analysis::add_implicit_intersection;
 use crate::expressions::token::{OpSum, OpUnary};
-use crate::language::{get_language, Language};
-use crate::locale::{get_locale, Locale};
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -45,44 +43,17 @@ pub enum DisplaceData {
 
 /// This is the internal mode in IronCalc
 pub fn to_rc_format(node: &Node) -> String {
-    #[allow(clippy::expect_used)]
-    let locale = get_locale("en").expect("");
-    #[allow(clippy::expect_used)]
-    let language = get_language("en").expect("");
-    stringify(node, None, &DisplaceData::None, false, locale, language)
+    stringify(node, None, &DisplaceData::None, false)
 }
 
 /// This is the mode used to display the formula in the UI
-pub fn to_localized_string(
-    node: &Node,
-    context: &CellReferenceRC,
-    locale: &Locale,
-    language: &Language,
-) -> String {
-    stringify(
-        node,
-        Some(context),
-        &DisplaceData::None,
-        false,
-        locale,
-        language,
-    )
+pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, false)
 }
 
 /// This is the mode used to export the formula to Excel
 pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
-    #[allow(clippy::expect_used)]
-    let locale = get_locale("en").expect("");
-    #[allow(clippy::expect_used)]
-    let language = get_language("en").expect("");
-    stringify(
-        node,
-        Some(context),
-        &DisplaceData::None,
-        true,
-        locale,
-        language,
-    )
+    stringify(node, Some(context), &DisplaceData::None, true)
 }
 
 pub fn to_string_displaced(
@@ -90,11 +61,7 @@ pub fn to_string_displaced(
     context: &CellReferenceRC,
     displace_data: &DisplaceData,
 ) -> String {
-    #[allow(clippy::expect_used)]
-    let locale = get_locale("en").expect("");
-    #[allow(clippy::expect_used)]
-    let language = get_language("en").expect("");
-    stringify(node, Some(context), displace_data, false, locale, language)
+    stringify(node, Some(context), displace_data, false)
 }
 
 /// Converts a local reference to a string applying some displacement if needed.
@@ -306,41 +273,19 @@ fn format_function(
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
     export_to_excel: bool,
-    locale: &Locale,
-    language: &Language,
 ) -> String {
     let mut first = true;
     let mut arguments = "".to_string();
-    let arg_separator = if locale.numbers.symbols.decimal == "." {
-        ','
-    } else {
-        ';'
-    };
     for el in args {
         if !first {
             arguments = format!(
-                "{}{}{}",
+                "{},{}",
                 arguments,
-                arg_separator,
-                stringify(
-                    el,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language
-                )
+                stringify(el, context, displace_data, export_to_excel)
             );
         } else {
             first = false;
-            arguments = stringify(
-                el,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language,
-            );
+            arguments = stringify(el, context, displace_data, export_to_excel);
         }
     }
     format!("{name}({arguments})")
@@ -376,26 +321,11 @@ fn stringify(
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
     export_to_excel: bool,
-    locale: &Locale,
-    language: &Language,
 ) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => {
-            if *value {
-                language.booleans.r#true.to_string()
-            } else {
-                language.booleans.r#false.to_string()
-            }
-        }
-        NumberKind(number) => {
-            let s = to_excel_precision_str(*number);
-            if locale.numbers.symbols.decimal == "." {
-                s
-            } else {
-                s.replace(".", &locale.numbers.symbols.decimal)
-            }
-        }
+        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
+        NumberKind(number) => to_excel_precision_str(*number),
         StringKind(value) => format!("\"{value}\""),
         WrongReferenceKind {
             sheet_name,
@@ -539,95 +469,32 @@ fn stringify(
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
-            stringify(
-                left,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            ),
-            stringify(
-                right,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            )
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         OpConcatenateKind { left, right } => format!(
             "{}&{}",
-            stringify(
-                left,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            ),
-            stringify(
-                right,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            )
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
-            stringify(
-                left,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            ),
+            stringify(left, context, displace_data, export_to_excel),
             kind,
-            stringify(
-                right,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language
-            )
+            stringify(right, context, displace_data, export_to_excel)
         ),
         OpSumKind { kind, left, right } => {
-            let left_str = stringify(
-                left,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language,
-            );
+            let left_str = stringify(left, context, displace_data, export_to_excel);
             // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
             let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
                 | matches!(**right, CompareKind { .. })
             {
                 format!(
                     "({})",
-                    stringify(
-                        right,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
+                    stringify(right, context, displace_data, export_to_excel)
                 )
             } else {
-                stringify(
-                    right,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language,
-                )
+                stringify(right, context, displace_data, export_to_excel)
             };
 
             format!("{left_str}{kind}{right_str}")
@@ -636,44 +503,16 @@ fn stringify(
             let x = match **left {
                 OpSumKind { .. } | CompareKind { .. } => format!(
                     "({})",
-                    stringify(
-                        left,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
-                ),
-                _ => stringify(
-                    left,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language,
+                    stringify(left, context, displace_data, export_to_excel)
                 ),
+                _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
                 OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
                     "({})",
-                    stringify(
-                        right,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
-                ),
-                _ => stringify(
-                    right,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language,
+                    stringify(right, context, displace_data, export_to_excel)
                 ),
+                _ => stringify(right, context, displace_data, export_to_excel),
             };
             format!("{x}{kind}{y}")
         }
@@ -689,14 +528,7 @@ fn stringify(
                 | DefinedNameKind(_)
                 | TableNameKind(_)
                 | WrongVariableKind(_)
-                | WrongRangeKind { .. } => stringify(
-                    left,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language,
-                ),
+                | WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
                 | OpProductKind { .. }
@@ -711,14 +543,7 @@ fn stringify(
                 | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(
-                        left,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
+                    stringify(left, context, displace_data, export_to_excel)
                 ),
             };
             let y = match **right {
@@ -731,14 +556,9 @@ fn stringify(
                 | DefinedNameKind(_)
                 | TableNameKind(_)
                 | WrongVariableKind(_)
-                | WrongRangeKind { .. } => stringify(
-                    right,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language,
-                ),
+                | WrongRangeKind { .. } => {
+                    stringify(right, context, displace_data, export_to_excel)
+                }
                 OpRangeKind { .. }
                 | OpConcatenateKind { .. }
                 | OpProductKind { .. }
@@ -754,56 +574,29 @@ fn stringify(
                 | ImplicitIntersection { .. }
                 | EmptyArgKind => format!(
                     "({})",
-                    stringify(
-                        right,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
+                    stringify(right, context, displace_data, export_to_excel)
                 ),
             };
             format!("{x}^{y}")
         }
-        InvalidFunctionKind { name, args } => format_function(
-            &name.to_ascii_lowercase(),
-            args,
-            context,
-            displace_data,
-            export_to_excel,
-            locale,
-            language,
-        ),
+        InvalidFunctionKind { name, args } => {
+            format_function(name, args, context, displace_data, export_to_excel)
+        }
         FunctionKind { kind, args } => {
             let name = if export_to_excel {
                 kind.to_xlsx_string()
             } else {
-                kind.to_localized_name(language)
+                kind.to_string()
             };
-            format_function(
-                &name,
-                args,
-                context,
-                displace_data,
-                export_to_excel,
-                locale,
-                language,
-            )
+            format_function(&name, args, context, displace_data, export_to_excel)
         }
         ArrayKind(args) => {
             let mut first_row = true;
             let mut matrix_string = String::new();
-            let row_separator = if locale.numbers.symbols.decimal == "." {
-                ';'
-            } else {
-                '/'
-            };
-            let col_separator = if row_separator == ';' { ',' } else { ';' };
 
             for row in args {
                 if !first_row {
-                    matrix_string.push(row_separator);
+                    matrix_string.push(';');
                 } else {
                     first_row = false;
                 }
@@ -811,11 +604,11 @@ fn stringify(
                 let mut row_string = String::new();
                 for el in row {
                     if !first_column {
-                        row_string.push(col_separator);
+                        row_string.push(',');
                     } else {
                         first_column = false;
                     }
-                    row_string.push_str(&to_string_array_node(el, locale, language));
+                    row_string.push_str(&to_string_array_node(el));
                 }
                 matrix_string.push_str(&row_string);
             }
@@ -854,40 +647,19 @@ fn stringify(
                 if needs_parentheses {
                     format!(
                         "-({})",
-                        stringify(
-                            right,
-                            context,
-                            displace_data,
-                            export_to_excel,
-                            locale,
-                            language
-                        )
+                        stringify(right, context, displace_data, export_to_excel)
                     )
                 } else {
                     format!(
                         "-{}",
-                        stringify(
-                            right,
-                            context,
-                            displace_data,
-                            export_to_excel,
-                            locale,
-                            language
-                        )
+                        stringify(right, context, displace_data, export_to_excel)
                     )
                 }
             }
             OpUnary::Percentage => {
                 format!(
                     "{}%",
-                    stringify(
-                        right,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
+                    stringify(right, context, displace_data, export_to_excel)
                 )
             }
         },
@@ -908,38 +680,17 @@ fn stringify(
 
                 add_implicit_intersection(&mut new_node, true);
                 if matches!(&new_node, Node::ImplicitIntersection { .. }) {
-                    return stringify(
-                        child,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language,
-                    );
+                    return stringify(child, context, displace_data, export_to_excel);
                 }
 
                 return format!(
                     "_xlfn.SINGLE({})",
-                    stringify(
-                        child,
-                        context,
-                        displace_data,
-                        export_to_excel,
-                        locale,
-                        language
-                    )
+                    stringify(child, context, displace_data, export_to_excel)
                 );
             }
             format!(
                 "@{}",
-                stringify(
-                    child,
-                    context,
-                    displace_data,
-                    export_to_excel,
-                    locale,
-                    language
-                )
+                stringify(child, context, displace_data, export_to_excel)
             )
         }
     }

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

@@ -4,10 +4,7 @@ mod test_general;
 mod test_implicit_intersection;
 mod test_issue_155;
 mod test_issue_483;
-mod test_languages;
-mod test_locales;
 mod test_move_formula;
 mod test_ranges;
 mod test_stringify;
 mod test_tables;
-mod utils;

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

@@ -2,8 +2,8 @@ use std::collections::HashMap;
 
 use crate::expressions::{
     parser::{
-        stringify::to_excel_string,
-        tests::utils::{new_parser, to_english_localized_string},
+        stringify::{to_excel_string, to_string},
+        Parser,
     },
     types::CellReferenceRC,
 };
@@ -13,7 +13,7 @@ use crate::expressions::parser::static_analysis::add_implicit_intersection;
 #[test]
 fn simple_test() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -72,7 +72,7 @@ fn simple_test() {
     for (formula, expected) in cases {
         let mut t = parser.parse(formula, &cell_reference);
         add_implicit_intersection(&mut t, true);
-        let r = to_english_localized_string(&t, &cell_reference);
+        let r = to_string(&t, &cell_reference);
         assert_eq!(r, expected);
         let excel_formula = to_excel_string(&t, &cell_reference);
         assert_eq!(excel_formula, formula);

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

@@ -2,15 +2,14 @@
 
 use std::collections::HashMap;
 
-use crate::expressions::parser::stringify::to_rc_format;
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
-use crate::expressions::parser::{ArrayNode, Node};
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::{ArrayNode, Node, Parser};
 use crate::expressions::types::CellReferenceRC;
 
 #[test]
 fn simple_horizontal() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -29,16 +28,13 @@ fn simple_horizontal() {
     );
 
     assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
-    assert_eq!(
-        to_english_localized_string(&horizontal, &cell_reference),
-        "{1,2,3}"
-    );
+    assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
 }
 
 #[test]
 fn simple_vertical() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -56,16 +52,13 @@ fn simple_vertical() {
         ])
     );
     assert_eq!(to_rc_format(&vertical), "{1;2;3}");
-    assert_eq!(
-        to_english_localized_string(&vertical, &cell_reference),
-        "{1;2;3}"
-    );
+    assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
 }
 
 #[test]
 fn simple_matrix() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -95,8 +88,5 @@ fn simple_matrix() {
         ])
     );
     assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
-    assert_eq!(
-        to_english_localized_string(&matrix, &cell_reference),
-        "{1,2,3;4,5,6;7,8,9}"
-    );
+    assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
 }

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

@@ -3,12 +3,12 @@
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::{to_rc_format, to_string_displaced, DisplaceData};
-use crate::expressions::parser::Node;
+use crate::expressions::parser::stringify::{
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
+};
+use crate::expressions::parser::{Node, Parser};
 use crate::expressions::types::CellReferenceRC;
 
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
-
 struct Formula<'a> {
     initial: &'a str,
     expected: &'a str,
@@ -17,7 +17,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_reference() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -32,7 +32,7 @@ fn test_parser_reference() {
 #[test]
 fn test_parser_absolute_column() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -47,7 +47,7 @@ fn test_parser_absolute_column() {
 #[test]
 fn test_parser_absolute_row_col() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -62,7 +62,7 @@ fn test_parser_absolute_row_col() {
 #[test]
 fn test_parser_absolute_row_col_1() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -77,7 +77,7 @@ fn test_parser_absolute_row_col_1() {
 #[test]
 fn test_parser_simple_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -93,7 +93,7 @@ fn test_parser_simple_formula() {
 #[test]
 fn test_parser_boolean() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -109,7 +109,7 @@ fn test_parser_boolean() {
 #[test]
 fn test_parser_bad_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -138,7 +138,7 @@ fn test_parser_bad_formula() {
 #[test]
 fn test_parser_bad_formula_1() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -167,7 +167,7 @@ fn test_parser_bad_formula_1() {
 #[test]
 fn test_parser_bad_formula_2() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -196,7 +196,7 @@ fn test_parser_bad_formula_2() {
 #[test]
 fn test_parser_bad_formula_3() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -225,7 +225,7 @@ fn test_parser_bad_formula_3() {
 #[test]
 fn test_parser_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -266,17 +266,14 @@ fn test_parser_formulas() {
             },
         );
         assert_eq!(to_rc_format(&t), formula.expected);
-        assert_eq!(
-            to_english_localized_string(&t, &cell_reference),
-            formula.initial
-        );
+        assert_eq!(to_string(&t, &cell_reference), formula.initial);
     }
 }
 
 #[test]
 fn test_parser_r1c1_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
     parser.set_lexer_mode(LexerMode::R1C1);
 
     let formulas = vec![
@@ -333,10 +330,7 @@ fn test_parser_r1c1_formulas() {
                 column: 1,
             },
         );
-        assert_eq!(
-            to_english_localized_string(&t, &cell_reference),
-            formula.expected
-        );
+        assert_eq!(to_string(&t, &cell_reference), formula.expected);
         assert_eq!(to_rc_format(&t), formula.initial);
     }
 }
@@ -344,7 +338,7 @@ fn test_parser_r1c1_formulas() {
 #[test]
 fn test_parser_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -360,7 +354,7 @@ fn test_parser_quotes() {
 #[test]
 fn test_parser_escape_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -376,7 +370,7 @@ fn test_parser_escape_quotes() {
 #[test]
 fn test_parser_parenthesis() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -392,7 +386,7 @@ fn test_parser_parenthesis() {
 #[test]
 fn test_parser_excel_xlfn() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -413,7 +407,7 @@ fn test_to_string_displaced() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
@@ -433,7 +427,7 @@ fn test_to_string_displaced_full_ranges() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let node = parser.parse("SUM(3:3)", context);
     let displace_data = DisplaceData::Column {
@@ -466,7 +460,7 @@ fn test_to_string_displaced_too_low() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
@@ -486,7 +480,7 @@ fn test_to_string_displaced_too_high() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {

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

@@ -1,15 +1,13 @@
 #![allow(clippy::panic)]
 
-use crate::expressions::parser::Node;
+use crate::expressions::parser::{Node, Parser};
 use crate::expressions::types::CellReferenceRC;
 use std::collections::HashMap;
 
-use crate::expressions::parser::tests::utils::new_parser;
-
 #[test]
 fn simple() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!B3
     let cell_reference = CellReferenceRC {
@@ -42,7 +40,7 @@ fn simple() {
 #[test]
 fn simple_add() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!B3
     let cell_reference = CellReferenceRC {

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

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

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

@@ -2,14 +2,14 @@
 
 use std::collections::HashMap;
 
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
-use crate::expressions::parser::Node;
+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 = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -19,12 +19,9 @@ fn issue_483_parser() {
     };
     let t = parser.parse("-(A1^1.22)", &cell_reference);
     assert!(matches!(t, Node::UnaryKind { .. }));
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "-(A1^1.22)"
-    );
+    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_english_localized_string(&t, &cell_reference), "-A1^1.22");
+    assert_eq!(to_string(&t, &cell_reference), "-A1^1.22");
 }

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

@@ -1,58 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use std::collections::HashMap;
-
-use crate::expressions::parser::{DefinedNameS, Node, Parser};
-use crate::expressions::types::CellReferenceRC;
-
-use crate::expressions::parser::stringify::to_localized_string;
-use crate::functions::Function;
-use crate::language::get_language;
-use crate::locale::get_locale;
-use crate::types::Table;
-
-pub fn to_string(t: &Node, cell_reference: &CellReferenceRC) -> String {
-    let locale = get_locale("en").unwrap();
-    let language = get_language("es").unwrap();
-    to_localized_string(t, cell_reference, locale, language)
-}
-
-pub fn new_parser<'a>(
-    worksheets: Vec<String>,
-    defined_names: Vec<DefinedNameS>,
-    tables: HashMap<String, Table>,
-) -> Parser<'a> {
-    let locale = get_locale("en").unwrap();
-    let language = get_language("es").unwrap();
-    Parser::new(worksheets, defined_names, tables, locale, language)
-}
-
-#[test]
-fn simple_language() {
-    let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
-    // Reference cell is Sheet1!A1
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 1,
-        column: 1,
-    };
-    let t = parser.parse("FALSO", &cell_reference);
-    assert!(matches!(t, Node::BooleanKind(false)));
-
-    let t = parser.parse("VERDADERO", &cell_reference);
-    assert!(matches!(t, Node::BooleanKind(true)));
-
-    let t = parser.parse("TRUE()", &cell_reference);
-    assert!(matches!(t, Node::InvalidFunctionKind { ref name, args: _} if name == "TRUE"));
-
-    let t = parser.parse("VERDADERO()", &cell_reference);
-    assert!(matches!(
-        t,
-        Node::FunctionKind {
-            kind: Function::True,
-            args: _
-        }
-    ));
-    assert_eq!(to_string(&t, &cell_reference), "VERDADERO()".to_string());
-}

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

@@ -1 +0,0 @@
-

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

@@ -1,17 +1,8 @@
 use std::collections::HashMap;
 
-use crate::expressions::parser::move_formula::{move_formula as mf, MoveContext};
-use crate::expressions::parser::tests::utils::new_parser;
-use crate::expressions::parser::Node;
+use crate::expressions::parser::move_formula::{move_formula, MoveContext};
+use crate::expressions::parser::Parser;
 use crate::expressions::types::{Area, CellReferenceRC};
-use crate::language::get_default_language;
-use crate::locale::get_default_locale;
-
-fn move_formula(node: &Node, context: &MoveContext) -> String {
-    let locale = get_default_locale();
-    let language = get_default_language();
-    mf(node, context, locale, language)
-}
 
 #[test]
 fn test_move_formula() {
@@ -24,7 +15,7 @@ fn test_move_formula() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -111,7 +102,7 @@ fn test_move_formula_context_offset() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -149,7 +140,7 @@ fn test_move_formula_area_limits() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -204,7 +195,7 @@ fn test_move_formula_ranges() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let area = &Area {
         sheet: 0,
@@ -327,7 +318,7 @@ fn test_move_formula_wrong_reference() {
         height: 5,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Wrong formulas will NOT be displaced
     let node = parser.parse("Sheet3!AB31", context);
@@ -386,7 +377,7 @@ fn test_move_formula_misc() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -454,7 +445,7 @@ fn test_move_formula_another_sheet() {
     };
     // we add two sheets and we cut/paste from Sheet1 to Sheet2
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -496,7 +487,7 @@ fn move_formula_implicit_intersetion() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -533,7 +524,7 @@ fn move_formula_implicit_intersetion_with_ranges() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {

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

@@ -2,8 +2,8 @@ use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
 
-use crate::expressions::parser::stringify::to_rc_format;
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::Parser;
 use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
@@ -14,7 +14,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_formulas_with_full_ranges() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -59,10 +59,7 @@ fn test_parser_formulas_with_full_ranges() {
             },
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
-        assert_eq!(
-            to_english_localized_string(&t, &cell_reference),
-            formula.formula_a1
-        );
+        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
     }
 
     // Now the inverse
@@ -77,17 +74,14 @@ fn test_parser_formulas_with_full_ranges() {
             },
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
-        assert_eq!(
-            to_english_localized_string(&t, &cell_reference),
-            formula.formula_a1
-        );
+        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
     }
 }
 
 #[test]
 fn test_range_inverse_order() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -102,7 +96,7 @@ fn test_range_inverse_order() {
         &cell_reference,
     );
     assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
+        to_string(&t, &cell_reference),
         "SUM(C2:D4)*SUM(Sheet2!C4:D20)*SUM($C4:D$20)".to_string()
     );
 }

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

@@ -2,13 +2,14 @@
 
 use std::collections::HashMap;
 
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
 use crate::expressions::types::CellReferenceRC;
 
 #[test]
 fn exp_order() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -17,34 +18,25 @@ fn exp_order() {
         column: 1,
     };
     let t = parser.parse("(1 + 2)^3  + 4", &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "(1+2)^3+4"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
 
     let t = parser.parse("(C5 + 3)^R4", &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "(C5+3)^R4"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
 
     let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "(C5+3)^(R4*6)"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
 
     let t = parser.parse("(C5)^(R4)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "C5^R4");
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
 
     let t = parser.parse("(5)^(4)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "5^4");
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
 }
 
 #[test]
 fn correct_parenthesis() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = new_parser(worksheets, vec![], HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let cell_reference = CellReferenceRC {
         sheet: "Sheet1".to_string(),
@@ -53,29 +45,26 @@ fn correct_parenthesis() {
     };
 
     let t = parser.parse("-(1 + 1)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "-(1+1)");
+    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
 
     let t = parser.parse("1 - (3 + 4)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "1-(3+4)");
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
 
     let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
     assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
+        to_string(&t, &cell_reference),
         "-(1.05*(0.0284+0.0046)-0.0284)"
     );
 
     let t = parser.parse("1 + (3+5)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "1+3+5");
+    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
 
     let t = parser.parse("1 - (3+5)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "1-(3+5)");
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
 
     let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "1-3-(3+5)"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
 
     let t = parser.parse("1 + (3<5)", &cell_reference);
-    assert_eq!(to_english_localized_string(&t, &cell_reference), "1+(3<5)");
+    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
 }

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

@@ -2,7 +2,8 @@
 
 use std::collections::HashMap;
 
-use crate::expressions::parser::tests::utils::{new_parser, to_english_localized_string};
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
 use crate::expressions::types::CellReferenceRC;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};
@@ -61,7 +62,7 @@ fn simple_table() {
     let row_count = 3;
     let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
 
-    let mut parser = new_parser(worksheets, vec![], tables);
+    let mut parser = Parser::new(worksheets, vec![], tables);
     // Reference cell is 'Sheet One'!F2
     let cell_reference = CellReferenceRC {
         sheet: "Sheet One".to_string(),
@@ -71,10 +72,7 @@ fn simple_table() {
 
     let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
     let t = parser.parse(formula, &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "SUM($A$2:$E$2)"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
 
     // Cell A3
     let cell_reference = CellReferenceRC {
@@ -84,10 +82,7 @@ fn simple_table() {
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
     let t = parser.parse(formula, &cell_reference);
-    assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
-        "SUBTOTAL(109,$A$2:$A$3)"
-    );
+    assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
 
     // Cell A3 in 'Second Sheet'
     let cell_reference = CellReferenceRC {
@@ -98,7 +93,7 @@ fn simple_table() {
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
     let t = parser.parse(formula, &cell_reference);
     assert_eq!(
-        to_english_localized_string(&t, &cell_reference),
+        to_string(&t, &cell_reference),
         "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"
     );
 }

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

@@ -1,29 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    expressions::{
-        parser::{DefinedNameS, Node, Parser},
-        types::CellReferenceRC,
-    },
-    language::get_default_language,
-    locale::get_default_locale,
-    types::Table,
-};
-
-use crate::expressions::parser::stringify::to_localized_string;
-
-pub fn to_english_localized_string(t: &Node, cell_reference: &CellReferenceRC) -> String {
-    let locale = get_default_locale();
-    let language = get_default_language();
-    to_localized_string(t, cell_reference, locale, language)
-}
-
-pub fn new_parser<'a>(
-    worksheets: Vec<String>,
-    defined_names: Vec<DefinedNameS>,
-    tables: HashMap<String, Table>,
-) -> Parser<'a> {
-    let locale = get_default_locale();
-    let language = get_default_language();
-    Parser::new(worksheets, defined_names, tables, locale, language)
-}

base/src/expressions/token.rs

@@ -241,7 +241,6 @@ pub enum TokenType {
     Percent,            // %
     And,                // &
     At,                 // @
-    Backslash,          // \
     Reference {
         sheet: Option<String>,
         row: i32,

base/src/formatter/format.rs

@@ -128,9 +128,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             if (1.0e-8..1.0e+11).contains(&value_abs) {
                 let mut text = format!("{value:.9}");
                 text = text.trim_end_matches('0').trim_end_matches('.').to_string();
-                if locale.numbers.symbols.decimal != "." {
-                    text = text.replace('.', &locale.numbers.symbols.decimal.to_string());
-                }
                 Formatted {
                     text,
                     color: None,
@@ -148,17 +145,13 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                 value /= 10.0_f64.powf(exponent);
                 let sign = if exponent < 0.0 { '-' } else { '+' };
                 let s = format!("{value:.5}");
-                let mut text = format!(
+                Formatted {
+                    text: format!(
                         "{}E{}{:02}",
                         s.trim_end_matches('0').trim_end_matches('.'),
                         sign,
                         exponent.abs()
-                );
-                if locale.numbers.symbols.decimal != "." {
-                    text = text.replace('.', &locale.numbers.symbols.decimal.to_string());
-                }
-                Formatted {
-                    text,
+                    ),
                     color: None,
                     error: None,
                 }
@@ -759,15 +752,13 @@ fn parse_date(value: &str) -> Result<(i32, String), String> {
 pub(crate) fn parse_formatted_number(
     original: &str,
     currencies: &[&str],
-    decimal_separator: u8,
-    group_separator: u8,
 ) -> Result<(f64, Option<String>), String> {
     let value = original.trim();
     let scientific_format = "0.00E+00";
 
     // Check if it is a percentage
     if let Some(p) = value.strip_suffix('%') {
-        let (f, options) = parse_number(p.trim(), decimal_separator, group_separator)?;
+        let (f, options) = parse_number(p.trim())?;
         if options.is_scientific {
             return Ok((f / 100.0, Some(scientific_format.to_string())));
         }
@@ -783,7 +774,7 @@ pub(crate) fn parse_formatted_number(
     // check if it is a currency in currencies
     for currency in currencies {
         if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
-            let (f, options) = parse_number(p.trim(), decimal_separator, group_separator)?;
+            let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));
             }
@@ -792,7 +783,7 @@ pub(crate) fn parse_formatted_number(
             }
             return Ok((-f, Some(format!("{currency}#,##0"))));
         } else if let Some(p) = value.strip_prefix(currency) {
-            let (f, options) = parse_number(p.trim(), decimal_separator, group_separator)?;
+            let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));
             }
@@ -801,7 +792,7 @@ pub(crate) fn parse_formatted_number(
             }
             return Ok((f, Some(format!("{currency}#,##0"))));
         } else if let Some(p) = value.strip_suffix(currency) {
-            let (f, options) = parse_number(p.trim(), decimal_separator, group_separator)?;
+            let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));
             }
@@ -820,7 +811,7 @@ pub(crate) fn parse_formatted_number(
     }
 
     // Lastly we check if it is a number
-    let (f, options) = parse_number(value, decimal_separator, group_separator)?;
+    let (f, options) = parse_number(value)?;
     if options.is_scientific {
         return Ok((f, Some(scientific_format.to_string())));
     }
@@ -843,11 +834,7 @@ struct NumberOptions {
 
 // tries to parse 'value' as a number.
 // If it is a number it either uses commas as thousands separator or it does not
-fn parse_number(
-    value: &str,
-    decimal_separator: u8,
-    group_separator: u8,
-) -> Result<(f64, NumberOptions), String> {
+fn parse_number(value: &str) -> Result<(f64, NumberOptions), String> {
     let mut position = 0;
     let bytes = value.as_bytes();
     let len = bytes.len();
@@ -855,6 +842,8 @@ fn parse_number(
         return Err("Cannot parse number".to_string());
     }
     let mut chars = String::from("");
+    let decimal_separator = b'.';
+    let group_separator = b',';
     let mut group_separator_index = Vec::new();
     // get the sign
     let sign = if bytes[0] == b'-' {

base/src/formatter/test/test_general.rs

@@ -1,5 +1,4 @@
 #![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
 
 use crate::{
     formatter::format::format_number,
@@ -203,9 +202,3 @@ fn test_date() {
         "Sat-September-12"
     );
 }
-
-#[test]
-fn test_german_locale() {
-    let locale = get_locale("de").expect("");
-    assert_eq!(format_number(1234.56, "General", locale).text, "1234,56");
-}

base/src/formatter/test/test_parse_formatted_number.rs

@@ -1,13 +1,9 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::formatter::format::parse_formatted_number;
+use crate::formatter::format::parse_formatted_number as parse;
 
 const PARSE_ERROR_MSG: &str = "Could not parse number";
 
-fn parse(input: &str, currencies: &[&str]) -> Result<(f64, Option<String>), String> {
-    parse_formatted_number(input, currencies, b'.', b',')
-}
-
 #[test]
 fn numbers() {
     // whole numbers

base/src/functions/binary_search.rs

@@ -137,7 +137,7 @@ pub(crate) fn binary_search_descending_or_greater<T: Ord>(target: &T, array: &[T
     Some((n - r - 1) as i32)
 }
 
-impl<'a> Model<'a> {
+impl Model {
     /// Returns an array with the list of cell values in the range
     pub(crate) fn prepare_array(
         &mut self,

base/src/functions/database.rs

@@ -9,7 +9,7 @@ use crate::{
 
 use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex};
 
-impl<'a> Model<'a> {
+impl Model {
     // =DAVERAGE(database, field, criteria)
     pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/date_and_time.rs

@@ -4,7 +4,6 @@ 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;
@@ -470,7 +469,7 @@ fn parse_datevalue_text(value: &str) -> Result<i32, String> {
     }
 }
 
-impl<'a> Model<'a> {
+impl Model {
     fn get_date_serial(
         &mut self,
         node: &Node,
@@ -771,12 +770,12 @@ impl<'a> Model<'a> {
         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 +978,7 @@ impl<'a> Model<'a> {
                 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 +989,14 @@ impl<'a> Model<'a> {
     }
 
     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,

base/src/functions/engineering/bessel.rs

@@ -12,7 +12,7 @@ use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y};
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
 // EXCEL_BESSEL(x, n) => bessel(n, x)
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_besseli(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/engineering/bit_operations.rs

@@ -7,7 +7,7 @@ use crate::{
 // 2^48-1
 const MAX: f64 = 281474976710655.0;
 
-impl<'a> Model<'a> {
+impl Model {
     // BITAND( number1, number2)
     pub(crate) fn fn_bitand(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {

base/src/functions/engineering/complex.rs

@@ -182,7 +182,7 @@ fn parse_complex_number(s: &str) -> Result<(f64, f64, Suffix), String> {
     }
 }
 
-impl<'a> Model<'a> {
+impl Model {
     fn get_complex_number(
         &mut self,
         node: &Node,

base/src/functions/engineering/convert.rs

@@ -41,7 +41,7 @@ fn convert_temperature(
     }
 }
 
-impl<'a> Model<'a> {
+impl Model {
     // CONVERT(number, from_unit, to_unit)
     pub(crate) fn fn_convert(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/engineering/misc.rs

@@ -5,7 +5,7 @@ use crate::{
     number_format::to_precision,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     // DELTA(number1, [number2])
     pub(crate) fn fn_delta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let arg_count = args.len();

base/src/functions/engineering/number_basis.rs

@@ -31,7 +31,7 @@ fn from_binary_to_decimal(value: f64) -> Result<i64, String> {
     Ok(result)
 }
 
-impl<'a> Model<'a> {
+impl Model {
     // BIN2DEC(number)
     pub(crate) fn fn_bin2dec(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {

base/src/functions/financial.rs

@@ -191,7 +191,7 @@ fn compute_ppmt(
 // All, except for rate are easily solvable in terms of the others.
 // In these formulas the payment (pmt) is normally negative
 
-impl<'a> Model<'a> {
+impl Model {
     fn get_array_of_numbers_generic(
         &mut self,
         arg: &Node,

base/src/functions/information.rs

@@ -4,7 +4,7 @@ use crate::{
     model::{Model, ParsedDefinedName},
 };
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_isnumber(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             match self.evaluate_node_in_context(&args[0], cell) {
@@ -373,8 +373,6 @@ impl<'a> Model<'a> {
         CalcResult::Number(sheet_count)
     }
 
-    /// INFO(info_type, [reference])
-    /// NB: In Excel "info_type" is localized. Here it is always in English.
     pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let arg_count = args.len();
         if arg_count == 0 || arg_count > 2 {

base/src/functions/logical.rs

@@ -6,7 +6,7 @@ use crate::{
 
 use super::util::compare_values;
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {
             CalcResult::Boolean(true)

base/src/functions/lookup_and_reference.rs

@@ -7,7 +7,7 @@ use crate::{
 
 use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex, values_are_equal};
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_index(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let row_num;
         let col_num;
@@ -698,7 +698,7 @@ impl<'a> Model<'a> {
                 let parsed_reference = ParsedReference::parse_reference_formula(
                     Some(cell.sheet),
                     &s,
-                    self.locale,
+                    &self.locale,
                     |name| self.get_sheet_index_by_name(name),
                 );
 
@@ -839,10 +839,6 @@ impl<'a> Model<'a> {
         CalcResult::Range { left, right }
     }
 
-    // FORMULATEXT(reference)
-    // Returns a formula as a string. Two differences with Excel:
-    // - It returns the formula in English
-    // - It formats the formula without spaces between elements
     pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {
             return CalcResult::new_args_number_error(cell);
@@ -864,7 +860,7 @@ impl<'a> Model<'a> {
                     message: "argument must be a reference to a single cell".to_string(),
                 };
             }
-            if let Ok(Some(f)) = self.get_english_cell_formula(left.sheet, left.row, left.column) {
+            if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
                 CalcResult::String(f)
             } else {
                 CalcResult::Error {

base/src/functions/mathematical.rs

@@ -1,15 +1,81 @@
 use crate::cast::NumberOrArray;
-use crate::constants::{EXCEL_PRECISION, LAST_COLUMN, LAST_ROW};
+use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::ArrayNode;
 use crate::expressions::types::CellReferenceIndex;
 use crate::functions::math_util::{from_roman, to_roman_with_form};
-use crate::number_format::{to_excel_precision, to_precision};
+use crate::number_format::to_precision;
 use crate::single_number_fn;
 use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
+use statrs::function::gamma::ln_gamma;
+use std::f64::consts::LN_2;
 use std::f64::consts::PI;
 
+const FACT_TABLE: [f64; 26] = [
+    1.0,                          // 0!
+    1.0,                          // 1!
+    2.0,                          // 2!
+    6.0,                          // 3!
+    24.0,                         // 4!
+    120.0,                        // 5!
+    720.0,                        // 6!
+    5040.0,                       // 7!
+    40320.0,                      // 8!
+    362880.0,                     // 9!
+    3628800.0,                    // 10!
+    39916800.0,                   // 11!
+    479001600.0,                  // 12!
+    6227020800.0,                 // 13!
+    87178291200.0,                // 14!
+    1307674368000.0,              // 15!
+    20922789888000.0,             // 16!
+    355687428096000.0,            // 17!
+    6402373705728000.0,           // 18!
+    121645100408832000.0,         // 19!
+    2432902008176640000.0,        // 20!
+    51090942171709440000.0,       // 21!
+    1124000727777607680000.0,     // 22!
+    25852016738884976640000.0,    // 23!
+    620448401733239439360000.0,   // 24!
+    15511210043330985984000000.0, // 25!
+];
+
+const FACTDOUBLE_TABLE: [f64; 32] = [
+    1.0,
+    1.0,
+    2.0,
+    3.0,
+    8.0,
+    15.0,
+    48.0,
+    105.0,
+    384.0,
+    945.0,
+    3840.0,
+    10395.0,
+    46080.0,
+    135135.0,
+    645120.0,
+    2027025.0,
+    10321920.0,
+    34459425.0,
+    185794560.0,
+    654729075.0,
+    3715891200.0,
+    13749310575.0,
+    81749606400.0,
+    316234143225.0,
+    1961990553600.0,
+    7905853580625.0,
+    51011754393600.0,
+    213458046676875.0,
+    1428329123020800.0,
+    6190283353629370.0,
+    42849873690624000.0,
+    191898783962511000.0,
+];
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn random() -> f64 {
     rand::random()
@@ -47,7 +113,7 @@ pub fn random() -> f64 {
     Math::random()
 }
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_min(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let mut result = f64::NAN;
         for arg in args {
@@ -984,9 +1050,7 @@ impl<'a> Model<'a> {
             };
         }
 
-        // Apply Excel precision to the ratio to handle floating-point rounding errors
-        let ratio = to_excel_precision(value / significance, EXCEL_PRECISION);
-        let result = f64::floor(ratio) * significance;
+        let result = f64::floor(value / significance) * significance;
         CalcResult::Number(result)
     }
 
@@ -1123,14 +1187,10 @@ impl<'a> Model<'a> {
         }
         let significance = significance.abs();
         if value < 0.0 && mode != 0.0 {
-            // Apply Excel precision to handle floating-point rounding errors
-            let ratio = to_excel_precision(value / significance, EXCEL_PRECISION);
-            let result = f64::ceil(ratio) * significance;
+            let result = f64::ceil(value / significance) * significance;
             CalcResult::Number(result)
         } else {
-            // Apply Excel precision to handle floating-point rounding errors
-            let ratio = to_excel_precision(value / significance, EXCEL_PRECISION);
-            let result = f64::floor(ratio) * significance;
+            let result = f64::floor(value / significance) * significance;
             CalcResult::Number(result)
         }
     }
@@ -1160,9 +1220,7 @@ impl<'a> Model<'a> {
             return CalcResult::Number(0.0);
         }
 
-        // Apply Excel precision to handle floating-point rounding errors
-        let ratio = to_excel_precision(value / significance, EXCEL_PRECISION);
-        let result = f64::floor(ratio) * significance;
+        let result = f64::floor(value / significance) * significance;
         CalcResult::Number(result)
     }
 
@@ -1327,35 +1385,78 @@ impl<'a> Model<'a> {
     single_number_fn!(fn_sec, |f| Ok(1.0 / f64::cos(f)));
     single_number_fn!(fn_sech, |f| Ok(1.0 / f64::cosh(f)));
     single_number_fn!(fn_exp, |f: f64| Ok(f64::exp(f)));
+
     single_number_fn!(fn_fact, |x: f64| {
         let x = x.floor();
+
         if x < 0.0 {
             return Err(Error::NUM);
         }
-        let mut acc = 1.0;
-        let mut k = 2.0;
-        while k <= x {
-            acc *= k;
-            k += 1.0;
-        }
-        Ok(acc)
-    });
-    single_number_fn!(fn_factdouble, |x: f64| {
-        let x = x.floor();
-        if x < -1.0 {
-            return Err(Error::NUM);
-        }
-        if x < 0.0 {
+
+        if x == 0.0 {
             return Ok(1.0);
         }
-        let mut acc = 1.0;
-        let mut k = if x % 2.0 == 0.0 { 2.0 } else { 1.0 };
-        while k <= x {
-            acc *= k;
-            k += 2.0;
+        if x < FACT_TABLE.len() as f64 {
+            return Ok(FACT_TABLE[x as usize]);
         }
-        Ok(acc)
+
+        // Use ln Γ(x+1) to avoid overflow while deciding.
+        let ln_val = ln_gamma(x + 1.0);
+
+        // If gamma overflows or is invalid, map to NUM
+        if !ln_val.is_finite() || ln_val > f64::MAX.ln() {
+            return Err(Error::NUM);
+        }
+
+        Ok(ln_val.exp())
     });
+
+    single_number_fn!(fn_factdouble, |x: f64| {
+        let x = x.floor();
+        if x <= -1.0 {
+            return Err(Error::NUM);
+        }
+
+        if x <= 1.0 {
+            return Ok(1.0);
+        }
+
+        // From here x > 1 and integer
+        let n = x as i64;
+
+        if n < FACTDOUBLE_TABLE.len() as i64 {
+            return Ok(FACTDOUBLE_TABLE[n as usize]);
+        }
+
+        // n!! grows very fast, so we compute it using gamma in log-space:
+        //
+        // If n is even, n = 2k:
+        //   n!! = 2^k * k!
+        // If n is odd, n = 2k + 1:
+        //   n!! = (2k+1)! / (2^k * k!)
+        //
+        // and we use ln_gamma for factorials.
+
+        let ln_val = if n % 2 == 0 {
+            // even n = 2k
+            let k = (n / 2) as f64;
+            // ln(n!!) = k * ln(2) + ln(k!)
+            k * LN_2 + ln_gamma(k + 1.0)
+        } else {
+            // odd n = 2k + 1
+            let k = ((n - 1) / 2) as f64;
+            let nn = n as f64;
+            // ln(n!!) = ln((2k+1)!) - (k * ln(2) + ln(k!))
+            ln_gamma(nn + 1.0) - (k * LN_2 + ln_gamma(k + 1.0))
+        };
+
+        if !ln_val.is_finite() || ln_val > f64::MAX.ln() {
+            return Err(Error::NUM);
+        }
+
+        Ok(ln_val.exp())
+    });
+
     single_number_fn!(fn_sign, |f| {
         if f == 0.0 {
             Ok(0.0)

base/src/functions/mathematical_sum.rs

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

base/src/functions/statistical/beta.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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();

base/src/functions/statistical/binom.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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);

base/src/functions/statistical/chisq.rs

@@ -6,7 +6,14 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+// Helper to check if two shapes are the same or compatible 1D shapes
+pub(crate) 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 {
     // CHISQ.DIST(x, deg_freedom, cumulative)
     pub(crate) fn fn_chisq_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {
@@ -303,10 +310,171 @@ impl<'a> Model<'a> {
 
     // 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)
-        {
+        if args.len() != 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let actual_range = self.evaluate_node_in_context(&args[0], cell);
+        let expected_range = self.evaluate_node_in_context(&args[1], cell);
+
+        let (width, height, values_left, values_right) = match (actual_range, expected_range) {
+            (
+                CalcResult::Range {
+                    left: l1,
+                    right: r1,
+                },
+                CalcResult::Range {
+                    left: l2,
+                    right: r2,
+                },
+            ) => {
+                if l1.sheet != l2.sheet {
+                    return 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 CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Ranges must be of the same shape".to_string(),
+                    );
+                }
+                let values_left = match self.values_from_range(l1, r1) {
+                    Err(error) => {
+                        return error;
+                    }
                     Ok(v) => v,
-            Err(r) => return r,
+                };
+                let values_right = match self.values_from_range(l2, r2) {
+                    Err(error) => {
+                        return error;
+                    }
+                    Ok(v) => v,
+                };
+                (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 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 CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error in first array: {:?}", error),
+                        );
+                    }
+                    Ok(v) => v,
+                };
+                let values_right = match self.values_from_range(l2, r2) {
+                    Err(error) => {
+                        return error;
+                    }
+                    Ok(v) => v,
+                };
+                (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 CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Range and array must be of the same shape".to_string(),
+                    );
+                }
+                let values_left = match self.values_from_range(l1, r1) {
+                    Err(error) => {
+                        return error;
+                    }
+                    Ok(v) => v,
+                };
+                let values_right = match self.values_from_array(right) {
+                    Err(error) => {
+                        return 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 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 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 CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error in second array: {:?}", error),
+                        );
+                    }
+                    Ok(v) => v,
+                };
+                (rows1, cols1, values_left, values_right)
+            }
+            _ => {
+                return CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Both arguments must be ranges or arrays".to_string(),
+                );
+            }
         };
 
         let mut values = Vec::with_capacity(values_left.len());

base/src/functions/statistical/correl.rs

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

base/src/functions/statistical/count_and_average.rs

@@ -1,5 +1,3 @@
-use std::cmp::Ordering;
-
 use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::ArrayNode;
 use crate::expressions::types::CellReferenceIndex;
@@ -7,220 +5,78 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
-    fn for_each_value<F>(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-        mut f: F,
-    ) -> Result<(), CalcResult>
-    where
-        F: FnMut(f64),
-    {
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    f(value);
-                }
-                CalcResult::Boolean(value) => {
-                    if !matches!(arg, Node::ReferenceKind { .. }) {
-                        f(if value { 1.0 } else { 0.0 });
-                    }
-                }
-                CalcResult::String(value) => {
-                    if !matches!(arg, Node::ReferenceKind { .. }) {
-                        if let Some(parsed) = self.cast_number(&value) {
-                            f(parsed);
-                        } else {
-                            return Err(CalcResult::new_error(
-                                Error::VALUE,
-                                cell,
-                                "Argument cannot be cast into number".to_string(),
-                            ));
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    f(value);
-                                }
-                                ArrayNode::Boolean(b) => {
-                                    f(if b { 1.0 } else { 0.0 });
-                                }
-                                ArrayNode::Error(error) => {
-                                    return Err(CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    });
-                                }
-                                _ => {
-                                    // ignore non-numeric
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        ));
-                    }
-
-                    for row in left.row..=right.row {
-                        for column in left.column..=right.column {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    f(value);
-                                }
-                                error @ CalcResult::Error { .. } => return Err(error),
-                                CalcResult::Range { .. } => {
-                                    return Err(CalcResult::new_error(
-                                        Error::ERROR,
-                                        cell,
-                                        "Unexpected Range".to_string(),
-                                    ));
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return Err(error),
-                // Everything else is ignored
-                _ => {}
-            }
-        }
-
-        Ok(())
-    }
-
-    fn for_each_value_a<F>(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-        mut f: F,
-    ) -> Result<(), CalcResult>
-    where
-        F: FnMut(f64),
-    {
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Number(value) => {
-                    f(value);
-                }
-                CalcResult::Boolean(value) => {
-                    if !matches!(arg, Node::ReferenceKind { .. }) {
-                        f(if value { 1.0 } else { 0.0 });
-                    }
-                }
-                CalcResult::String(value) => {
-                    if !matches!(arg, Node::ReferenceKind { .. }) {
-                        if let Some(parsed) = self.cast_number(&value) {
-                            f(parsed);
-                        } else {
-                            return Err(CalcResult::new_error(
-                                Error::VALUE,
-                                cell,
-                                "Argument cannot be cast into number".to_string(),
-                            ));
-                        }
-                    }
-                }
-                CalcResult::Array(array) => {
-                    for row in array {
-                        for value in row {
-                            match value {
-                                ArrayNode::Number(value) => {
-                                    f(value);
-                                }
-                                ArrayNode::Boolean(b) => {
-                                    f(if b { 1.0 } else { 0.0 });
-                                }
-                                ArrayNode::String(_) => {
-                                    f(0.0);
-                                }
-                                ArrayNode::Error(error) => {
-                                    return Err(CalcResult::Error {
-                                        error,
-                                        origin: cell,
-                                        message: "Error in array".to_string(),
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return Err(CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        ));
-                    }
-
-                    for row in left.row..=right.row {
-                        for column in left.column..=right.column {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Number(value) => {
-                                    f(value);
-                                }
-                                CalcResult::Boolean(b) => {
-                                    f(if b { 1.0 } else { 0.0 });
-                                }
-                                CalcResult::String(_) => {
-                                    f(0.0);
-                                }
-                                error @ CalcResult::Error { .. } => return Err(error),
-                                CalcResult::Range { .. } => {
-                                    return Err(CalcResult::new_error(
-                                        Error::ERROR,
-                                        cell,
-                                        "Unexpected Range".to_string(),
-                                    ));
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return Err(error),
-                // Everything else is ignored
-                _ => {}
-            }
-        }
-
-        Ok(())
-    }
-
+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;
-        if let Err(e) = self.for_each_value(args, cell, |f| {
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
                     count += 1.0;
-            sum += f;
-        }) {
-            return e;
+                    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,
@@ -230,7 +86,6 @@ impl<'a> Model<'a> {
         }
         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);
@@ -588,484 +443,4 @@ impl<'a> Model<'a> {
 
         CalcResult::Number(sum_abs_dev / n)
     }
-
-    pub(crate) fn fn_median(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut values: Vec<f64> = Vec::new();
-        if let Err(e) = self.for_each_value(args, cell, |f| values.push(f)) {
-            return e;
-        }
-
-        if values.is_empty() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "No numeric values for MEDIAN".to_string(),
-            };
-        }
-
-        values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
-
-        let n = values.len();
-        let median = if n % 2 == 1 {
-            // odd
-            values[n / 2]
-        } else {
-            // even: average of the two middle values
-            let a = values[(n / 2) - 1];
-            let b = values[n / 2];
-            (a + b) / 2.0
-        };
-
-        CalcResult::Number(median)
-    }
-
-    pub(crate) fn fn_harmean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut values: Vec<f64> = Vec::new();
-        if let Err(e) = self.for_each_value(args, cell, |f| values.push(f)) {
-            return e;
-        }
-
-        if values.is_empty() {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Division by Zero".to_string(),
-            };
-        }
-
-        // Excel HARMEAN: all values must be > 0
-        if values.iter().any(|&v| v <= 0.0) {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "HARMEAN requires strictly positive values".to_string(),
-            };
-        }
-
-        let n = values.len() as f64;
-        let sum_recip: f64 = values.iter().map(|v| 1.0 / v).sum();
-
-        if sum_recip == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Division by Zero".to_string(),
-            };
-        }
-
-        CalcResult::Number(n / sum_recip)
-    }
-
-    pub(crate) fn fn_mina(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let mut mina: Option<f64> = None;
-        if let Err(e) = self.for_each_value_a(args, cell, |f| {
-            if let Some(m) = mina {
-                mina = Some(m.min(f));
-            } else {
-                mina = Some(f);
-            }
-        }) {
-            return e;
-        }
-        if let Some(mina) = mina {
-            CalcResult::Number(mina)
-        } else {
-            CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No numeric values for MINA".to_string(),
-            }
-        }
-    }
-
-    pub(crate) fn fn_maxa(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let mut maxa: Option<f64> = None;
-        if let Err(e) = self.for_each_value_a(args, cell, |f| {
-            if let Some(m) = maxa {
-                maxa = Some(m.max(f));
-            } else {
-                maxa = Some(f);
-            }
-        }) {
-            return e;
-        }
-        if let Some(maxa) = maxa {
-            CalcResult::Number(maxa)
-        } else {
-            CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No numeric values for MAXA".to_string(),
-            }
-        }
-    }
-
-    pub(crate) fn fn_skew(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // Sample skewness (Excel SKEW)
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut values: Vec<f64> = Vec::new();
-        if let Err(e) = self.for_each_value(args, cell, |f| values.push(f)) {
-            return e;
-        }
-
-        let n = values.len();
-        if n < 3 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "SKEW requires at least 3 data points".to_string(),
-            };
-        }
-
-        let n_f = n as f64;
-        let mean = values.iter().sum::<f64>() / n_f;
-
-        let mut m2 = 0.0;
-        for &x in &values {
-            let d = x - mean;
-            m2 += d * d;
-        }
-
-        if m2 == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Zero variance in SKEW".to_string(),
-            };
-        }
-
-        let s = (m2 / (n_f - 1.0)).sqrt();
-
-        let mut sum_cubed = 0.0;
-        for &x in &values {
-            let z = (x - mean) / s;
-            sum_cubed += z * z * z;
-        }
-
-        let skew = (n_f / ((n_f - 1.0) * (n_f - 2.0))) * sum_cubed;
-        CalcResult::Number(skew)
-    }
-
-    pub(crate) fn fn_skew_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        // Population skewness (Excel SKEW.P)
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut values: Vec<f64> = Vec::new();
-        if let Err(e) = self.for_each_value(args, cell, |f| values.push(f)) {
-            return e;
-        }
-
-        let n = values.len();
-        if n < 2 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "SKEW.P requires at least 2 data points".to_string(),
-            };
-        }
-
-        let n_f = n as f64;
-        let mean = values.iter().sum::<f64>() / n_f;
-
-        let mut m2 = 0.0;
-        for &x in &values {
-            let d = x - mean;
-            m2 += d * d;
-        }
-
-        if m2 == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Zero variance in SKEW.P".to_string(),
-            };
-        }
-
-        let sigma = (m2 / n_f).sqrt();
-
-        let mut sum_cubed = 0.0;
-        for &x in &values {
-            let z = (x - mean) / sigma;
-            sum_cubed += z * z * z;
-        }
-
-        let skew_p = sum_cubed / n_f;
-        CalcResult::Number(skew_p)
-    }
-
-    pub(crate) fn fn_kurt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let mut values: Vec<f64> = Vec::new();
-        if let Err(e) = self.for_each_value(args, cell, |f| values.push(f)) {
-            return e;
-        }
-
-        let n = values.len();
-        if n < 4 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "KURT requires at least 4 data points".to_string(),
-            };
-        }
-
-        let n_f = n as f64;
-        let mean = values.iter().sum::<f64>() / n_f;
-
-        let mut m2 = 0.0;
-        for &x in &values {
-            let d = x - mean;
-            m2 += d * d;
-        }
-
-        if m2 == 0.0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Zero variance in KURT".to_string(),
-            };
-        }
-
-        let s = (m2 / (n_f - 1.0)).sqrt();
-
-        let mut sum_fourth = 0.0;
-        for &x in &values {
-            let z = (x - mean) / s;
-            sum_fourth += z * z * z * z;
-        }
-
-        let term1 = (n_f * (n_f + 1.0)) / ((n_f - 1.0) * (n_f - 2.0) * (n_f - 3.0)) * sum_fourth;
-        let term2 = 3.0 * (n_f - 1.0) * (n_f - 1.0) / ((n_f - 2.0) * (n_f - 3.0));
-
-        let kurt = term1 - term2;
-        CalcResult::Number(kurt)
-    }
-
-    pub(crate) fn fn_large(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let values = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Array(array) => match self.values_from_array(array) {
-                Ok(v) => v,
-                Err(e) => {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: format!("Unsupported array argument: {}", e),
-                    }
-                }
-            },
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(e) => return e,
-            },
-            CalcResult::Boolean(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    vec![Some(if value { 1.0 } else { 0.0 })]
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            CalcResult::Number(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    vec![Some(value)]
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            CalcResult::String(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    if let Some(parsed) = self.cast_number(&value) {
-                        vec![Some(parsed)]
-                    } else {
-                        return CalcResult::Error {
-                            error: Error::VALUE,
-                            origin: cell,
-                            message: "Unsupported argument type".to_string(),
-                        };
-                    }
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            _ => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Unsupported argument type".to_string(),
-                }
-            }
-        };
-        let k = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(s) => return s,
-        };
-        if k < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "K must be >= 1".to_string(),
-            };
-        }
-        let mut numeric_values: Vec<f64> = values.into_iter().flatten().collect();
-        if numeric_values.is_empty() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "No numeric values for LARGE".to_string(),
-            };
-        }
-        numeric_values.sort_by(|a, b| b.partial_cmp(a).unwrap_or(Ordering::Equal));
-        let k_usize = k as usize;
-        if k_usize > numeric_values.len() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "K is larger than the number of data points".to_string(),
-            };
-        }
-        CalcResult::Number(numeric_values[k_usize - 1])
-    }
-
-    pub(crate) fn fn_small(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Array(array) => match self.values_from_array(array) {
-                Ok(v) => v,
-                Err(e) => {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: format!("Unsupported array argument: {}", e),
-                    }
-                }
-            },
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(e) => return e,
-            },
-            CalcResult::Boolean(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    vec![Some(if value { 1.0 } else { 0.0 })]
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            CalcResult::Number(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    vec![Some(value)]
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            CalcResult::String(value) => {
-                if !matches!(args[0], Node::ReferenceKind { .. }) {
-                    if let Some(parsed) = self.cast_number(&value) {
-                        vec![Some(parsed)]
-                    } else {
-                        return CalcResult::Error {
-                            error: Error::VALUE,
-                            origin: cell,
-                            message: "Unsupported argument type".to_string(),
-                        };
-                    }
-                } else {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Unsupported argument type".to_string(),
-                    };
-                }
-            }
-            _ => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Unsupported argument type".to_string(),
-                }
-            }
-        };
-
-        let k = match self.get_number_no_bools(&args[1], cell) {
-            Ok(f) => f.trunc(),
-            Err(s) => return s,
-        };
-
-        if k < 1.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "K must be >= 1".to_string(),
-            };
-        }
-
-        let mut numeric_values: Vec<f64> = values.into_iter().flatten().collect();
-        if numeric_values.is_empty() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "No numeric values for SMALL".to_string(),
-            };
-        }
-
-        // For SMALL, sort ascending
-        numeric_values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
-
-        let k_usize = k as usize;
-        if k_usize > numeric_values.len() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "K is larger than the number of data points".to_string(),
-            };
-        }
-
-        CalcResult::Number(numeric_values[k_usize - 1])
-    }
 }

base/src/functions/statistical/covariance.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_covariance_p(
         &mut self,
         args: &[Node],

base/src/functions/statistical/devsq.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     // DEVSQ(number1, [number2], ...)
     pub(crate) fn fn_devsq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {

base/src/functions/statistical/exponential.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_expon_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // EXPON.DIST(x, lambda, cumulative)
         if args.len() != 3 {

base/src/functions/statistical/fisher.rs

@@ -1,12 +1,11 @@
 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<'a> Model<'a> {
+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 {
@@ -297,122 +296,4 @@ impl<'a> Model<'a> {
 
         CalcResult::Number(x)
     }
-
-    // F.TEST(array1, array2)
-    pub(crate) fn fn_f_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let values1_opts = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in first array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "First argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        // Get second sample as Vec<Option<f64>>
-        let values2_opts = match self.evaluate_node_in_context(&args[1], cell) {
-            CalcResult::Range { left, right } => match self.values_from_range(left, right) {
-                Ok(v) => v,
-                Err(error) => return error,
-            },
-            CalcResult::Array(a) => match self.values_from_array(a) {
-                Ok(v) => v,
-                Err(error) => {
-                    return CalcResult::new_error(
-                        Error::VALUE,
-                        cell,
-                        format!("Error in second array: {:?}", error),
-                    );
-                }
-            },
-            _ => {
-                return CalcResult::new_error(
-                    Error::VALUE,
-                    cell,
-                    "Second argument must be a range or array".to_string(),
-                );
-            }
-        };
-
-        let values1: Vec<f64> = values1_opts.into_iter().flatten().collect();
-        let values2: Vec<f64> = values2_opts.into_iter().flatten().collect();
-
-        let n1 = values1.len();
-        let n2 = values2.len();
-
-        // If fewer than 2 numeric values in either sample -> #DIV/0!
-        if n1 < 2 || n2 < 2 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "F.TEST requires at least two numeric values in each sample".to_string(),
-            );
-        }
-
-        let v1 = sample_var(&values1);
-        let v2 = sample_var(&values2);
-
-        if v1 <= 0.0 || v2 <= 0.0 {
-            return CalcResult::new_error(
-                Error::DIV,
-                cell,
-                "Variance of one sample is zero in F.TEST".to_string(),
-            );
-        }
-
-        // F ratio: larger variance / smaller variance
-        let mut f = v1 / v2;
-        let mut df1 = (n1 - 1) as f64;
-        let mut df2 = (n2 - 1) as f64;
-
-        if f < 1.0 {
-            f = 1.0 / f;
-            std::mem::swap(&mut df1, &mut df2);
-        }
-
-        let dist = match FisherSnedecor::new(df1, df2) {
-            Ok(d) => d,
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::NUM,
-                    cell,
-                    "Invalid parameters for F distribution in F.TEST".to_string(),
-                );
-            }
-        };
-
-        // One-tailed right-tail probability
-        let tail = 1.0 - dist.cdf(f);
-        // F.TEST is two-tailed: p = 2 * tail (with F >= 1)
-        let mut p = 2.0 * tail;
-
-        // Clamp tiny FP noise
-        if p < 0.0 && p > -1e-15 {
-            p = 0.0;
-        }
-        if p > 1.0 && p < 1.0 + 1e-15 {
-            p = 1.0;
-        }
-
-        CalcResult::Number(p)
-    }
 }

base/src/functions/statistical/gamma.rs

@@ -6,7 +6,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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);

base/src/functions/statistical/gauss.rs

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

base/src/functions/statistical/geomean.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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);

base/src/functions/statistical/hypegeom.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     // =HYPGEOM.DIST(sample_s, number_sample, population_s, number_pop, cumulative)
     pub(crate) fn fn_hyp_geom_dist(
         &mut self,

base/src/functions/statistical/if_ifs.rs

@@ -8,7 +8,7 @@ use crate::{
     model::Model,
 };
 
-impl<'a> Model<'a> {
+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()];

base/src/functions/statistical/log_normal.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_log_norm_dist(
         &mut self,
         args: &[Node],

base/src/functions/statistical/mod.rs

@@ -1,14 +1,12 @@
 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;
@@ -17,7 +15,6 @@ mod normal;
 mod pearson;
 mod phi;
 mod poisson;
-mod rank_eq_avg;
 mod standard_dev;
 mod standardize;
 mod t_dist;

base/src/functions/statistical/normal.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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 {

base/src/functions/statistical/pearson.rs

@@ -1,14 +1,182 @@
 use crate::expressions::types::CellReferenceIndex;
+use crate::functions::statistical::chisq::is_same_shape_or_1d;
 use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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,
+        if args.len() != 2 {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let left_arg = self.evaluate_node_in_context(&args[0], cell);
+        let right_arg = self.evaluate_node_in_context(&args[1], cell);
+
+        let (values_left, values_right) = match (left_arg, right_arg) {
+            (
+                CalcResult::Range {
+                    left: l1,
+                    right: r1,
+                },
+                CalcResult::Range {
+                    left: l2,
+                    right: r2,
+                },
+            ) => {
+                if l1.sheet != l2.sheet {
+                    return 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 CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Ranges must be of the same shape".to_string(),
+                    );
+                }
+
+                let values_left = match self.values_from_range(l1, r1) {
+                    Err(error) => return error,
+                    Ok(v) => v,
+                };
+                let values_right = match self.values_from_range(l2, r2) {
+                    Err(error) => return error,
+                    Ok(v) => v,
+                };
+
+                (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 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 CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error in first array: {:?}", error),
+                        );
+                    }
+                    Ok(v) => v,
+                };
+                let values_right = match self.values_from_range(l2, r2) {
+                    Err(error) => return error,
+                    Ok(v) => v,
+                };
+
+                (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 CalcResult::new_error(
+                        Error::VALUE,
+                        cell,
+                        "Range and array must be of the same shape".to_string(),
+                    );
+                }
+
+                let values_left = match self.values_from_range(l1, r1) {
+                    Err(error) => return error,
+                    Ok(v) => v,
+                };
+                let values_right = match self.values_from_array(right) {
+                    Err(error) => {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error in second array: {:?}", error),
+                        );
+                    }
+                    Ok(v) => v,
+                };
+
+                (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 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 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 CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            format!("Error in second array: {:?}", error),
+                        );
+                    }
+                    Ok(v) => v,
+                };
+
+                (values_left, values_right)
+            }
+            _ => {
+                return CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Both arguments must be ranges or arrays".to_string(),
+                );
+            }
         };
 
         // Flatten into (x, y) pairs, skipping non-numeric entries (None)
@@ -60,54 +228,8 @@ impl<'a> Model<'a> {
         }
 
         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)
+
+        CalcResult::Number(r)
     }
 }

base/src/functions/statistical/phi.rs

@@ -1,7 +1,7 @@
 use crate::expressions::types::CellReferenceIndex;
 use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
 
-impl<'a> Model<'a> {
+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 {

base/src/functions/statistical/poisson.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     // =POISSON.DIST(x, mean, cumulative)
     pub(crate) fn fn_poisson_dist(
         &mut self,

base/src/functions/statistical/rank_eq_avg.rs

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

base/src/functions/statistical/standard_dev.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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);

base/src/functions/statistical/standardize.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_standardize(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // STANDARDIZE(x, mean, standard_dev)
         if args.len() != 3 {

base/src/functions/statistical/t_dist.rs

@@ -17,7 +17,7 @@ fn mean(xs: &[f64]) -> f64 {
     s / (n as f64)
 }
 
-pub(crate) fn sample_var(xs: &[f64]) -> f64 {
+fn sample_var(xs: &[f64]) -> f64 {
     let n = xs.len();
     if n < 2 {
         return 0.0;
@@ -42,7 +42,7 @@ enum TTestTails {
     TwoTailed,
 }
 
-impl<'a> Model<'a> {
+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 {

base/src/functions/statistical/variance.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+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);

base/src/functions/statistical/weibull.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl<'a> Model<'a> {
+impl Model {
     // WEIBULL.DIST(x, alpha, beta, cumulative)
     pub(crate) fn fn_weibull_dist(
         &mut self,

base/src/functions/statistical/z_test.rs

@@ -4,7 +4,7 @@ use crate::expressions::token::Error;
 use crate::expressions::types::CellReferenceIndex;
 use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
 
-impl<'a> Model<'a> {
+impl Model {
     // Z.TEST(array, x, [sigma])
     pub(crate) fn fn_z_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // 2 or 3 arguments

base/src/functions/subtotal.rs

@@ -32,7 +32,7 @@ pub enum CellTableStatus {
     Filtered,
 }
 
-impl<'a> Model<'a> {
+impl Model {
     fn get_table_for_cell(&self, sheet_index: u32, row: i32, column: i32) -> bool {
         let worksheet = match self.workbook.worksheet(sheet_index) {
             Ok(ws) => ws,

base/src/functions/text.rs

@@ -50,7 +50,7 @@ fn search(search_for: &str, text: &str, start: usize) -> Option<i32> {
     None
 }
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn fn_concat(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let mut result = "".to_string();
         for arg in args {
@@ -149,7 +149,7 @@ impl<'a> Model<'a> {
                 Ok(s) => s,
                 Err(s) => return s,
             };
-            let d = format_number(value, &format_code, self.locale);
+            let d = format_number(value, &format_code, &self.locale);
             if let Some(_e) = d.error {
                 return CalcResult::Error {
                     error: Error::VALUE,
@@ -1210,15 +1210,7 @@ impl<'a> Model<'a> {
         match self.evaluate_node_in_context(&args[0], cell) {
             CalcResult::String(text) => {
                 let currencies = vec!["$", "€"];
-                let (decimal_separator, group_separator) =
-                    if self.locale.numbers.symbols.decimal == "," {
-                        (b',', b'.')
-                    } else {
-                        (b'.', b',')
-                    };
-                if let Ok((value, _)) =
-                    parse_formatted_number(&text, &currencies, decimal_separator, group_separator)
-                {
+                if let Ok((value, _)) = parse_formatted_number(&text, &currencies) {
                     return CalcResult::Number(value);
                 };
                 CalcResult::Error {

base/src/functions/xlookup.rs

@@ -118,7 +118,7 @@ fn linear_search(
     None
 }
 
-impl<'a> Model<'a> {
+impl Model {
     /// The XLOOKUP function searches a range or an array, and then returns the item corresponding
     /// to the first match it finds. If no match exists, then XLOOKUP can return the closest (approximate) match.
     /// =XLOOKUP(lookup_value, lookup_array, return_array, [if_not_found], [match_mode], [search_mode])

base/src/language/mod.rs

@@ -2,13 +2,13 @@ use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Booleans {
     pub r#true: String,
     pub r#false: String,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Errors {
     pub r#ref: String,
     pub name: String,
@@ -24,367 +24,10 @@ pub struct Errors {
     pub null: String,
 }
 
-#[derive(Encode, Decode)]
-pub struct Functions {
-    pub and: String,
-    pub r#false: String,
-    pub r#if: String,
-    pub iferror: String,
-    pub ifna: String,
-    pub ifs: String,
-    pub not: String,
-    pub or: String,
-    pub switch: String,
-    pub r#true: String,
-    pub xor: String,
-    pub log: String,
-    pub log10: String,
-    pub ln: String,
-    pub sin: String,
-    pub cos: String,
-    pub tan: String,
-    pub asin: String,
-    pub acos: String,
-    pub atan: String,
-    pub sinh: String,
-    pub cosh: String,
-    pub tanh: String,
-    pub asinh: String,
-    pub acosh: String,
-    pub atanh: String,
-    pub acot: String,
-    pub acoth: String,
-    pub cot: String,
-    pub coth: String,
-    pub csc: String,
-    pub csch: String,
-    pub sec: String,
-    pub sech: String,
-    pub abs: String,
-    pub pi: String,
-    pub sqrt: String,
-    pub sqrtpi: String,
-    pub atan2: String,
-    pub power: String,
-    pub max: String,
-    pub min: String,
-    pub product: String,
-    pub rand: String,
-    pub randbetween: String,
-    pub round: String,
-    pub rounddown: String,
-    pub roundup: String,
-    pub sum: String,
-    pub sumif: String,
-    pub sumifs: String,
-    pub choose: String,
-    pub column: String,
-    pub columns: String,
-    pub index: String,
-    pub indirect: String,
-    pub hlookup: String,
-    pub lookup: String,
-    pub r#match: String,
-    pub offset: String,
-    pub row: String,
-    pub rows: String,
-    pub vlookup: String,
-    pub xlookup: String,
-    pub concatenate: String,
-    pub exact: String,
-    pub value: String,
-    pub t: String,
-    pub valuetotext: String,
-    pub concat: String,
-    pub find: String,
-    pub left: String,
-    pub len: String,
-    pub lower: String,
-    pub mid: String,
-    pub right: String,
-    pub search: String,
-    pub text: String,
-    pub trim: String,
-    pub unicode: String,
-    pub upper: String,
-    pub isnumber: String,
-    pub isnontext: String,
-    pub istext: String,
-    pub islogical: String,
-    pub isblank: String,
-    pub iserr: String,
-    pub iserror: String,
-    pub isna: String,
-    pub na: String,
-    pub isref: String,
-    pub isodd: String,
-    pub iseven: String,
-    pub errortype: String,
-    pub formulatext: String,
-    pub isformula: String,
-    pub r#type: String,
-    pub sheet: String,
-    pub average: String,
-    pub averagea: String,
-    pub avedev: String,
-    pub averageif: String,
-    pub averageifs: String,
-    pub count: String,
-    pub counta: String,
-    pub countblank: String,
-    pub countif: String,
-    pub countifs: String,
-    pub maxifs: String,
-    pub minifs: String,
-    pub geomean: String,
-    pub year: String,
-    pub day: String,
-    pub month: String,
-    pub eomonth: String,
-    pub date: String,
-    pub datedif: String,
-    pub datevalue: String,
-    pub edate: String,
-    pub networkdays: String,
-    pub networkdaysintl: String,
-    pub time: String,
-    pub timevalue: String,
-    pub hour: String,
-    pub minute: String,
-    pub second: String,
-    pub today: String,
-    pub now: String,
-    pub days: String,
-    pub days360: String,
-    pub weekday: String,
-    pub weeknum: String,
-    pub workday: String,
-    pub workdayintl: String,
-    pub yearfrac: String,
-    pub isoweeknum: String,
-    pub pmt: String,
-    pub pv: String,
-    pub rate: String,
-    pub nper: String,
-    pub fv: String,
-    pub ppmt: String,
-    pub ipmt: String,
-    pub npv: String,
-    pub mirr: String,
-    pub irr: String,
-    pub xirr: String,
-    pub xnpv: String,
-    pub rept: String,
-    pub textafter: String,
-    pub textbefore: String,
-    pub textjoin: String,
-    pub substitute: String,
-    pub ispmt: String,
-    pub rri: String,
-    pub sln: String,
-    pub syd: String,
-    pub nominal: String,
-    pub effect: String,
-    pub pduration: String,
-    pub tbillyield: String,
-    pub tbillprice: String,
-    pub tbilleq: String,
-    pub dollarde: String,
-    pub dollarfr: String,
-    pub ddb: String,
-    pub db: String,
-    pub cumprinc: String,
-    pub cumipmt: String,
-    pub besseli: String,
-    pub besselj: String,
-    pub besselk: String,
-    pub bessely: String,
-    pub erf: String,
-    pub erfprecise: String,
-    pub erfc: String,
-    pub erfcprecise: String,
-    pub bin2dec: String,
-    pub bin2hex: String,
-    pub bin2oct: String,
-    pub dec2bin: String,
-    pub dec2hex: String,
-    pub dec2oct: String,
-    pub hex2bin: String,
-    pub hex2dec: String,
-    pub hex2oct: String,
-    pub oct2bin: String,
-    pub oct2dec: String,
-    pub oct2hex: String,
-    pub bitand: String,
-    pub bitlshift: String,
-    pub bitor: String,
-    pub bitrshift: String,
-    pub bitxor: String,
-    pub complex: String,
-    pub imabs: String,
-    pub imaginary: String,
-    pub imargument: String,
-    pub imconjugate: String,
-    pub imcos: String,
-    pub imcosh: String,
-    pub imcot: String,
-    pub imcsc: String,
-    pub imcsch: String,
-    pub imdiv: String,
-    pub imexp: String,
-    pub imln: String,
-    pub imlog10: String,
-    pub imlog2: String,
-    pub impower: String,
-    pub improduct: String,
-    pub imreal: String,
-    pub imsec: String,
-    pub imsech: String,
-    pub imsin: String,
-    pub imsinh: String,
-    pub imsqrt: String,
-    pub imsub: String,
-    pub imsum: String,
-    pub imtan: String,
-    pub convert: String,
-    pub delta: String,
-    pub gestep: String,
-    pub subtotal: String,
-    pub exp: String,
-    pub fact: String,
-    pub factdouble: String,
-    pub sign: String,
-    pub radians: String,
-    pub degrees: String,
-    pub int: String,
-    pub even: String,
-    pub odd: String,
-    pub ceiling: String,
-    pub ceilingmath: String,
-    pub ceilingprecise: String,
-    pub floor: String,
-    pub floormath: String,
-    pub floorprecise: String,
-    pub isoceiling: String,
-    pub r#mod: String,
-    pub quotient: String,
-    pub mround: String,
-    pub trunc: String,
-    pub gcd: String,
-    pub lcm: String,
-    pub base: String,
-    pub decimal: String,
-    pub roman: String,
-    pub arabic: String,
-    pub combin: String,
-    pub combina: String,
-    pub sumsq: String,
-    pub n: String,
-    pub cell: String,
-    pub info: String,
-    pub sheets: String,
-    pub daverage: String,
-    pub dcount: String,
-    pub dget: String,
-    pub dmax: String,
-    pub dmin: String,
-    pub dsum: String,
-    pub dcounta: String,
-    pub dproduct: String,
-    pub dstdev: String,
-    pub dvar: String,
-    pub dvarp: String,
-    pub dstdevp: String,
-    pub betadist: String,
-    pub betainv: String,
-    pub binomdist: String,
-    pub binomdistrange: String,
-    pub binominv: String,
-    pub chisqdist: String,
-    pub chisqdistrt: String,
-    pub chisqinv: String,
-    pub chisqinvrt: String,
-    pub chisqtest: String,
-    pub confidencenorm: String,
-    pub confidencet: String,
-    pub covariancep: String,
-    pub covariances: String,
-    pub devsq: String,
-    pub expondist: String,
-    pub fdist: String,
-    pub fdistrt: String,
-    pub finv: String,
-    pub finvrt: String,
-    pub fisher: String,
-    pub fisherinv: String,
-    pub ftest: String,
-    pub gamma: String,
-    pub gammadist: String,
-    pub gammainv: String,
-    pub gammaln: String,
-    pub gammalnprecise: String,
-    pub hypgeomdist: String,
-    pub lognormdist: String,
-    pub lognorminv: String,
-    pub negbinomdist: String,
-    pub normdist: String,
-    pub norminv: String,
-    pub normsdist: String,
-    pub normsinv: String,
-    pub pearson: String,
-    pub phi: String,
-    pub poissondist: String,
-    pub standardize: String,
-    pub stdevp: String,
-    pub stdevs: String,
-    pub stdeva: String,
-    pub stdevpa: String,
-    pub tdist: String,
-    pub tdist2t: String,
-    pub tdistrt: String,
-    pub tinv: String,
-    pub tinv2t: String,
-    pub ttest: String,
-    pub varp: String,
-    pub vars: String,
-    pub varpa: String,
-    pub vara: String,
-    pub weibulldist: String,
-    pub ztest: String,
-    pub sumx2my2: String,
-    pub sumx2py2: String,
-    pub sumxmy2: String,
-    pub correl: String,
-    pub rsq: String,
-    pub intercept: String,
-    pub slope: String,
-    pub steyx: String,
-    pub gauss: String,
-    pub harmean: String,
-    pub kurt: String,
-    pub large: String,
-    pub maxa: String,
-    pub median: String,
-    pub mina: String,
-    pub rankavg: String,
-    pub rankeq: String,
-    pub skew: String,
-    pub skewp: String,
-    pub small: String,
-}
-
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Language {
-    pub name: String,
-    pub code: String,
     pub booleans: Booleans,
     pub errors: Errors,
-    pub functions: Functions,
-}
-
-pub fn get_default_language() -> &'static Language {
-    #[allow(clippy::unwrap_used)]
-    get_language("en").unwrap()
 }
 
 static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
@@ -396,7 +39,7 @@ fn get_languages() -> &'static HashMap<String, Language> {
     })
 }
 
-pub fn get_language(id: &str) -> Result<&'static Language, String> {
+pub fn get_language(id: &str) -> Result<&Language, String> {
     get_languages()
         .get(id)
         .ok_or_else(|| format!("Language is not supported: '{id}'"))

base/src/lib.rs

@@ -57,10 +57,8 @@ mod test;
 #[cfg(test)]
 pub mod mock_time;
 
-pub use locale::get_supported_locales;
 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
 pub use user_model::BorderArea;
 pub use user_model::ClipboardData;
 pub use user_model::UserModel;
-pub use utils::get_all_timezones;

base/src/locale/mod.rs

@@ -2,39 +2,36 @@ use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Locale {
     pub dates: Dates,
     pub numbers: NumbersProperties,
     pub currency: Currency,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Currency {
     pub iso: String,
     pub symbol: String,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersProperties {
     pub symbols: NumbersSymbols,
     pub decimal_formats: DecimalFormats,
     pub currency_formats: CurrencyFormats,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct Dates {
     pub day_names: Vec<String>,
     pub day_names_short: Vec<String>,
     pub months: Vec<String>,
     pub months_short: Vec<String>,
     pub months_letter: Vec<String>,
-    pub date_formats: DateFormats,
-    pub time_formats: DateFormats,
-    pub date_time_formats: DateFormats,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersSymbols {
     pub decimal: String,
     pub group: String,
@@ -52,7 +49,7 @@ pub struct NumbersSymbols {
 }
 
 // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct CurrencyFormats {
     pub standard: String,
     pub standard_alpha_next_to_number: Option<String>,
@@ -62,32 +59,11 @@ pub struct CurrencyFormats {
     pub accounting_no_currency: String,
 }
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Clone)]
 pub struct DecimalFormats {
     pub standard: String,
 }
 
-#[derive(Encode, Decode)]
-pub struct DateFormats {
-    pub full: String,
-    pub long: String,
-    pub medium: String,
-    pub short: String,
-}
-
-#[derive(Encode, Decode)]
-pub struct TimeFormats {
-    pub full: String,
-    pub long: String,
-    pub medium: String,
-    pub short: String,
-}
-
-pub fn get_default_locale() -> &'static Locale {
-    #[allow(clippy::unwrap_used)]
-    get_locale("en").unwrap()
-}
-
 static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
 
 #[allow(clippy::expect_used)]
@@ -97,12 +73,7 @@ fn get_locales() -> &'static HashMap<String, Locale> {
     })
 }
 
-/// Get all available locale IDs.
-pub fn get_supported_locales() -> Vec<String> {
-    get_locales().keys().cloned().collect()
-}
-
-pub fn get_locale(id: &str) -> Result<&'static Locale, String> {
+pub fn get_locale(id: &str) -> Result<&Locale, String> {
     get_locales()
         .get(id)
         .ok_or_else(|| format!("Invalid locale: '{id}'"))

base/src/model.rs

@@ -11,7 +11,7 @@ use crate::{
         lexer::LexerMode,
         parser::{
             move_formula::{move_formula, MoveContext},
-            stringify::{rename_defined_name_in_node, to_localized_string, to_rc_format},
+            stringify::{rename_defined_name_in_node, to_rc_format, to_string},
             Node, Parser,
         },
         token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
@@ -24,8 +24,8 @@ use crate::{
     },
     functions::util::compare_values,
     implicit_intersection::implicit_intersection,
-    language::{get_default_language, get_language, Language},
-    locale::{get_locale, Locale},
+    language::{get_language, Language},
+    locale::{get_locale, Currency, Locale},
     types::*,
     utils as common,
 };
@@ -95,7 +95,7 @@ pub(crate) enum ParsedDefinedName {
 /// * A list of cells with its status (evaluating, evaluated, not evaluated)
 /// * A dictionary with the shared strings and their indices.
 ///   This is an optimization for large files (~1 million rows)
-pub struct Model<'a> {
+pub struct Model {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
     /// A list of parsed formulas
@@ -105,13 +105,13 @@ pub struct Model<'a> {
     /// An optimization to lookup strings faster
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
-    pub(crate) parser: Parser<'a>,
+    pub(crate) parser: Parser,
     /// The list of cells with formulas that are evaluated or being evaluated
     pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
-    pub(crate) locale: &'a Locale,
+    pub(crate) locale: Locale,
     /// The language used
-    pub(crate) language: &'a Language,
+    pub(crate) language: Language,
     /// The timezone used to evaluate the model
     pub(crate) tz: Tz,
     /// The view id. A view consists of a selected sheet and ranges.
@@ -129,7 +129,7 @@ pub struct CellIndex {
     pub column: i32,
 }
 
-impl<'a> Model<'a> {
+impl Model {
     pub(crate) fn evaluate_node_with_reference(
         &mut self,
         node: &Node,
@@ -375,7 +375,7 @@ impl<'a> Model<'a> {
             }
             FunctionKind { kind, args } => self.evaluate_function(kind, args, cell),
             InvalidFunctionKind { name, args: _ } => {
-                CalcResult::new_error(Error::NAME, cell, format!("Invalid function: {name}"))
+                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}"))
             }
             ArrayKind(s) => CalcResult::Array(s.to_owned()),
             DefinedNameKind((name, scope, _)) => {
@@ -680,7 +680,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// assert_eq!(model.workbook.worksheet(0)?.color, None);
     /// model.set_sheet_color(0, "#DBBE29")?;
     /// assert_eq!(model.workbook.worksheet(0)?.color, Some("#DBBE29".to_string()));
@@ -721,7 +721,7 @@ impl<'a> Model<'a> {
             BooleanCell { v, .. } => CalcResult::Boolean(*v),
             NumberCell { v, .. } => CalcResult::Number(*v),
             ErrorCell { ei, .. } => {
-                let message = ei.to_localized_error_string(self.language);
+                let message = ei.to_localized_error_string(&self.language);
                 CalcResult::new_error(ei.clone(), cell_reference, message)
             }
             SharedString { si, .. } => {
@@ -747,7 +747,7 @@ impl<'a> Model<'a> {
                     CalcResult::Error {
                         error: ei.clone(),
                         origin: cell_reference,
-                        message: ei.to_localized_error_string(self.language),
+                        message: ei.to_localized_error_string(&self.language),
                     }
                 }
             }
@@ -761,7 +761,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// assert_eq!(model.is_empty_cell(0, 1, 1)?, true);
     /// model.set_user_input(0, 1, 1, "Attention is all you need".to_string());
     /// assert_eq!(model.is_empty_cell(0, 1, 1)?, false);
@@ -839,9 +839,9 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::cell::CellValue;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// model.set_user_input(0, 1, 1, "Stella!".to_string());
-    /// let model2 = Model::from_bytes(&model.to_bytes(), "en")?;
+    /// let model2 = Model::from_bytes(&model.to_bytes())?;
     /// assert_eq!(
     ///     model2.get_cell_value_by_index(0, 1, 1),
     ///     Ok(CellValue::String("Stella!".to_string()))
@@ -852,10 +852,10 @@ impl<'a> Model<'a> {
     ///
     /// See also:
     /// * [Model::to_bytes]
-    pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result<Model<'a>, String> {
+    pub fn from_bytes(s: &[u8]) -> Result<Model, String> {
         let workbook: Workbook =
             bitcode::decode(s).map_err(|e| format!("Error parsing workbook: {e}"))?;
-        Model::from_workbook(workbook, language_id)
+        Model::from_workbook(workbook)
     }
 
     /// Returns a model from a Workbook object
@@ -866,9 +866,9 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::cell::CellValue;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// model.set_user_input(0, 1, 1, "Stella!".to_string());
-    /// let model2 = Model::from_workbook(model.workbook, "en")?;
+    /// let model2 = Model::from_workbook(model.workbook)?;
     /// assert_eq!(
     ///     model2.get_cell_value_by_index(0, 1, 1),
     ///     Ok(CellValue::String("Stella!".to_string()))
@@ -876,7 +876,7 @@ impl<'a> Model<'a> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result<Model<'_>, String> {
+    pub fn from_workbook(workbook: Workbook) -> Result<Model, String> {
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
 
@@ -892,27 +892,20 @@ impl<'a> Model<'a> {
         //     }
         //     tables.push(tables_in_sheet);
         // }
-
+        let parser = Parser::new(worksheet_names, defined_names, workbook.tables.clone());
         let cells = HashMap::new();
-        let locale =
-            get_locale(&workbook.settings.locale).map_err(|_| "Invalid locale".to_string())?;
+        let locale = get_locale(&workbook.settings.locale)
+            .map_err(|_| "Invalid locale".to_string())?
+            .clone();
         let tz: Tz = workbook
             .settings
             .tz
             .parse()
             .map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?;
 
-        let language = match get_language(language_id) {
-            Ok(lang) => lang,
-            Err(_) => return Err("Invalid language".to_string()),
-        };
-        let parser = Parser::new(
-            worksheet_names,
-            defined_names,
-            workbook.tables.clone(),
-            locale,
-            language,
-        );
+        // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
+        let language = get_language("en").expect("").clone();
         let mut shared_strings = HashMap::new();
         for (index, s) in workbook.shared_strings.iter().enumerate() {
             shared_strings.insert(s.to_string(), index);
@@ -945,7 +938,7 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::expressions::types::CellReferenceIndex;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// model.set_user_input(0, 1, 1, "Stella!".to_string());
     /// let reference = model.parse_reference("Sheet1!D40");
     /// assert_eq!(reference, Some(CellReferenceIndex {sheet: 0, row: 40, column: 4}));
@@ -1011,7 +1004,7 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::expressions::types::{Area, CellReferenceIndex};
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let source = CellReferenceIndex { sheet: 0, row: 3, column: 1};
     /// let target = CellReferenceIndex { sheet: 0, row: 50, column: 1};
     /// let area = Area { sheet: 0, row: 1, column: 1, width: 5, height: 4};
@@ -1067,8 +1060,6 @@ impl<'a> Model<'a> {
                     row_delta: target.row - source.row,
                     column_delta: target.column - source.column,
                 },
-                self.locale,
-                self.language,
             );
             Ok(format!("={formula_str}"))
         } else {
@@ -1083,7 +1074,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "=B1*D4".to_string());
     /// let (target_row, target_column) = (30, 1);
@@ -1107,7 +1098,7 @@ impl<'a> Model<'a> {
         let cell = self.workbook.worksheet(sheet)?.cell(row, column);
         let result = match cell {
             Some(cell) => match cell.get_formula() {
-                None => cell.get_localized_text(&self.workbook.shared_strings, self.language),
+                None => cell.get_text(&self.workbook.shared_strings, &self.language),
                 Some(i) => {
                     let formula = &self.parsed_formulas[sheet as usize][i as usize];
                     let cell_ref = CellReferenceRC {
@@ -1115,10 +1106,7 @@ impl<'a> Model<'a> {
                         row: target_row,
                         column: target_column,
                     };
-                    format!(
-                        "={}",
-                        to_localized_string(formula, &cell_ref, self.locale, self.language)
-                    )
+                    format!("={}", to_string(formula, &cell_ref))
                 }
             },
             None => "".to_string(),
@@ -1134,7 +1122,7 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::expressions::types::CellReferenceIndex;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let source = CellReferenceIndex {sheet: 0, row: 1, column: 1};
     /// let target = CellReferenceIndex {sheet: 0, row: 30, column: 1};
     /// let result = model.extend_copied_value("=B1*D4", &source, &target)?;
@@ -1176,10 +1164,7 @@ impl<'a> Model<'a> {
                 row: target.row,
                 column: target.column,
             };
-            return Ok(format!(
-                "={}",
-                to_localized_string(formula, &cell_reference, self.locale, self.language)
-            ));
+            return Ok(format!("={}", to_string(formula, &cell_reference)));
         };
         Ok(value.to_string())
     }
@@ -1191,7 +1176,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "=SIN(B1*C3)+1".to_string());
     /// model.evaluate();
@@ -1202,7 +1187,7 @@ impl<'a> Model<'a> {
     /// ```
     ///
     /// See also:
-    /// * [Model::get_localized_cell_content()]
+    /// * [Model::get_cell_content()]
     pub fn get_cell_formula(
         &self,
         sheet: u32,
@@ -1224,47 +1209,7 @@ impl<'a> Model<'a> {
                         row,
                         column,
                     };
-                    Ok(Some(format!(
-                        "={}",
-                        to_localized_string(formula, &cell_ref, self.locale, self.language)
-                    )))
-                }
-                None => Ok(None),
-            },
-            None => Ok(None),
-        }
-    }
-
-    /// Returns the text for the formula in (`sheet`, `row`, `column`) in English if any
-    ///
-    /// See also:
-    /// * [Model::get_localized_cell_content()]
-    pub(crate) fn get_english_cell_formula(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<String>, String> {
-        let worksheet = self.workbook.worksheet(sheet)?;
-        match worksheet.cell(row, column) {
-            Some(cell) => match cell.get_formula() {
-                Some(formula_index) => {
-                    let formula = &self
-                        .parsed_formulas
-                        .get(sheet as usize)
-                        .ok_or("missing sheet")?
-                        .get(formula_index as usize)
-                        .ok_or("missing formula")?;
-                    let cell_ref = CellReferenceRC {
-                        sheet: worksheet.get_name(),
-                        row,
-                        column,
-                    };
-                    let language_en = get_default_language();
-                    Ok(Some(format!(
-                        "={}",
-                        to_localized_string(formula, &cell_ref, self.locale, language_en)
-                    )))
+                    Ok(Some(format!("={}", to_string(formula, &cell_ref))))
                 }
                 None => Ok(None),
             },
@@ -1280,13 +1225,13 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "Hello!".to_string())?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "Hello!".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Hello!".to_string());
     ///
     /// model.update_cell_with_text(sheet, row, column, "Goodbye!")?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "Goodbye!".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Goodbye!".to_string());
     /// # Ok(())
     /// # }
     /// ```
@@ -1305,7 +1250,7 @@ impl<'a> Model<'a> {
     ) -> Result<(), String> {
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index;
-        if common::value_needs_quoting(value, self.language) {
+        if common::value_needs_quoting(value, &self.language) {
             new_style_index = self
                 .workbook
                 .styles
@@ -1330,13 +1275,13 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "TRUE".to_string())?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "TRUE".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "TRUE".to_string());
     ///
     /// model.update_cell_with_bool(sheet, row, column, false)?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "FALSE".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "FALSE".to_string());
     /// # Ok(())
     /// # }
     /// ```
@@ -1372,13 +1317,13 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "42".to_string())?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "42".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "42".to_string());
     ///
     /// model.update_cell_with_number(sheet, row, column, 23.0)?;
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "23".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "23".to_string());
     /// # Ok(())
     /// # }
     /// ```
@@ -1415,15 +1360,15 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "=A2*2".to_string())?;
     /// model.evaluate();
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "=A2*2".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A2*2".to_string());
     ///
     /// model.update_cell_with_formula(sheet, row, column, "=A3*2".to_string())?;
     /// model.evaluate();
-    /// assert_eq!(model.get_localized_cell_content(sheet, row, column)?, "=A3*2".to_string());
+    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A3*2".to_string());
     /// # Ok(())
     /// # }
     /// ```
@@ -1468,7 +1413,7 @@ impl<'a> Model<'a> {
     /// # use ironcalc_base::Model;
     /// # use ironcalc_base::cell::CellValue;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// model.set_user_input(0, 1, 1, "100$".to_string());
     /// model.set_user_input(0, 2, 1, "125$".to_string());
     /// model.set_user_input(0, 3, 1, "-10$".to_string());
@@ -1496,7 +1441,7 @@ impl<'a> Model<'a> {
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
             // First check if it needs quoting
-            let new_style = if common::value_needs_quoting(new_value, self.language) {
+            let new_style = if common::value_needs_quoting(new_value, &self.language) {
                 self.workbook
                     .styles
                     .get_style_with_quote_prefix(style_index)?
@@ -1533,16 +1478,8 @@ impl<'a> Model<'a> {
                 if !currencies.iter().any(|e| e == currency) {
                     currencies.push(currency);
                 }
-                let (decimal_separator, group_separator) =
-                    if self.locale.numbers.symbols.decimal == "," {
-                        (b',', b'.')
-                    } else {
-                        (b'.', b',')
-                    };
                 //  We try to parse as number
-                if let Ok((v, number_format)) =
-                    parse_formatted_number(&value, &currencies, decimal_separator, group_separator)
-                {
+                if let Ok((v, number_format)) = parse_formatted_number(&value, &currencies) {
                     if let Some(num_fmt) = number_format {
                         // Should not apply the format in the following cases:
                         // - we assign a date to already date-formatted cell
@@ -1569,7 +1506,7 @@ impl<'a> Model<'a> {
                 // Check is it is error value
                 let upper = value.to_uppercase();
                 let worksheet = self.workbook.worksheet_mut(sheet)?;
-                match get_error_by_name(&upper, self.language) {
+                match get_error_by_name(&upper, &self.language) {
                     Some(error) => {
                         worksheet.set_cell_with_error(row, column, error, new_style_index)?;
                     }
@@ -1748,7 +1685,7 @@ impl<'a> Model<'a> {
             .cell(row, column)
             .cloned()
             .unwrap_or_default();
-        let cell_value = cell.value(&self.workbook.shared_strings, self.language);
+        let cell_value = cell.value(&self.workbook.shared_strings, &self.language);
         Ok(cell_value)
     }
 
@@ -1763,7 +1700,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "=1/3".to_string());
     /// model.evaluate();
@@ -1782,8 +1719,8 @@ impl<'a> Model<'a> {
             Some(cell) => {
                 let format = self.get_style_for_cell(sheet_index, row, column)?.num_fmt;
                 let formatted_value =
-                    cell.formatted_value(&self.workbook.shared_strings, self.language, |value| {
-                        format_number(value, &format, self.locale).text
+                    cell.formatted_value(&self.workbook.shared_strings, &self.language, |value| {
+                        format_number(value, &format, &self.locale).text
                     });
                 Ok(formatted_value)
             }
@@ -1799,16 +1736,10 @@ impl<'a> Model<'a> {
         })
     }
 
-    /// Returns a string with the cell content in the given language and locale.
-    /// If there is a formula returns the formula
+    /// Returns a string with the cell content. If there is a formula returns the formula
     /// If the cell is empty returns the empty string
-    /// Returns an error if there is no worksheet
-    pub fn get_localized_cell_content(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<String, String> {
+    /// Raises an error if there is no worksheet
+    pub fn get_cell_content(&self, sheet: u32, row: i32, column: i32) -> Result<String, String> {
         let worksheet = self.workbook.worksheet(sheet)?;
         let cell = match worksheet.cell(row, column) {
             Some(c) => c,
@@ -1822,12 +1753,9 @@ impl<'a> Model<'a> {
                     row,
                     column,
                 };
-                Ok(format!(
-                    "={}",
-                    to_localized_string(formula, &cell_ref, self.locale, self.language)
-                ))
+                Ok(format!("={}", to_string(formula, &cell_ref)))
             }
-            None => Ok(cell.get_localized_text(&self.workbook.shared_strings, self.language)),
+            None => Ok(cell.get_text(&self.workbook.shared_strings, &self.language)),
         }
     }
 
@@ -1879,7 +1807,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "100$".to_string());
     /// model.cell_clear_contents(sheet, row, column);
@@ -1906,7 +1834,7 @@ impl<'a> Model<'a> {
     /// ```rust
     /// # use ironcalc_base::Model;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC", "en")?;
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
     /// model.set_user_input(sheet, row, column, "100$".to_string());
     /// model.cell_clear_all(sheet, row, column);
@@ -2030,6 +1958,29 @@ impl<'a> Model<'a> {
         Ok(rows.join("\n"))
     }
 
+    /// Sets the currency of the model.
+    /// Currently we only support `USD`, `EUR`, `GBP` and `JPY`
+    /// NB: This is not preserved in the JSON.
+    pub fn set_currency(&mut self, iso: &str) -> Result<(), &str> {
+        // TODO: Add a full list
+        let symbol = if iso == "USD" {
+            "$"
+        } else if iso == "EUR" {
+            "€"
+        } else if iso == "GBP" {
+            "£"
+        } else if iso == "JPY" {
+            "¥"
+        } else {
+            return Err("Unsupported currency");
+        };
+        self.locale.currency = Currency {
+            symbol: symbol.to_string(),
+            iso: iso.to_string(),
+        };
+        Ok(())
+    }
+
     /// Returns the number of frozen rows in `sheet`
     pub fn get_frozen_rows_count(&self, sheet: u32) -> Result<i32, String> {
         if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
@@ -2155,9 +2106,12 @@ impl<'a> Model<'a> {
         }
 
         // Make sure the formula is valid
-        match common::ParsedReference::parse_reference_formula(None, formula, self.locale, |name| {
-            self.get_sheet_index_by_name(name)
-        }) {
+        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());
@@ -2342,57 +2296,6 @@ impl<'a> Model<'a> {
     pub fn delete_row_style(&mut self, sheet: u32, row: i32) -> Result<(), String> {
         self.workbook.worksheet_mut(sheet)?.delete_row_style(row)
     }
-
-    /// Sets the locale of the model
-    pub fn set_locale(&mut self, locale_id: &str) -> Result<(), String> {
-        let locale = match get_locale(locale_id) {
-            Ok(l) => l,
-            Err(_) => return Err(format!("Invalid locale: {locale_id}")),
-        };
-        self.parser.set_locale(locale);
-        self.locale = locale;
-        self.workbook.settings.locale = locale_id.to_string();
-        self.evaluate();
-        Ok(())
-    }
-
-    /// Sets the timezone of the model
-    pub fn set_timezone(&mut self, timezone: &str) -> Result<(), String> {
-        let tz: Tz = match &timezone.parse() {
-            Ok(tz) => *tz,
-            Err(_) => return Err(format!("Invalid timezone: {}", &timezone)),
-        };
-        self.tz = tz;
-        self.workbook.settings.tz = timezone.to_string();
-        self.evaluate();
-        Ok(())
-    }
-
-    /// Sets the language
-    pub fn set_language(&mut self, language_id: &str) -> Result<(), String> {
-        let language = match get_language(language_id) {
-            Ok(l) => l,
-            Err(_) => return Err(format!("Invalid language: {language_id}")),
-        };
-        self.parser.set_language(language);
-        self.language = language;
-        Ok(())
-    }
-
-    /// Gets the current language
-    pub fn get_language(&self) -> String {
-        self.language.name.clone()
-    }
-
-    /// Gets the timezone of the model
-    pub fn get_timezone(&self) -> String {
-        self.workbook.settings.tz.clone()
-    }
-
-    /// Gets the locale of the model
-    pub fn get_locale(&self) -> String {
-        self.workbook.settings.locale.clone()
-    }
 }
 
 #[cfg(test)]

base/src/new_empty.rs

@@ -8,13 +8,13 @@ use crate::{
     expressions::{
         lexer::LexerMode,
         parser::{
-            stringify::{rename_sheet_in_node, to_localized_string, to_rc_format},
+            stringify::{rename_sheet_in_node, to_rc_format, to_string},
             Parser,
         },
         types::CellReferenceRC,
     },
-    language::{get_default_language, get_language},
-    locale::{get_default_locale, get_locale},
+    language::get_language,
+    locale::get_locale,
     model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
     types::{
         DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
@@ -37,7 +37,7 @@ fn is_valid_sheet_name(name: &str) -> bool {
     !name.is_empty() && name.chars().count() <= 31 && !name.contains(&invalid[..])
 }
 
-impl<'a> Model<'a> {
+impl Model {
     /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists
     fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet {
         let mut views = HashMap::new();
@@ -81,14 +81,7 @@ impl<'a> Model<'a> {
         index + 1
     }
 
-    // This function parses all the internal formulas in all the worksheets
-    // (in the default language ("en") and locale ("en") and the RC format)
     pub(crate) fn parse_formulas(&mut self) {
-        let locale = self.locale;
-        let language = self.language;
-
-        self.parser.set_locale(get_default_locale());
-        self.parser.set_language(get_default_language());
         self.parser.set_lexer_mode(LexerMode::R1C1);
         let worksheets = &self.workbook.worksheets;
         for worksheet in worksheets {
@@ -106,8 +99,6 @@ impl<'a> Model<'a> {
             self.parsed_formulas.push(parse_formula);
         }
         self.parser.set_lexer_mode(LexerMode::A1);
-        self.parser.set_locale(locale);
-        self.parser.set_language(language);
     }
 
     pub(crate) fn parse_defined_names(&mut self) {
@@ -117,7 +108,7 @@ impl<'a> Model<'a> {
                 ParsedReference::parse_reference_formula(
                     None,
                     &defined_name.formula,
-                    self.locale,
+                    &self.locale,
                     |name| self.get_sheet_index_by_name(name),
                 ) {
                 match reference {
@@ -299,7 +290,7 @@ impl<'a> Model<'a> {
         for defined_name in &mut self.workbook.defined_names {
             let mut t = self.parser.parse(&defined_name.formula, cell_reference);
             rename_sheet_in_node(&mut t, sheet_index, new_name);
-            let formula = to_localized_string(&t, cell_reference, self.locale, self.language);
+            let formula = to_string(&t, cell_reference);
             defined_names.push(DefinedName {
                 name: defined_name.name.clone(),
                 formula,
@@ -364,24 +355,15 @@ impl<'a> Model<'a> {
     }
 
     /// Creates a new workbook with one empty sheet
-    pub fn new_empty(
-        name: &'a str,
-        locale_id: &'a str,
-        timezone: &'a str,
-        language_id: &'a str,
-    ) -> Result<Model<'a>, String> {
+    pub fn new_empty(name: &str, locale_id: &str, timezone: &str) -> Result<Model, String> {
         let tz: Tz = match &timezone.parse() {
             Ok(tz) => *tz,
             Err(_) => return Err(format!("Invalid timezone: {}", &timezone)),
         };
         let locale = match get_locale(locale_id) {
-            Ok(l) => l,
+            Ok(l) => l.clone(),
             Err(_) => return Err(format!("Invalid locale: {locale_id}")),
         };
-        let language = match get_language(language_id) {
-            Ok(l) => l,
-            Err(_) => return Err(format!("Invalid language: {language_id}")),
-        };
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
@@ -427,9 +409,13 @@ impl<'a> Model<'a> {
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
-        let parser = Parser::new(worksheet_names, vec![], HashMap::new(), locale, language);
+        let parser = Parser::new(worksheet_names, vec![], HashMap::new());
         let cells = HashMap::new();
 
+        // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
+        let language = get_language("en").expect("").clone();
+
         let mut model = Model {
             workbook,
             shared_strings: HashMap::new(),

base/src/styles.rs

@@ -213,7 +213,7 @@ impl Styles {
 }
 
 // TODO: Try to find a better spot for styles setters
-impl<'a> Model<'a> {
+impl Model {
     pub fn set_cell_style(
         &mut self,
         sheet: u32,

base/src/test/engineering/test_number_basis.rs

@@ -150,7 +150,7 @@ fn fn_hex2dec() {
     model._set("A4", r#"=HEX2DEC("FE")"#);
 
     model._set("B1", "=HEX2DEC()");
-    model._set("B2", "=HEX2DEC(1,2,3)");
+    model._set("B2", "=HHEX2DEC(1,2,3)");
 
     model.evaluate();
 

base/src/test/mod.rs

@@ -1,11 +1,11 @@
 mod test_actions;
-mod test_arabic_roman;
 mod test_binary_search;
 mod test_cell;
 mod test_cell_clear_contents;
 mod test_circular_references;
 mod test_column_width;
 mod test_criteria;
+mod test_currency;
 mod test_date_and_time;
 mod test_datedif_leap_month_end;
 mod test_days360_month_end;
@@ -18,6 +18,7 @@ mod test_fn_concatenate;
 mod test_fn_count;
 mod test_fn_day;
 mod test_fn_exact;
+mod test_fn_fact;
 mod test_fn_financial;
 mod test_fn_formulatext;
 mod test_fn_if;
@@ -39,14 +40,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;
@@ -62,13 +61,11 @@ mod test_fn_offset;
 mod test_number_format;
 
 mod test_arrays;
-mod test_cell_info_n_sheets;
 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;
@@ -79,9 +76,7 @@ mod test_get_cell_content;
 mod test_implicit_intersection;
 mod test_issue_155;
 mod test_issue_483;
-mod test_language;
 mod test_ln;
-mod test_locale;
 mod test_log;
 mod test_log10;
 mod test_mod_quotient;

base/src/test/statistical/mod.rs

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

base/src/test/statistical/test_fn_f_test.rs

@@ -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!");
-}

base/src/test/statistical/test_fn_gauss.rs

@@ -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!");
-}

base/src/test/test_arabic_roman

@@ -6,8 +6,8 @@ use crate::test::util::new_empty_model;
 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("A2", "=ARABIC(V)");
+    model._set("A3", "=ARABIC(V, 2)");
 
     model._set("A4", "=ROMAN()");
     model._set("A5", "=ROMAN(5)");