Trait Function 

pub trait Function:
    Send
    + Sync
    + 'static {
    // Required methods
    fn name(&self) -> &'static str;
    fn eval<'a, 'b, 'c>(
        &self,
        args: &'c [ArgumentHandle<'a, 'b>],
        ctx: &dyn FunctionContext<'b>,
    ) -> Result<CalcValue<'b>, ExcelError>;

    // Provided methods
    fn caps(&self) -> FnCaps { ... }
    fn namespace(&self) -> &'static str { ... }
    fn min_args(&self) -> usize { ... }
    fn variadic(&self) -> bool { ... }
    fn volatile(&self) -> bool { ... }
    fn arg_schema(&self) -> &'static [ArgSchema] { ... }
    fn aliases(&self) -> &'static [&'static str] { ... }
    fn function_salt(&self) -> u64 { ... }
    fn eval_reference<'a, 'b, 'c>(
        &self,
        _args: &'c [ArgumentHandle<'a, 'b>],
        _ctx: &dyn FunctionContext<'b>,
    ) -> Option<Result<ReferenceType, ExcelError>> { ... }
    fn dispatch<'a, 'b, 'c>(
        &self,
        args: &'c [ArgumentHandle<'a, 'b>],
        ctx: &dyn FunctionContext<'b>,
    ) -> Result<CalcValue<'b>, ExcelError> { ... }
}

Revised, object-safe trait for all Excel-style functions.

This trait uses a capability-based model (FnCaps) to declare function properties, enabling the evaluation engine to select the most optimal execution path (e.g., scalar, vectorized, parallel).

Required Methods

fn name(&self) -> &'static str

fn eval<'a, 'b, 'c>( &self, args: &'c [ArgumentHandle<'a, 'b>], ctx: &dyn FunctionContext<'b>, ) -> Result<CalcValue<'b>, ExcelError>

The unified evaluation path.

This method replaces the separate scalar, fold, and map paths. Functions use the provided ArgumentHandles to access inputs as either scalars or RangeViews (Arrow-backed virtual ranges).

Provided Methods

fn caps(&self) -> FnCaps

Capability flags for this function

fn namespace(&self) -> &'static str

fn min_args(&self) -> usize

fn variadic(&self) -> bool

fn volatile(&self) -> bool

fn arg_schema(&self) -> &'static [ArgSchema]

fn aliases(&self) -> &'static [&'static str]

Optional list of additional alias names (case-insensitive) that should resolve to this function. Default: empty slice. Implementors can override to expose legacy names. Returned slice must have ’static lifetime (typically a static array reference).

fn function_salt(&self) -> u64

fn eval_reference<'a, 'b, 'c>( &self, _args: &'c [ArgumentHandle<'a, 'b>], _ctx: &dyn FunctionContext<'b>, ) -> Option<Result<ReferenceType, ExcelError>>

Optional reference result path. Only called by the interpreter/engine when the callsite expects a reference (e.g., range combinators, by-ref argument positions, or spill sources).

Default implementation returns None, indicating the function does not support returning references. Functions that set RETURNS_REFERENCE should override this.

fn dispatch<'a, 'b, 'c>( &self, args: &'c [ArgumentHandle<'a, 'b>], ctx: &dyn FunctionContext<'b>, ) -> Result<CalcValue<'b>, ExcelError>

Dispatch to the unified evaluation path with automatic argument validation.

Implementors

impl Function for DAverageFn

Returns the arithmetic mean of values in a database field for matching records.

DAVERAGE applies criteria filtering first, then averages the numeric values in field.

Remarks

• Criteria rows are OR conditions, while criteria columns in the same row are AND conditions.
• field can be a case-insensitive header name or a 1-based column index; invalid field resolution returns #VALUE!.
• If no numeric values match, the function returns #DIV/0!.

Examples

title: "Average units for Gadget sales"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Gadget"
formula: "=DAVERAGE(A1:E7, \"Units\", G1:G2)"
expected: 29

title: "Average revenue for West or South regions"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "West"
  G3: "South"
formula: "=DAVERAGE(A1:E7, 5, G1:G3)"
expected: 97000

related:
  - DSUM
  - DCOUNT
  - AVERAGEIFS
faq:
  - q: "What happens if criteria match rows but field values are non-numeric?"
    a: "DAVERAGE skips non-numeric values and returns #DIV/0! if no numeric values remain after filtering."

[formualizer-docgen:schema:start] Name: DAVERAGE Type: DAverageFn Min args: 3 Max args: 1 Variadic: false Signature: DAVERAGE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DCountAFn

Counts non-blank values in a database field for records matching criteria.

Remarks

• DCOUNTA counts both text and numeric non-empty values.
• Criteria rows are OR-ed; criteria columns in the same row are AND-ed.
• Blank cells are excluded from the count.

Examples

title: "Count non-blank names where score > 80"
grid:
  A1: "Name"
  B1: "Score"
  A2: "Ana"
  B2: 92
  A3: "Bo"
  B3: 75
  A4: "Cy"
  B4: 88
  D1: "Score"
  D2: ">80"
formula: "=DCOUNTA(A1:B4,\"Name\",D1:D2)"
expected: 2

title: "Count all non-blank values in a field"
grid:
  A1: "Item"
  A2: "X"
  A3: "Y"
  A4: ""
  C1: "Item"
formula: "=DCOUNTA(A1:A4,\"Item\",C1:C1)"
expected: 2

related:
  - DCOUNT
  - DGET
  - COUNTA
faq:
  - q: "What is treated as blank in DCOUNTA?"
    a: "Empty cells and empty strings are treated as blank; other value types are counted when their row matches criteria."

[formualizer-docgen:schema:start] Name: DCOUNTA Type: DCountAFn Min args: 3 Max args: 1 Variadic: false Signature: DCOUNTA(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DCountFn

Counts numeric cells in a database field for records matching criteria.

DCOUNT ignores non-numeric values in the selected field even when the row itself matches.

Remarks

• Criteria rows are ORed, and criteria columns inside a single row are ANDed.
• field header lookup is case-insensitive, and numeric field uses 1-based indexing; unresolved headers or invalid indexes return #VALUE!.
• Only numeric field values contribute to the count.

Examples

title: "Count numeric revenue entries in East region"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
formula: "=DCOUNT(A1:E7, \"Revenue\", G1:G2)"
expected: 2

title: "Count numeric units for Widget or Service products"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
  G3: "Service"
formula: "=DCOUNT(A1:E7, 4, G1:G3)"
expected: 4

related:
  - DCOUNTA
  - DSUM
  - COUNTIFS
faq:
  - q: "Does DCOUNT count text values that look like numbers?"
    a: "Only values resolved as numeric in the target field are counted; true non-numeric text is ignored."

[formualizer-docgen:schema:start] Name: DCOUNT Type: DCountFn Min args: 3 Max args: 1 Variadic: false Signature: DCOUNT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DGetFn

Returns a single field value from the only record that matches criteria.

DGET is useful for keyed lookups where criteria are expected to identify exactly one record.

Remarks

• Criteria rows are OR alternatives; criteria columns inside one row are AND predicates.
• field resolves from a case-insensitive header name or 1-based index; unresolved field/header references return #VALUE!.
• Returns #VALUE! when no records match and #NUM! when multiple records match.

Examples

title: "Get salesperson for a unique North Widget record"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  H1: "Product"
  G2: "North"
  H2: "Widget"
formula: "=DGET(A1:E7, \"Salesperson\", G1:H2)"
expected: "Kim"

title: "Multiple matches return NUM error"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
formula: "=DGET(A1:E7, 5, G1:G2)"
expected: "#NUM!"

related:
  - DSUM
  - DCOUNT
  - XLOOKUP
faq:
  - q: "Why does DGET fail when criteria match two rows?"
    a: "DGET requires exactly one matching record; multiple matches produce #NUM! and zero matches produce #VALUE!."

[formualizer-docgen:schema:start] Name: DGET Type: DGetFn Min args: 3 Max args: 1 Variadic: false Signature: DGET(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DMaxFn

Returns the largest value in a database field for records matching criteria.

DMAX scans the filtered records and returns the maximum numeric value found in field.

Remarks

• Criteria rows are OR conditions; multiple non-empty criteria columns in one row are AND conditions.
• field can be a case-insensitive header string or a 1-based column index; failed resolution returns #VALUE!.
• If no numeric values are matched, this implementation returns 0.

Examples

title: "Maximum revenue for West or South"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "West"
  G3: "South"
formula: "=DMAX(A1:E7, \"Revenue\", G1:G3)"
expected: 126000

title: "Maximum units for Widget deals"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
formula: "=DMAX(A1:E7, 4, G1:G2)"
expected: 24

related:
  - DMIN
  - DGET
  - MAXIFS
faq:
  - q: "What does DMAX return when no numeric field values match criteria?"
    a: "This implementation returns 0 when the filtered set has no numeric values."

[formualizer-docgen:schema:start] Name: DMAX Type: DMaxFn Min args: 3 Max args: 1 Variadic: false Signature: DMAX(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DMinFn

Returns the smallest value in a database field for records matching criteria.

DMIN applies criteria filtering and then evaluates the minimum numeric value from field.

Remarks

• Criteria rows are ORed together; criteria columns on the same row are ANDed.
• field resolves from a case-insensitive header label or 1-based index, and invalid resolution yields #VALUE!.
• If no numeric values are matched, this implementation returns 0.

Examples

title: "Minimum revenue for East or West"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DMIN(A1:E7, \"Revenue\", G1:G3)"
expected: 46000

title: "Minimum units where revenue exceeds 100000"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Revenue"
  G2: ">100000"
formula: "=DMIN(A1:E7, 4, G1:G2)"
expected: 22

related:
  - DMAX
  - DGET
  - MINIFS
faq:
  - q: "How are mixed criteria (text plus numeric operators) handled in DMIN?"
    a: "Criteria are parsed per criteria cell, then applied as AND within row and OR across rows before the minimum is chosen."

[formualizer-docgen:schema:start] Name: DMIN Type: DMinFn Min args: 3 Max args: 1 Variadic: false Signature: DMIN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DProductFn

Multiplies values in a database field for records that satisfy criteria.

DPRODUCT filters the database first, then returns the product of numeric values in field.

Remarks

• Criteria rows are evaluated as OR alternatives; criteria columns in one row are AND constraints.
• field resolves via case-insensitive header text or 1-based column index; unresolved field references return #VALUE!.
• If no numeric values match, this implementation returns 0.

Examples

title: "Product of units in North or South"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "North"
  G3: "South"
formula: "=DPRODUCT(A1:E7, \"Units\", G1:G3)"
expected: 486

title: "Product of units for East or West by index field"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DPRODUCT(A1:E7, 4, G1:G3)"
expected: 196416

related:
  - DSUM
  - DCOUNT
  - PRODUCT
faq:
  - q: "What result does DPRODUCT return if no numeric records match?"
    a: "This implementation returns 0 when no numeric field values remain after criteria filtering."

[formualizer-docgen:schema:start] Name: DPRODUCT Type: DProductFn Min args: 3 Max args: 1 Variadic: false Signature: DPRODUCT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DStdevFn

Returns the sample standard deviation of a database field for matching records.

DSTDEV computes standard deviation with the sample denominator (n - 1) after criteria filtering.

Remarks

• Criteria rows represent OR branches; criteria columns in each row are combined with AND.
• field is resolved by case-insensitive header text or 1-based column index; invalid field resolution returns #VALUE!.
• At least two numeric values must match criteria, otherwise the result is #DIV/0!.

Examples

title: "Sample stdev of units for East or West"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DSTDEV(A1:E7, \"Units\", G1:G3)"
expected: 7.847504911329036

title: "Sample stdev of widget revenue"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
formula: "=DSTDEV(A1:E7, 5, G1:G2)"
expected: 19756.85535031659

related:
  - DSTDEVP
  - DVAR
  - STDEV.S
faq:
  - q: "Why does DSTDEV return #DIV/0! with one matching row?"
    a: "DSTDEV uses sample statistics and needs at least two numeric matches for an n-1 denominator."

[formualizer-docgen:schema:start] Name: DSTDEV Type: DStdevFn Min args: 3 Max args: 1 Variadic: false Signature: DSTDEV(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DStdevPFn

Returns the population standard deviation of a database field for matching records.

DSTDEVP computes standard deviation with the population denominator (n) after criteria filtering.

Remarks

• Criteria rows are OR branches, and each row’s populated criteria columns are ANDed.
• field can be a case-insensitive header label or 1-based index; invalid lookup returns #VALUE!.
• At least one numeric value must match criteria, otherwise the result is #DIV/0!.

Examples

title: "Population stdev of units for East or West"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DSTDEVP(A1:E7, \"Units\", G1:G3)"
expected: 6.796138609534093

title: "Population stdev of widget revenue"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
formula: "=DSTDEVP(A1:E7, 5, G1:G2)"
expected: 16131.404843417147

related:
  - DSTDEV
  - DVARP
  - STDEV.P
faq:
  - q: "When should I prefer DSTDEVP over DSTDEV?"
    a: "Use DSTDEVP when matching rows represent the full population; DSTDEV is for samples."

[formualizer-docgen:schema:start] Name: DSTDEVP Type: DStdevPFn Min args: 3 Max args: 1 Variadic: false Signature: DSTDEVP(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DSumFn

Sums values in a database field for records that match criteria.

DSUM filters database rows using a criteria range, then adds the selected field values.

Remarks

• Criteria rows are evaluated with OR semantics; populated criteria columns within one row are ANDed.
• field resolves by case-insensitive header text or 1-based column index; unknown headers and out-of-range indexes return #VALUE!.
• Non-numeric values in the target field are ignored unless they coerce to numbers.

Examples

title: "Sum revenue for East or West regions"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "West"
  G3: "East"
formula: "=DSUM(A1:E7, \"Revenue\", G1:G3)"
expected: 415500

title: "Sum revenue by field index with numeric criteria"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Units"
  G2: ">20"
formula: "=DSUM(A1:E7, 5, G1:G2)"
expected: 488500

related:
  - DAVERAGE
  - DCOUNT
  - SUMIFS
faq:
  - q: "How are multiple criteria rows interpreted in DSUM?"
    a: "Each criteria row is an OR branch, while multiple populated criteria columns in one row are combined with AND."

[formualizer-docgen:schema:start] Name: DSUM Type: DSumFn Min args: 3 Max args: 1 Variadic: false Signature: DSUM(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DVarFn

Returns the sample variance of a database field for records matching criteria.

DVAR filters records first, then computes variance using the sample denominator (n - 1).

Remarks

• Criteria rows are OR alternatives; criteria columns within each row are AND constraints.
• field can be resolved by case-insensitive header text or 1-based index; unresolved fields return #VALUE!.
• At least two numeric values must match criteria, otherwise the function returns #DIV/0!.

Examples

title: "Sample variance of units for East or West"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DVAR(A1:E7, \"Units\", G1:G3)"
expected: 61.583333333333336

title: "Sample variance of widget revenue"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
formula: "=DVAR(A1:E7, 5, G1:G2)"
expected: 390333333.3333333

related:
  - DVARP
  - DSTDEV
  - VAR.S
faq:
  - q: "Does DVAR use sample or population variance math?"
    a: "DVAR uses sample variance with an n-1 denominator and returns #DIV/0! when fewer than two numeric rows match."

[formualizer-docgen:schema:start] Name: DVAR Type: DVarFn Min args: 3 Max args: 1 Variadic: false Signature: DVAR(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DVarPFn

Returns the population variance of a database field for records matching criteria.

DVARP computes variance with the population denominator (n) over filtered records.

Remarks

• Criteria rows are OR branches; populated criteria cells in the same row are combined with AND.
• field accepts case-insensitive header text or 1-based index; bad field/header resolution returns #VALUE!.
• At least one numeric value must match criteria, otherwise the function returns #DIV/0!.

Examples

title: "Population variance of units for East or West"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Region"
  G2: "East"
  G3: "West"
formula: "=DVARP(A1:E7, \"Units\", G1:G3)"
expected: 46.1875

title: "Population variance of widget revenue"
grid:
  A1: "Region"
  B1: "Salesperson"
  C1: "Product"
  D1: "Units"
  E1: "Revenue"
  A2: "West"
  B2: "Diaz"
  C2: "Widget"
  D2: 24
  E2: 126000
  A3: "East"
  B3: "Patel"
  C3: "Gadget"
  D3: 31
  E3: 142500
  A4: "North"
  B4: "Kim"
  C4: "Widget"
  D4: 18
  E4: 87000
  A5: "West"
  B5: "Ramos"
  C5: "Service"
  D5: 12
  E5: 46000
  A6: "South"
  B6: "Lee"
  C6: "Gadget"
  D6: 27
  E6: 119000
  A7: "East"
  B7: "Noor"
  C7: "Widget"
  D7: 22
  E7: 101000
  G1: "Product"
  G2: "Widget"
formula: "=DVARP(A1:E7, 5, G1:G2)"
expected: 260222222.2222222

related:
  - DVAR
  - DSTDEVP
  - VAR.P
faq:
  - q: "Why can DVARP return a value with only one matched row?"
    a: "Population variance divides by n, so one numeric match yields a defined result instead of #DIV/0!."

[formualizer-docgen:schema:start] Name: DVARP Type: DVarPFn Min args: 3 Max args: 1 Variadic: false Signature: DVARP(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for DateFn

[formualizer-docgen:schema:start] Name: DATE Type: DateFn Min args: 3 Max args: 3 Variadic: false Signature: DATE(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DateValueFn

[formualizer-docgen:schema:start] Name: DATEVALUE Type: DateValueFn Min args: 1 Max args: 1 Variadic: false Signature: DATEVALUE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DatedifFn

[formualizer-docgen:schema:start] Name: DATEDIF Type: DatedifFn Min args: 3 Max args: 3 Variadic: false Signature: DATEDIF(arg1: number@scalar, arg2: number@scalar, arg3: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DayFn

[formualizer-docgen:schema:start] Name: DAY Type: DayFn Min args: 1 Max args: 1 Variadic: false Signature: DAY(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Days360Fn

[formualizer-docgen:schema:start] Name: DAYS360 Type: Days360Fn Min args: 2 Max args: variadic Variadic: true Signature: DAYS360(arg1: number@scalar, arg2: number@scalar, arg3…: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DaysFn

[formualizer-docgen:schema:start] Name: DAYS Type: DaysFn Min args: 2 Max args: 2 Variadic: false Signature: DAYS(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for EdateFn

[formualizer-docgen:schema:start] Name: EDATE Type: EdateFn Min args: 2 Max args: 2 Variadic: false Signature: EDATE(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for EomonthFn

[formualizer-docgen:schema:start] Name: EOMONTH Type: EomonthFn Min args: 2 Max args: 2 Variadic: false Signature: EOMONTH(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for HourFn

[formualizer-docgen:schema:start] Name: HOUR Type: HourFn Min args: 1 Max args: 1 Variadic: false Signature: HOUR(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsoWeekNumFn

[formualizer-docgen:schema:start] Name: ISOWEEKNUM Type: IsoWeekNumFn Min args: 1 Max args: 1 Variadic: false Signature: ISOWEEKNUM(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MinuteFn

[formualizer-docgen:schema:start] Name: MINUTE Type: MinuteFn Min args: 1 Max args: 1 Variadic: false Signature: MINUTE(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MonthFn

[formualizer-docgen:schema:start] Name: MONTH Type: MonthFn Min args: 1 Max args: 1 Variadic: false Signature: MONTH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NetworkdaysFn

[formualizer-docgen:schema:start] Name: NETWORKDAYS Type: NetworkdaysFn Min args: 2 Max args: variadic Variadic: true Signature: NETWORKDAYS(arg1: number@scalar, arg2: number@scalar, arg3…: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NowFn

[formualizer-docgen:schema:start] Name: NOW Type: NowFn Min args: 0 Max args: 0 Variadic: false Signature: NOW() Arg schema: [] Caps: VOLATILE [formualizer-docgen:schema:end]

impl Function for SecondFn

[formualizer-docgen:schema:start] Name: SECOND Type: SecondFn Min args: 1 Max args: 1 Variadic: false Signature: SECOND(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TimeFn

[formualizer-docgen:schema:start] Name: TIME Type: TimeFn Min args: 3 Max args: 3 Variadic: false Signature: TIME(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TimeValueFn

[formualizer-docgen:schema:start] Name: TIMEVALUE Type: TimeValueFn Min args: 1 Max args: 1 Variadic: false Signature: TIMEVALUE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TodayFn

[formualizer-docgen:schema:start] Name: TODAY Type: TodayFn Min args: 0 Max args: 0 Variadic: false Signature: TODAY() Arg schema: [] Caps: VOLATILE [formualizer-docgen:schema:end]

impl Function for WeekdayFn

[formualizer-docgen:schema:start] Name: WEEKDAY Type: WeekdayFn Min args: 1 Max args: variadic Variadic: true Signature: WEEKDAY(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for WeeknumFn

[formualizer-docgen:schema:start] Name: WEEKNUM Type: WeeknumFn Min args: 1 Max args: variadic Variadic: true Signature: WEEKNUM(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for WorkdayFn

[formualizer-docgen:schema:start] Name: WORKDAY Type: WorkdayFn Min args: 2 Max args: variadic Variadic: true Signature: WORKDAY(arg1: number@scalar, arg2: number@scalar, arg3…: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for YearFn

[formualizer-docgen:schema:start] Name: YEAR Type: YearFn Min args: 1 Max args: 1 Variadic: false Signature: YEAR(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for YearFracFn

[formualizer-docgen:schema:start] Name: YEARFRAC Type: YearFracFn Min args: 2 Max args: variadic Variadic: true Signature: YEARFRAC(arg1: number@scalar, arg2: number@scalar, arg3…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Bin2DecFn

[formualizer-docgen:schema:start] Name: BIN2DEC Type: Bin2DecFn Min args: 1 Max args: 1 Variadic: false Signature: BIN2DEC(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Bin2HexFn

[formualizer-docgen:schema:start] Name: BIN2HEX Type: Bin2HexFn Min args: 1 Max args: variadic Variadic: true Signature: BIN2HEX(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Bin2OctFn

[formualizer-docgen:schema:start] Name: BIN2OCT Type: Bin2OctFn Min args: 1 Max args: variadic Variadic: true Signature: BIN2OCT(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BitAndFn

[formualizer-docgen:schema:start] Name: BITAND Type: BitAndFn Min args: 2 Max args: 2 Variadic: false Signature: BITAND(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BitLShiftFn

[formualizer-docgen:schema:start] Name: BITLSHIFT Type: BitLShiftFn Min args: 2 Max args: 2 Variadic: false Signature: BITLSHIFT(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BitOrFn

[formualizer-docgen:schema:start] Name: BITOR Type: BitOrFn Min args: 2 Max args: 2 Variadic: false Signature: BITOR(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BitRShiftFn

[formualizer-docgen:schema:start] Name: BITRSHIFT Type: BitRShiftFn Min args: 2 Max args: 2 Variadic: false Signature: BITRSHIFT(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BitXorFn

[formualizer-docgen:schema:start] Name: BITXOR Type: BitXorFn Min args: 2 Max args: 2 Variadic: false Signature: BITXOR(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ComplexFn

[formualizer-docgen:schema:start] Name: COMPLEX Type: ComplexFn Min args: 2 Max args: variadic Variadic: true Signature: COMPLEX(arg1: any@scalar, arg2: any@scalar, arg3…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ConvertFn

[formualizer-docgen:schema:start] Name: CONVERT Type: ConvertFn Min args: 3 Max args: 3 Variadic: false Signature: CONVERT(arg1: any@scalar, arg2: any@scalar, arg3: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Dec2BinFn

[formualizer-docgen:schema:start] Name: DEC2BIN Type: Dec2BinFn Min args: 1 Max args: variadic Variadic: true Signature: DEC2BIN(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Dec2HexFn

[formualizer-docgen:schema:start] Name: DEC2HEX Type: Dec2HexFn Min args: 1 Max args: variadic Variadic: true Signature: DEC2HEX(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Dec2OctFn

[formualizer-docgen:schema:start] Name: DEC2OCT Type: Dec2OctFn Min args: 1 Max args: variadic Variadic: true Signature: DEC2OCT(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DeltaFn

[formualizer-docgen:schema:start] Name: DELTA Type: DeltaFn Min args: 1 Max args: variadic Variadic: true Signature: DELTA(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ErfFn

[formualizer-docgen:schema:start] Name: ERF Type: ErfFn Min args: 1 Max args: variadic Variadic: true Signature: ERF(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ErfPreciseFn

[formualizer-docgen:schema:start] Name: ERF.PRECISE Type: ErfPreciseFn Min args: 1 Max args: 1 Variadic: false Signature: ERF.PRECISE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ErfcFn

[formualizer-docgen:schema:start] Name: ERFC Type: ErfcFn Min args: 1 Max args: 1 Variadic: false Signature: ERFC(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for GestepFn

[formualizer-docgen:schema:start] Name: GESTEP Type: GestepFn Min args: 1 Max args: variadic Variadic: true Signature: GESTEP(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Hex2BinFn

[formualizer-docgen:schema:start] Name: HEX2BIN Type: Hex2BinFn Min args: 1 Max args: variadic Variadic: true Signature: HEX2BIN(arg1: any@scalar, arg2…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Hex2DecFn

[formualizer-docgen:schema:start] Name: HEX2DEC Type: Hex2DecFn Min args: 1 Max args: 1 Variadic: false Signature: HEX2DEC(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Hex2OctFn

[formualizer-docgen:schema:start] Name: HEX2OCT Type: Hex2OctFn Min args: 1 Max args: variadic Variadic: true Signature: HEX2OCT(arg1: any@scalar, arg2…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImAbsFn

[formualizer-docgen:schema:start] Name: IMABS Type: ImAbsFn Min args: 1 Max args: 1 Variadic: false Signature: IMABS(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImArgumentFn

[formualizer-docgen:schema:start] Name: IMARGUMENT Type: ImArgumentFn Min args: 1 Max args: 1 Variadic: false Signature: IMARGUMENT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImConjugateFn

[formualizer-docgen:schema:start] Name: IMCONJUGATE Type: ImConjugateFn Min args: 1 Max args: 1 Variadic: false Signature: IMCONJUGATE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImCosFn

[formualizer-docgen:schema:start] Name: IMCOS Type: ImCosFn Min args: 1 Max args: 1 Variadic: false Signature: IMCOS(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImDivFn

[formualizer-docgen:schema:start] Name: IMDIV Type: ImDivFn Min args: 2 Max args: 2 Variadic: false Signature: IMDIV(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImExpFn

[formualizer-docgen:schema:start] Name: IMEXP Type: ImExpFn Min args: 1 Max args: 1 Variadic: false Signature: IMEXP(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImLnFn

[formualizer-docgen:schema:start] Name: IMLN Type: ImLnFn Min args: 1 Max args: 1 Variadic: false Signature: IMLN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImLog2Fn

[formualizer-docgen:schema:start] Name: IMLOG2 Type: ImLog2Fn Min args: 1 Max args: 1 Variadic: false Signature: IMLOG2(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImLog10Fn

[formualizer-docgen:schema:start] Name: IMLOG10 Type: ImLog10Fn Min args: 1 Max args: 1 Variadic: false Signature: IMLOG10(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImPowerFn

[formualizer-docgen:schema:start] Name: IMPOWER Type: ImPowerFn Min args: 2 Max args: 2 Variadic: false Signature: IMPOWER(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImProductFn

[formualizer-docgen:schema:start] Name: IMPRODUCT Type: ImProductFn Min args: 1 Max args: variadic Variadic: true Signature: IMPRODUCT(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImRealFn

[formualizer-docgen:schema:start] Name: IMREAL Type: ImRealFn Min args: 1 Max args: 1 Variadic: false Signature: IMREAL(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImSinFn

[formualizer-docgen:schema:start] Name: IMSIN Type: ImSinFn Min args: 1 Max args: 1 Variadic: false Signature: IMSIN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImSqrtFn

[formualizer-docgen:schema:start] Name: IMSQRT Type: ImSqrtFn Min args: 1 Max args: 1 Variadic: false Signature: IMSQRT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImSubFn

[formualizer-docgen:schema:start] Name: IMSUB Type: ImSubFn Min args: 2 Max args: 2 Variadic: false Signature: IMSUB(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImSumFn

[formualizer-docgen:schema:start] Name: IMSUM Type: ImSumFn Min args: 1 Max args: variadic Variadic: true Signature: IMSUM(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ImaginaryFn

[formualizer-docgen:schema:start] Name: IMAGINARY Type: ImaginaryFn Min args: 1 Max args: 1 Variadic: false Signature: IMAGINARY(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Oct2BinFn

[formualizer-docgen:schema:start] Name: OCT2BIN Type: Oct2BinFn Min args: 1 Max args: variadic Variadic: true Signature: OCT2BIN(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Oct2DecFn

[formualizer-docgen:schema:start] Name: OCT2DEC Type: Oct2DecFn Min args: 1 Max args: 1 Variadic: false Signature: OCT2DEC(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Oct2HexFn

[formualizer-docgen:schema:start] Name: OCT2HEX Type: Oct2HexFn Min args: 1 Max args: variadic Variadic: true Signature: OCT2HEX(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for AccrintFn

[formualizer-docgen:schema:start] Name: ACCRINT Type: AccrintFn Min args: 6 Max args: variadic Variadic: true Signature: ACCRINT(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6: number@scalar, arg7: number@scalar, arg8…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg7{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg8{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for AccrintmFn

[formualizer-docgen:schema:start] Name: ACCRINTM Type: AccrintmFn Min args: 4 Max args: variadic Variadic: true Signature: ACCRINTM(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CumipmtFn

[formualizer-docgen:schema:start] Name: CUMIPMT Type: CumipmtFn Min args: 6 Max args: 6 Variadic: false Signature: CUMIPMT(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CumprincFn

[formualizer-docgen:schema:start] Name: CUMPRINC Type: CumprincFn Min args: 6 Max args: 6 Variadic: false Signature: CUMPRINC(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DbFn

[formualizer-docgen:schema:start] Name: DB Type: DbFn Min args: 4 Max args: variadic Variadic: true Signature: DB(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DdbFn

[formualizer-docgen:schema:start] Name: DDB Type: DdbFn Min args: 4 Max args: variadic Variadic: true Signature: DDB(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DollardeFn

[formualizer-docgen:schema:start] Name: DOLLARDE Type: DollardeFn Min args: 2 Max args: 2 Variadic: false Signature: DOLLARDE(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DollarfrFn

[formualizer-docgen:schema:start] Name: DOLLARFR Type: DollarfrFn Min args: 2 Max args: 2 Variadic: false Signature: DOLLARFR(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for EffectFn

[formualizer-docgen:schema:start] Name: EFFECT Type: EffectFn Min args: 2 Max args: 2 Variadic: false Signature: EFFECT(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FvFn

[formualizer-docgen:schema:start] Name: FV Type: FvFn Min args: 3 Max args: variadic Variadic: true Signature: FV(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IpmtFn

[formualizer-docgen:schema:start] Name: IPMT Type: IpmtFn Min args: 4 Max args: variadic Variadic: true Signature: IPMT(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IrrFn

[formualizer-docgen:schema:start] Name: IRR Type: IrrFn Min args: 1 Max args: variadic Variadic: true Signature: IRR(arg1: any@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MirrFn

[formualizer-docgen:schema:start] Name: MIRR Type: MirrFn Min args: 3 Max args: 3 Variadic: false Signature: MIRR(arg1: any@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NominalFn

[formualizer-docgen:schema:start] Name: NOMINAL Type: NominalFn Min args: 2 Max args: 2 Variadic: false Signature: NOMINAL(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NperFn

[formualizer-docgen:schema:start] Name: NPER Type: NperFn Min args: 3 Max args: variadic Variadic: true Signature: NPER(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NpvFn

[formualizer-docgen:schema:start] Name: NPV Type: NpvFn Min args: 2 Max args: variadic Variadic: true Signature: NPV(arg1: number@scalar, arg2…: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PmtFn

[formualizer-docgen:schema:start] Name: PMT Type: PmtFn Min args: 3 Max args: variadic Variadic: true Signature: PMT(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PpmtFn

[formualizer-docgen:schema:start] Name: PPMT Type: PpmtFn Min args: 4 Max args: variadic Variadic: true Signature: PPMT(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PriceFn

[formualizer-docgen:schema:start] Name: PRICE Type: PriceFn Min args: 6 Max args: variadic Variadic: true Signature: PRICE(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6: number@scalar, arg7…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg7{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PvFn

[formualizer-docgen:schema:start] Name: PV Type: PvFn Min args: 3 Max args: variadic Variadic: true Signature: PV(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RateFn

[formualizer-docgen:schema:start] Name: RATE Type: RateFn Min args: 3 Max args: variadic Variadic: true Signature: RATE(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SlnFn

[formualizer-docgen:schema:start] Name: SLN Type: SlnFn Min args: 3 Max args: 3 Variadic: false Signature: SLN(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SydFn

[formualizer-docgen:schema:start] Name: SYD Type: SydFn Min args: 4 Max args: 4 Variadic: false Signature: SYD(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for XirrFn

[formualizer-docgen:schema:start] Name: XIRR Type: XirrFn Min args: 2 Max args: variadic Variadic: true Signature: XIRR(arg1: any@scalar, arg2: any@scalar, arg3…: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for XnpvFn

[formualizer-docgen:schema:start] Name: XNPV Type: XnpvFn Min args: 3 Max args: 3 Variadic: false Signature: XNPV(arg1: number@scalar, arg2: any@scalar, arg3: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for YieldFn

[formualizer-docgen:schema:start] Name: YIELD Type: YieldFn Min args: 6 Max args: variadic Variadic: true Signature: YIELD(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6: number@scalar, arg7…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg7{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ErrorTypeFn

Returns the numeric code for a specific error value.

Remarks

• Standard mappings include: #NULL!=1, #DIV/0!=2, #VALUE!=3, #REF!=4, #NAME?=5, #NUM!=6, #N/A=7.
• Non-error inputs return #N/A.
• Additional internal error kinds may map to extended non-standard codes.

Examples

title: "Map DIV/0 to code"
formula: '=ERROR.TYPE(1/0)'
expected: 2

title: "Non-error input returns N/A"
formula: '=ERROR.TYPE(10)'
expected: "#N/A"

related:
  - ISERROR
  - ISNA
  - IFERROR
faq:
  - q: "What if the input is not an error value?"
    a: "ERROR.TYPE returns #N/A when the input is not an error."

[formualizer-docgen:schema:start] Name: ERROR.TYPE Type: ErrorTypeFn Min args: 1 Max args: 1 Variadic: false Signature: ERROR.TYPE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsBlankFn

Returns TRUE only for a truly empty value.

Remarks

• Empty string "" is text, not blank, so it returns FALSE.
• Numeric zero and FALSE are not blank.
• Errors return FALSE.

Examples

title: "Reference to an empty cell"
formula: '=ISBLANK(A1)'
expected: true

title: "Empty string is not blank"
formula: '=ISBLANK("")'
expected: false

related:
  - ISTEXT
  - LEN
  - T
faq:
  - q: "Why does ISBLANK(\"\") return FALSE?"
    a: "Because an empty string is text, not a truly empty cell value."

[formualizer-docgen:schema:start] Name: ISBLANK Type: IsBlankFn Min args: 1 Max args: 1 Variadic: false Signature: ISBLANK(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsErrFn

Returns TRUE for any error except #N/A.

Remarks

• #N/A specifically returns FALSE.
• Other errors such as #DIV/0! or #VALUE! return TRUE.
• Non-error values return FALSE.

Examples

title: "DIV/0 is an error excluding N/A"
formula: '=ISERR(1/0)'
expected: true

title: "N/A is excluded"
formula: '=ISERR(NA())'
expected: false

related:
  - ISERROR
  - ISNA
  - IFERROR
faq:
  - q: "What is the difference between ISERR and ISERROR?"
    a: "ISERR excludes #N/A, while ISERROR treats #N/A as an error too."

[formualizer-docgen:schema:start] Name: ISERR Type: IsErrFn Min args: 1 Max args: 1 Variadic: false Signature: ISERR(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsErrorFn

Returns TRUE for any error value.

Remarks

• Matches all error kinds, including #N/A.
• Non-error values always return FALSE.
• Arity mismatch returns #VALUE!.

Examples

title: "Division error"
formula: '=ISERROR(1/0)'
expected: true

title: "Normal value"
formula: '=ISERROR(123)'
expected: false

related:
  - ISERR
  - ISNA
  - IFERROR
faq:
  - q: "Does ISERROR include #N/A?"
    a: "Yes. ISERROR returns TRUE for all error kinds, including #N/A."

[formualizer-docgen:schema:start] Name: ISERROR Type: IsErrorFn Min args: 1 Max args: 1 Variadic: false Signature: ISERROR(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsEvenFn

Returns TRUE when a number is even.

Remarks

• Numeric input is truncated toward zero before parity is checked.
• Booleans are coerced (TRUE -> 1, FALSE -> 0).
• Non-numeric text returns #VALUE!.
• Errors propagate unchanged.

Examples

title: "Even integer"
formula: '=ISEVEN(6)'
expected: true

title: "Decimal truncation before parity"
formula: '=ISEVEN(3.9)'
expected: false

related:
  - ISODD
  - ISNUMBER
  - N
faq:
  - q: "How are decimals handled by ISEVEN?"
    a: "The number is truncated toward zero before checking even/odd parity."

[formualizer-docgen:schema:start] Name: ISEVEN Type: IsEvenFn Min args: 1 Max args: 1 Variadic: false Signature: ISEVEN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsFormulaFn

Returns whether a value originates from a formula.

Current engine metadata does not track formula provenance at this call site.

Remarks

• This implementation currently returns FALSE for all inputs.
• Errors are not raised solely due to provenance unavailability.
• Arity mismatch returns #VALUE!.

Examples

title: "Literal value"
formula: '=ISFORMULA(10)'
expected: false

title: "Computed value in expression context"
formula: '=ISFORMULA(1+1)'
expected: false

related:
  - TYPE
  - ISNUMBER
  - ISTEXT
faq:
  - q: "Can ISFORMULA currently detect formula provenance?"
    a: "Not yet. This implementation always returns FALSE because provenance metadata is not tracked here."

[formualizer-docgen:schema:start] Name: ISFORMULA Type: IsFormulaFn Min args: 1 Max args: 1 Variadic: false Signature: ISFORMULA(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsLogicalFn

Returns TRUE when the value is a boolean.

Remarks

• Only logical TRUE/FALSE values return TRUE.
• Numeric truthy/falsy values are not considered logical by this predicate.
• Errors return FALSE.

Examples

title: "Boolean input"
formula: '=ISLOGICAL(TRUE)'
expected: true

title: "Numeric input"
formula: '=ISLOGICAL(1)'
expected: false

related:
  - TRUE
  - FALSE
  - TYPE
faq:
  - q: "Do truthy numbers count as logical values?"
    a: "No. ISLOGICAL returns TRUE only for actual boolean TRUE/FALSE values."

[formualizer-docgen:schema:start] Name: ISLOGICAL Type: IsLogicalFn Min args: 1 Max args: 1 Variadic: false Signature: ISLOGICAL(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsNaFn

Returns TRUE only for the #N/A error.

Remarks

• Other error kinds return FALSE.
• Non-error values return FALSE.
• Useful when #N/A has special business meaning.

Examples

title: "Check for N/A"
formula: '=ISNA(NA())'
expected: true

title: "Other errors are not N/A"
formula: '=ISNA(1/0)'
expected: false

related:
  - NA
  - IFNA
  - ISERROR
faq:
  - q: "Does ISNA return TRUE for errors other than #N/A?"
    a: "No. It returns TRUE only when the value is exactly #N/A."

[formualizer-docgen:schema:start] Name: ISNA Type: IsNaFn Min args: 1 Max args: 1 Variadic: false Signature: ISNA(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsNumberFn

Returns TRUE when the value is numeric.

This includes integer, floating-point, and temporal serial-compatible values.

Remarks

• Returns TRUE for Int, Number, Date, DateTime, Time, and Duration.
• Text that looks numeric is still text and returns FALSE.
• Errors are treated as non-numeric and return FALSE.

Examples

title: "Number is numeric"
formula: '=ISNUMBER(42)'
expected: true

title: "Numeric text is not numeric"
formula: '=ISNUMBER("42")'
expected: false

related:
  - VALUE
  - N
  - TYPE
faq:
  - q: "Does numeric-looking text count as a number?"
    a: "No. ISNUMBER checks the stored value type, so text like \"42\" returns FALSE."

[formualizer-docgen:schema:start] Name: ISNUMBER Type: IsNumberFn Min args: 1 Max args: 1 Variadic: false Signature: ISNUMBER(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsOddFn

Returns TRUE when a number is odd.

Remarks

• Numeric input is truncated toward zero before parity is checked.
• Booleans are coerced (TRUE -> 1, FALSE -> 0).
• Non-numeric text returns #VALUE!.
• Errors propagate unchanged.

Examples

title: "Odd integer"
formula: '=ISODD(7)'
expected: true

title: "Boolean coercion"
formula: '=ISODD(TRUE)'
expected: true

related:
  - ISEVEN
  - ISNUMBER
  - N
faq:
  - q: "Are booleans valid inputs for ISODD?"
    a: "Yes. TRUE is treated as 1 and FALSE as 0 before the odd check."

[formualizer-docgen:schema:start] Name: ISODD Type: IsOddFn Min args: 1 Max args: 1 Variadic: false Signature: ISODD(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IsTextFn

Returns TRUE when the value is text.

Remarks

• Only text literals return TRUE.
• Numbers, booleans, blanks, and errors return FALSE.
• No coercion from other types to text is performed for this check.

Examples

title: "Detect text"
formula: '=ISTEXT("alpha")'
expected: true

title: "Number is not text"
formula: '=ISTEXT(100)'
expected: false

related:
  - T
  - TYPE
  - ISNUMBER
faq:
  - q: "Is an empty string treated as text?"
    a: "Yes. An empty string literal is still text, so ISTEXT(\"\") returns TRUE."

[formualizer-docgen:schema:start] Name: ISTEXT Type: IsTextFn Min args: 1 Max args: 1 Variadic: false Signature: ISTEXT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NFn

Converts a value to its numeric representation.

Remarks

• Numbers pass through unchanged; booleans convert to 1/0.
• Text and blank values convert to 0.
• Errors propagate unchanged.
• Temporal values are converted using serial number representation.

Examples

title: "Boolean to number"
formula: '=N(TRUE)'
expected: 1

title: "Text to zero"
formula: '=N("hello")'
expected: 0

related:
  - VALUE
  - T
  - TYPE
faq:
  - q: "What does N do with text and blanks?"
    a: "Text and blank values convert to 0, while existing errors are passed through."

[formualizer-docgen:schema:start] Name: N Type: NFn Min args: 1 Max args: 1 Variadic: false Signature: N(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NaFn

Returns the #N/A error value.

Remarks

• NA() is commonly used to mark missing lookup results.
• The function takes no arguments.
• The returned value is an error and propagates through dependent formulas.

Examples

title: "Direct N/A"
formula: '=NA()'
expected: "#N/A"

title: "Detect N/A"
formula: '=ISNA(NA())'
expected: true

related:
  - ISNA
  - IFNA
  - IFERROR
faq:
  - q: "When should I use NA() intentionally?"
    a: "Use it to mark missing data so lookups and downstream checks can distinguish absent values from blanks."

[formualizer-docgen:schema:start] Name: NA Type: NaFn Min args: 0 Max args: 0 Variadic: false Signature: NA() Arg schema: [] Caps: PURE [formualizer-docgen:schema:end]

impl Function for TFn

Returns text when input is text, otherwise returns empty text.

Remarks

• Text values pass through unchanged.
• Errors propagate unchanged.
• Numbers, booleans, and blanks return an empty string.

Examples

title: "Text passthrough"
formula: '=T("report")'
expected: "report"

title: "Number becomes empty text"
formula: '=T(99)'
expected: ""

related:
  - N
  - ISTEXT
  - TYPE
faq:
  - q: "Does T hide non-text values?"
    a: "Yes. Non-text inputs become an empty string, but errors are still propagated."

[formualizer-docgen:schema:start] Name: T Type: TFn Min args: 1 Max args: 1 Variadic: false Signature: T(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TypeFn

Returns an Excel TYPE code describing the value category.

Remarks

• Codes: 1 number, 2 text, 4 logical, 64 array.
• Errors are propagated unchanged instead of returning 16.
• Blank values map to numeric code 1 in this implementation.

Examples

title: "Text type code"
formula: '=TYPE("abc")'
expected: 2

title: "Boolean type code"
formula: '=TYPE(TRUE)'
expected: 4

related:
  - ISNUMBER
  - ISTEXT
  - ISLOGICAL
faq:
  - q: "How are errors handled by TYPE?"
    a: "Errors are propagated unchanged instead of returning Excel's error type code 16."

[formualizer-docgen:schema:start] Name: TYPE Type: TypeFn Min args: 1 Max args: 1 Variadic: false Signature: TYPE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LambdaFn

Creates an anonymous callable that can be invoked with spreadsheet arguments.

LAMBDA captures its defining local scope and returns a reusable function value.

Remarks

• All arguments except the last are parameter names; the last argument is the body expression.
• Parameter names must be unique (case-insensitive), or #VALUE! is returned.
• Invocation arity must exactly match the declared parameter count.
• Returning an uninvoked lambda as a final cell value yields a #CALC! in evaluation.

Examples

title: "Inline lambda invocation"
formula: "=LAMBDA(x,x+1)(41)"
expected: 42

title: "Lambda captures outer LET bindings"
formula: "=LET(k,10,addk,LAMBDA(n,n+k),addk(5))"
expected: 15

title: "Duplicate parameter names are invalid"
formula: "=LAMBDA(x,x,x+1)"
expected: "#VALUE!"

related:
  - LET
  - IF
  - SUM
faq:
  - q: "Why does =LAMBDA(x,x+1) return #CALC! instead of a number?"
    a: "LAMBDA returns a callable value. In a cell result position, it must be invoked, for example =LAMBDA(x,x+1)(1)."
  - q: "Does a LAMBDA read outer LET variables at call time or definition time?"
    a: "Definition time. The closure captures its lexical environment when created."
  - q: "Can I call a LAMBDA with fewer or extra arguments?"
    a: "No. Invocation arity must match the declared parameter count exactly, or #VALUE! is returned."

[formualizer-docgen:schema:start] Name: LAMBDA Type: LambdaFn Min args: 1 Max args: variadic Variadic: true Signature: LAMBDA() Arg schema: <unavailable: arg_schema panicked> Caps: PURE, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for LetFn

Binds local names to values and evaluates a final expression with those bindings.

LET introduces lexical variables using name/value pairs, then returns the last expression.

Remarks

• Arguments must be provided as name, value pairs followed by one final calculation expression.
• Names are resolved as local identifiers and can shadow workbook-level names.
• Bindings are evaluated left-to-right, so later values can reference earlier bindings.
• Invalid names or malformed arity return #VALUE!.

Examples

title: "Bind intermediate values"
formula: "=LET(rate,0.08,price,125,price*(1+rate))"
expected: 135

title: "Use LET with range calculations"
grid:
  A1: 10
  A2: 4
formula: "=LET(total,SUM(A1:A2),total*2)"
expected: 28

title: "Nested LET supports shadowing"
formula: "=LET(x,2,LET(x,5,x)+x)"
expected: 7

related:
  - LAMBDA
  - IF
  - SUM
  - INDEX
faq:
  - q: "Can a LET binding reference a name defined later in the same LET?"
    a: "No. LET evaluates name/value pairs left-to-right, so each binding can only use earlier bindings."
  - q: "Does LET overwrite workbook or worksheet names permanently?"
    a: "No. LET names are lexical and local to that formula evaluation; they only shadow outer names inside the LET expression."
  - q: "Is LET itself volatile?"
    a: "No. LET is deterministic unless one of its bound expressions calls a volatile function such as RAND."

[formualizer-docgen:schema:start] Name: LET Type: LetFn Min args: 3 Max args: variadic Variadic: true Signature: LET() Arg schema: <unavailable: arg_schema panicked> Caps: PURE, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for AndFn

Returns TRUE only when all supplied values evaluate to TRUE.

AND evaluates arguments left to right and short-circuits on a decisive FALSE.

Remarks

• Booleans and numbers are accepted (0 is FALSE, non-zero is TRUE).
• Blank values are treated as FALSE.
• Text and other non-coercible values yield #VALUE! unless a prior FALSE short-circuits.
• If no decisive FALSE is found, the first encountered error is returned.

Examples

title: "All truthy inputs"
formula: '=AND(TRUE, 1, 5)'
expected: true

title: "Text input causes VALUE error"
formula: '=AND(TRUE, "x")'
expected: "#VALUE!"

related:
  - OR
  - NOT
  - XOR
faq:
  - q: "What happens with blanks and text in AND?"
    a: "Blank values evaluate as FALSE; non-coercible text yields #VALUE! unless a prior FALSE short-circuits."

[formualizer-docgen:schema:start] Name: AND Type: AndFn Min args: 1 Max args: variadic Variadic: true Signature: AND(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, BOOL_ONLY, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for FalseFn

Returns the logical constant FALSE.

Use FALSE() when you want an explicit boolean false value in formulas.

Remarks

• FALSE takes no arguments and always returns the boolean value FALSE.
• No coercion or evaluation side effects are involved.

Examples

title: "Return FALSE directly"
formula: '=FALSE()'
expected: false

title: "Use FALSE in branching"
formula: '=IF(FALSE(), "yes", "no")'
expected: "no"

related:
  - TRUE
  - IF
  - OR
faq:
  - q: "Can FALSE accept arguments?"
    a: "No. FALSE takes zero arguments and always returns the boolean constant FALSE."

[formualizer-docgen:schema:start] Name: FALSE Type: FalseFn Min args: 0 Max args: 0 Variadic: false Signature: FALSE() Arg schema: [] Caps: PURE [formualizer-docgen:schema:end]

impl Function for IfFn

Returns one value when a condition is TRUE and another when FALSE.

IF(condition, value_if_true, [value_if_false]) supports two or three arguments.

Remarks

• Condition coercion: booleans are used directly, numbers use 0 as FALSE and non-zero as TRUE.
• A blank condition is treated as FALSE.
• Text or other non-numeric/non-boolean conditions return #VALUE!.
• With only two arguments, the FALSE branch defaults to logical FALSE.

Examples

title: "Numeric condition"
formula: '=IF(2, "yes", "no")'
expected: "yes"

title: "Two-argument IF defaults false branch"
formula: '=IF(0, 10)'
expected: false

related:
  - IFS
  - IFERROR
  - IFNA
faq:
  - q: "What is returned when IF has only two arguments and condition is FALSE?"
    a: "The false branch defaults to logical FALSE when value_if_false is omitted."

[formualizer-docgen:schema:start] Name: IF Type: IfFn Min args: 2 Max args: variadic Variadic: true Signature: IF(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for OrFn

Returns TRUE when any supplied value evaluates to TRUE.

OR evaluates arguments left to right and short-circuits on a decisive TRUE.

Remarks

• Booleans and numbers are accepted (0 is FALSE, non-zero is TRUE).
• Blank values are ignored.
• Text and other non-coercible values yield #VALUE! if no prior TRUE short-circuits.
• If no TRUE is found, the first encountered error is returned.

Examples

title: "One truthy value makes OR true"
formula: '=OR(FALSE, 0, 2)'
expected: true

title: "No true values and text input"
formula: '=OR(FALSE, "x")'
expected: "#VALUE!"

related:
  - AND
  - NOT
  - XOR
faq:
  - q: "How does OR treat blanks and text?"
    a: "Blanks are ignored; non-coercible text returns #VALUE! unless a prior TRUE already short-circuits."

[formualizer-docgen:schema:start] Name: OR Type: OrFn Min args: 1 Max args: variadic Variadic: true Signature: OR(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, BOOL_ONLY, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for TrueFn

Returns the logical constant TRUE.

Use TRUE() when you want an explicit boolean value in formulas.

Remarks

• TRUE takes no arguments and always returns the boolean value TRUE.
• No coercion or evaluation side effects are involved.

Examples

title: "Return TRUE directly"
formula: '=TRUE()'
expected: true

title: "Use TRUE in branching"
formula: '=IF(TRUE(), "yes", "no")'
expected: "yes"

related:
  - FALSE
  - IF
  - AND
faq:
  - q: "Can TRUE accept arguments?"
    a: "No. TRUE takes zero arguments and always returns the boolean constant TRUE."

[formualizer-docgen:schema:start] Name: TRUE Type: TrueFn Min args: 0 Max args: 0 Variadic: false Signature: TRUE() Arg schema: [] Caps: PURE [formualizer-docgen:schema:end]

impl Function for IfErrorFn

Returns a fallback when the first expression evaluates to any error.

IFERROR(value, value_if_error) is useful for user-friendly error handling.

Remarks

• Any error kind in the first argument triggers the fallback branch.
• Non-error results pass through unchanged.
• Evaluation failures surfaced as interpreter errors are also caught.
• Exactly two arguments are required; other arities return #VALUE!.

Examples

title: "Replace division error"
formula: '=IFERROR(1/0, "n/a")'
expected: "n/a"

title: "Pass through non-error"
formula: '=IFERROR(42, 0)'
expected: 42

related:
  - IFNA
  - IF
  - ISERROR
faq:
  - q: "Does IFERROR catch all error types?"
    a: "Yes. Any error kind in the first argument triggers the fallback value."

[formualizer-docgen:schema:start] Name: IFERROR Type: IfErrorFn Min args: 2 Max args: 2 Variadic: false Signature: IFERROR(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IfNaFn

Returns a fallback only when the first expression is #N/A.

IFNA(value, value_if_na) is narrower than IFERROR.

Remarks

• Only #N/A triggers fallback.
• Other error kinds are returned unchanged.
• Non-error results pass through unchanged.
• Exactly two arguments are required; other arities return #VALUE!.

Examples

title: "Catch N/A"
formula: '=IFNA(NA(), "missing")'
expected: "missing"

title: "Do not catch other errors"
formula: '=IFNA(1/0, "missing")'
expected: "#DIV/0!"

related:
  - IFERROR
  - ISNA
  - NA
faq:
  - q: "Which errors does IFNA intercept?"
    a: "Only #N/A is intercepted; all other errors pass through unchanged."

[formualizer-docgen:schema:start] Name: IFNA Type: IfNaFn Min args: 2 Max args: 2 Variadic: false Signature: IFNA(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IfsFn

Returns the value for the first TRUE condition in condition-value pairs.

IFS(cond1, value1, cond2, value2, ...) evaluates left to right and short-circuits.

Remarks

• Arguments must be provided as pairs; odd argument counts return #VALUE!.
• Conditions accept booleans and numbers (0 FALSE, non-zero TRUE); blank is FALSE.
• Text conditions return #VALUE!; error conditions propagate.
• If no condition is TRUE, returns #N/A.

Examples

title: "First matching condition wins"
formula: '=IFS(2<1, "a", 3>2, "b", TRUE, "c")'
expected: "b"

title: "No conditions matched"
formula: '=IFS(FALSE, 1, 0, 2)'
expected: "#N/A"

related:
  - IF
  - AND
  - OR
faq:
  - q: "What errors can IFS return on structure issues?"
    a: "Odd argument counts return #VALUE!, and no TRUE condition returns #N/A."

[formualizer-docgen:schema:start] Name: IFS Type: IfsFn Min args: 2 Max args: variadic Variadic: true Signature: IFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, SHORT_CIRCUIT [formualizer-docgen:schema:end]

impl Function for NotFn

Reverses the logical value of its argument.

NOT converts the input to a logical value, then flips it.

Remarks

• Numbers are coerced (0 -> TRUE after inversion, non-zero -> FALSE after inversion).
• Blank values are treated as FALSE, so NOT(blank) returns TRUE.
• Text and other non-coercible values return #VALUE!.
• Errors are propagated unchanged.

Examples

title: "Invert boolean"
formula: '=NOT(TRUE)'
expected: false

title: "Invert numeric truthiness"
formula: '=NOT(0)'
expected: true

related:
  - AND
  - OR
  - XOR
faq:
  - q: "How does NOT treat blanks?"
    a: "Blank is treated as FALSE first, so NOT(blank) returns TRUE."

[formualizer-docgen:schema:start] Name: NOT Type: NotFn Min args: 1 Max args: 1 Variadic: false Signature: NOT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for XorFn

Returns TRUE when an odd number of arguments evaluate to TRUE.

XOR aggregates all values and checks parity of truthy inputs.

Remarks

• Booleans and numbers are accepted (0 is FALSE, non-zero is TRUE).
• Blank values are ignored.
• Text and other non-coercible values produce #VALUE!.
• If no coercion error occurs first, encountered formula errors are propagated.

Examples

title: "Odd count of TRUE values"
formula: '=XOR(TRUE, FALSE, TRUE, TRUE)'
expected: true

title: "Text input triggers VALUE error"
formula: '=XOR(1, "x")'
expected: "#VALUE!"

related:
  - AND
  - OR
  - NOT
faq:
  - q: "What determines XOR's final result?"
    a: "XOR returns TRUE when the count of truthy inputs is odd; blanks are ignored."

[formualizer-docgen:schema:start] Name: XOR Type: XorFn Min args: 1 Max args: variadic Variadic: true Signature: XOR(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, BOOL_ONLY [formualizer-docgen:schema:end]

impl Function for AddressFn

Returns a cell reference as text from row and column numbers.

ADDRESS can emit either A1 or R1C1 notation and optionally prefix the address with a sheet name.

Remarks

• abs_num defaults to 1 ($A$1) and supports values 1..4.
• a1 defaults to TRUE; FALSE returns R1C1-style text.
• Valid row range is 1..1048576; valid column range is 1..16384.
• Out-of-range row/column values or invalid abs_num return #VALUE!.
• If sheet_text contains spaces or special characters, it is quoted.

Examples

title: "Absolute A1 reference"
formula: '=ADDRESS(2,3)'
expected: "$C$2"

title: "Relative R1C1 reference with sheet"
formula: '=ADDRESS(5,3,4,FALSE,"Data Sheet")'
expected: "'Data Sheet'!R[5]C[3]"

related:
  - INDEX
  - OFFSET
  - INDIRECT
faq:
  - q: "What happens when abs_num is outside 1..4?"
    a: "ADDRESS returns #VALUE!; only 1 (absolute), 2 (absolute row), 3 (absolute column), and 4 (relative) are valid."
  - q: "Why does sheet_text sometimes add single quotes?"
    a: "Sheet names containing spaces or special characters are quoted and internal apostrophes are escaped to keep a valid reference string."

[formualizer-docgen:schema:start] Name: ADDRESS Type: AddressFn Min args: 2 Max args: 5 Variadic: false Signature: ADDRESS(arg1: number@scalar, arg2: number@scalar, arg3?: number@scalar, arg4?: logical@scalar, arg5?: text@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=true}; arg4{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true}; arg5{kinds=text,required=false,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ChooseColsFn

Returns selected columns from an array or range.

CHOOSECOLS builds a new spilled array containing only the requested columns, in the order provided.

Remarks

• Column indexes are 1-based; negative indexes count from the end (-1 is last column).
• Repeated indexes are allowed and duplicate columns in the output.
• Index 0 or out-of-bounds indexes return #VALUE!.
• The result spills as an array unless it collapses to a single cell.

Examples

title: "Select first and third columns"
grid:
  A1: "Name"
  B1: "Dept"
  C1: "Score"
  A2: "Ana"
  B2: "Ops"
  C2: 91
formula: '=CHOOSECOLS(A1:C2,1,3)'
expected: [["Name","Score"],["Ana",91]]

title: "Select the last column with a negative index"
grid:
  A1: 10
  B1: 20
  C1: 30
formula: '=CHOOSECOLS(A1:C1,-1)'
expected: 30

related:
  - CHOOSEROWS
  - TAKE
  - DROP
faq:
  - q: "How do negative column indexes work?"
    a: "Negative indexes count from the right edge of the array, so -1 selects the last column, -2 the second-to-last, and so on."
  - q: "What triggers #VALUE! in CHOOSECOLS?"
    a: "Index 0 and any index whose absolute position falls outside the source width return #VALUE!."

[formualizer-docgen:schema:start] Name: CHOOSECOLS Type: ChooseColsFn Min args: 2 Max args: variadic Variadic: true Signature: CHOOSECOLS(arg1: range|any@range, arg2…: number@scalar) Arg schema: arg1{kinds=range|any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=Some(1),default=false} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for ChooseFn

Returns one value from a list using a 1-based index.

CHOOSE selects from value1, value2, ... based on index_num.

Remarks

• index_num is 1-based and is truncated to an integer.
• Indexes less than 1 or greater than the number of choices return #VALUE!.
• Errors in index_num are propagated.
• The selected argument is returned as-is, including non-text/non-numeric values.

Examples

title: "Select a label"
formula: '=CHOOSE(2,"Low","Medium","High")'
expected: "Medium"

title: "Use numeric choices"
formula: '=CHOOSE(3,10,20,30,40)'
expected: 30

related:
  - INDEX
  - CHOOSECOLS
  - CHOOSEROWS
faq:
  - q: "How are decimal index_num values handled?"
    a: "The index is truncated toward zero before selection, so CHOOSE(2.9,...) selects the second argument."
  - q: "What error do I get for index_num 0 or too large?"
    a: "CHOOSE returns #VALUE! when index_num is less than 1 or greater than the number of provided choices."

[formualizer-docgen:schema:start] Name: CHOOSE Type: ChooseFn Min args: 2 Max args: 2 Variadic: false Signature: CHOOSE(arg1: number@scalar, arg2: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=Some(1),default=false} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for ChooseRowsFn

Returns selected rows from an array or range.

CHOOSEROWS builds a new spilled array containing only the requested rows, in the order provided.

Remarks

• Row indexes are 1-based; negative indexes count from the end (-1 is last row).
• Repeated indexes are allowed and duplicate rows in the output.
• Index 0 or out-of-bounds indexes return #VALUE!.
• The result spills as an array unless it collapses to a single cell.

Examples

title: "Pick first and last rows"
grid:
  A1: "Jan"
  A2: "Feb"
  A3: "Mar"
formula: '=CHOOSEROWS(A1:A3,1,-1)'
expected: [["Jan"],["Mar"]]

title: "Duplicate a row in output"
grid:
  A1: 5
  A2: 9
formula: '=CHOOSEROWS(A1:A2,2,2)'
expected: [[9],[9]]

related:
  - CHOOSECOLS
  - TAKE
  - DROP
faq:
  - q: "Can I return rows in a custom order?"
    a: "Yes. CHOOSEROWS returns rows in the exact order of the supplied indexes, and repeated indexes duplicate rows."
  - q: "When does CHOOSEROWS return #VALUE!?"
    a: "It returns #VALUE! for index 0 and for row indexes outside the source height after applying negative-index conversion."

[formualizer-docgen:schema:start] Name: CHOOSEROWS Type: ChooseRowsFn Min args: 2 Max args: variadic Variadic: true Signature: CHOOSEROWS(arg1: range|any@range, arg2…: number@scalar) Arg schema: arg1{kinds=range|any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=Some(1),default=false} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for ColumnFn

Returns the column number of a reference, or of the current cell when omitted.

COLUMN returns a 1-based column index (A = 1).

Remarks

• With a range argument, COLUMN returns the first column in that reference.
• Without arguments, it uses the column of the formula cell.
• Full-row references such as 5:5 return 1.
• Invalid references return an error (#REF!/#VALUE! depending on context).

Examples

title: "Column of a single-cell reference"
formula: '=COLUMN(C5)'
expected: 3

title: "Column of a range"
formula: '=COLUMN(B2:D4)'
expected: 2

related:
  - COLUMNS
  - ROW
  - ADDRESS
faq:
  - q: "What does COLUMN return for a range like B2:D4?"
    a: "COLUMN returns the first column index of the reference (2 for column B)."
  - q: "What if COLUMN() is used without a reference?"
    a: "It returns the formula cell's column number, or #VALUE! if current-cell context is unavailable."

[formualizer-docgen:schema:start] Name: COLUMN Type: ColumnFn Min args: 0 Max args: 1 Variadic: false Signature: COLUMN(arg1?: range@range) Arg schema: arg1{kinds=range,required=false,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ColumnsFn

Returns the number of columns in a reference or array.

COLUMNS reports width, not data density.

Remarks

• For a single cell reference, returns 1.
• For full-row references (for example 1:1), returns 16384.
• For array literals, returns the first row width.
• Invalid references return an error.

Examples

title: "Count columns in a rectangular range"
formula: '=COLUMNS(B2:D10)'
expected: 3

title: "Count columns in a full row reference"
formula: '=COLUMNS(1:1)'
expected: 16384

related:
  - COLUMN
  - ROWS
  - CHOOSECOLS
faq:
  - q: "Does COLUMNS count non-empty cells?"
    a: "No. COLUMNS returns the width of the referenced array/range, including blank cells."
  - q: "What does COLUMNS return for a full-row reference like 1:1?"
    a: "It returns the sheet column limit, 16384."

[formualizer-docgen:schema:start] Name: COLUMNS Type: ColumnsFn Min args: 1 Max args: 1 Variadic: false Signature: COLUMNS(arg1: any@range) Arg schema: arg1{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FilterFn

Filters rows from an array using a Boolean include mask.

FILTER returns only rows where the include condition evaluates to true.

Remarks

• include must have the same row count as array, or a single row used as broadcast.
• A row is kept if any include cell for that row is truthy.
• If no rows match, if_empty is returned when supplied; otherwise #CALC!.
• Dimension mismatches return #VALUE!.
• Results spill as dynamic arrays.

Examples

title: "Filter active records"
grid:
  A1: "Ana"
  B1: true
  A2: "Bo"
  B2: false
  A3: "Cy"
  B3: true
formula: '=FILTER(A1:A3,B1:B3)'
expected: [["Ana"],["Cy"]]

title: "Return fallback when no rows match"
grid:
  A1: 10
  A2: 20
  B1: false
  B2: false
formula: '=FILTER(A1:A2,B1:B2,"No matches")'
expected: "No matches"

related:
  - XLOOKUP
  - UNIQUE
  - SORT
faq:
  - q: "What happens when include has no TRUE rows?"
    a: "FILTER returns if_empty when provided; otherwise it returns #CALC! to signal an empty result set."
  - q: "How strict is include shape matching?"
    a: "include must match array row count or be a single broadcast row; incompatible dimensions return #VALUE!."

[formualizer-docgen:schema:start] Name: FILTER Type: FilterFn Min args: 2 Max args: variadic Variadic: true Signature: FILTER(arg1: range@range, arg2: range@range, arg3?…: any@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=false,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for GroupByFn

Groups rows by key fields and returns aggregated values as a spilled table.

GROUPBY summarizes one or more value columns using a selected aggregation function.

Remarks

• row_fields and values must have the same row count.
• Aggregation can be supplied as text (for example "SUM") or numeric code.
• Optional controls: field_headers, total_depth, sort_order.
• Invalid aggregation names/codes return #VALUE!.
• Output is dynamic-array shaped and may include generated headers or totals.

Examples

title: "Sum sales by region"
grid:
  A1: "Region"
  A2: "East"
  A3: "West"
  A4: "East"
  B1: "Sales"
  B2: 100
  B3: 80
  B4: 50
formula: '=GROUPBY(A1:A4,B1:B4,"SUM",3,0,1)'
expected: [["Region","Sales"],["East",150],["West",80]]

title: "Average with grand total"
grid:
  A1: "Team"
  A2: "A"
  A3: "A"
  A4: "B"
  B1: "Score"
  B2: 90
  B3: 70
  B4: 80
formula: '=GROUPBY(A1:A4,B1:B4,"AVERAGE",3,1,1)'
expected: "Grouped table with team averages plus grand total row"

related:
  - PIVOTBY
  - SORTBY
  - UNIQUE
faq:
  - q: "What shape constraints does GROUPBY enforce?"
    a: "row_fields and values must have the same number of rows; mismatched heights return #VALUE!."
  - q: "Can the aggregation function be numeric instead of text?"
    a: "Yes. GROUPBY accepts either function names (like \"SUM\") or numeric function codes, and invalid entries return #VALUE!."

[formualizer-docgen:schema:start] Name: GROUPBY Type: GroupByFn Min args: 3 Max args: variadic Variadic: true Signature: GROUPBY(arg1: range@range, arg2: range@range, arg3: any@scalar, arg4?: number@scalar, arg5?: number@scalar, arg6?…: number@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg4{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg5{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg6{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for HLookupFn

Looks up a value in the first row of a table and returns a value from another row.

HLOOKUP searches horizontally and returns the matching column’s value from row_index_num.

Remarks

• row_index_num is 1-based and must be within the table height.
• range_lookup defaults to FALSE in this engine (exact match by default).
• When range_lookup=TRUE, approximate match logic is used against the first row.
• If the lookup value is not found, returns #N/A.
• If row_index_num is invalid, returns #REF! (or #VALUE! if non-numeric).
• A matched empty target cell is materialized as numeric 0.

Examples

title: "Exact match across header row"
grid:
  A1: "Jan"
  B1: "Feb"
  A2: 120
  B2: 150
formula: '=HLOOKUP("Feb",A1:B2,2,FALSE)'
expected: 150

title: "Approximate threshold lookup"
grid:
  A1: 0
  B1: 50
  C1: 80
  A2: "F"
  B2: "C"
  C2: "A"
formula: '=HLOOKUP(72,A1:C2,2,TRUE)'
expected: "C"

related:
  - VLOOKUP
  - XLOOKUP
  - MATCH
faq:
  - q: "Does HLOOKUP default to exact or approximate matching?"
    a: "It defaults to exact matching in this engine because range_lookup defaults to FALSE."
  - q: "How are invalid row_index_num values reported?"
    a: "If row_index_num is outside table height HLOOKUP returns #REF!; if it is non-numeric it returns #VALUE!."

[formualizer-docgen:schema:start] Name: HLOOKUP Type: HLookupFn Min args: 3 Max args: 4 Variadic: false Signature: HLOOKUP(arg1: any@scalar, arg2: any@range, arg3: number@scalar, arg4?: logical@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg4{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for HStackFn

Concatenates arrays horizontally into a single spilled array.

HSTACK appends columns from each argument left-to-right.

Remarks

• All non-empty range arguments must have the same row count.
• Scalar arguments are treated as 1x1 values.
• Mismatched row counts return #VALUE!.
• Empty inputs are skipped; if all inputs are empty, result is an empty spill.

Examples

title: "Join two 2-row ranges side by side"
grid:
  A1: 1
  A2: 2
  B1: 10
  B2: 20
formula: '=HSTACK(A1:A2,B1:B2)'
expected: [[1,10],[2,20]]

title: "Append a scalar column"
grid:
  A1: "Item"
formula: '=HSTACK(A1,"OK")'
expected: [["Item","OK"]]

related:
  - VSTACK
  - CHOOSECOLS
  - TAKE
faq:
  - q: "Why does HSTACK return #VALUE! when combining ranges?"
    a: "All non-empty inputs must have identical row counts; mismatched heights produce #VALUE!."
  - q: "How are scalar arguments treated in HSTACK?"
    a: "Each scalar is treated as a 1x1 block, so it only aligns with other arguments when the target row count is 1."

[formualizer-docgen:schema:start] Name: HSTACK Type: HStackFn Min args: 1 Max args: variadic Variadic: true Signature: HSTACK(arg1…: range|any@range) Arg schema: arg1{kinds=range|any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=Some(1),default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MatchFn

Returns the relative position of a lookup value in a one-dimensional array.

MATCH supports exact and approximate modes and returns a 1-based position.

Remarks

• match_type defaults to 1 (approximate, ascending).
• match_type=0 performs exact matching and supports *, ?, and ~ wildcards for text.
• match_type=1 looks for the largest value less than or equal to the lookup value.
• match_type=-1 looks for the smallest value greater than or equal to the lookup value.
• Approximate modes require sorted data; unsorted data returns #N/A.
• If no match is found, returns #N/A.

Examples

title: "Exact text match"
grid:
  A1: "A"
  A2: "B"
  A3: "C"
formula: '=MATCH("B",A1:A3,0)'
expected: 2

title: "Approximate numeric match"
grid:
  A1: 10
  A2: 20
  A3: 30
  A4: 40
formula: '=MATCH(27,A1:A4,1)'
expected: 2

related:
  - XMATCH
  - XLOOKUP
  - VLOOKUP
faq:
  - q: "Why does MATCH with match_type 1 or -1 return #N/A on unsorted data?"
    a: "Approximate modes assume ordered lookup data; this implementation treats detected unsorted inputs as no valid match and returns #N/A."
  - q: "When are wildcards interpreted in MATCH?"
    a: "Wildcard patterns (*, ?, ~ escapes) are only applied in exact mode (match_type=0) for text lookup values."

[formualizer-docgen:schema:start] Name: MATCH Type: MatchFn Min args: 2 Max args: 3 Variadic: false Signature: MATCH(arg1: any@scalar, arg2: any@range, arg3?: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for PivotByFn

Builds a pivot-style summary matrix from row fields, column fields, and values.

PIVOTBY aggregates intersections of row keys and column keys into a dynamic result grid.

Remarks

• row_fields, col_fields, and values must have matching row counts.
• Aggregation accepts text names (for example "SUM") or numeric codes.
• Optional controls include header handling, row/column totals, and sort order.
• Current implementation uses the first column of col_fields and values for aggregation.
• Invalid setup returns #VALUE!.

Examples

title: "Pivot sales by region and quarter"
grid:
  A1: "Region"
  A2: "East"
  A3: "East"
  A4: "West"
  B1: "Quarter"
  B2: "Q1"
  B3: "Q2"
  B4: "Q1"
  C1: "Sales"
  C2: 100
  C3: 150
  C4: 120
formula: '=PIVOTBY(A1:A4,B1:B4,C1:C4,"SUM",3,0,1,0,1)'
expected: "Pivot table with regions as rows and quarters as columns"

title: "Pivot with totals enabled"
grid:
  A1: "Dept"
  A2: "Ops"
  A3: "Ops"
  A4: "Sales"
  B1: "Month"
  B2: "Jan"
  B3: "Feb"
  B4: "Jan"
  C1: "Cost"
  C2: 40
  C3: 35
  C4: 55
formula: '=PIVOTBY(A1:A4,B1:B4,C1:C4,"SUM",3,1,1,1,1)'
expected: "Pivot table including row and column totals"

related:
  - GROUPBY
  - SORTBY
  - UNIQUE
faq:
  - q: "What rows must align in PIVOTBY inputs?"
    a: "row_fields, col_fields, and values must share the same row count; otherwise PIVOTBY returns #VALUE!."
  - q: "What value range is currently aggregated?"
    a: "Current implementation aggregates using the first value column (and first col_fields column for keys), so extra columns are not yet summarized independently."

[formualizer-docgen:schema:start] Name: PIVOTBY Type: PivotByFn Min args: 4 Max args: variadic Variadic: true Signature: PIVOTBY(arg1: range@range, arg2: range@range, arg3: range@range, arg4: any@scalar, arg5?: number@scalar, arg6?: number@scalar, arg7?: number@scalar, arg8?: number@scalar, arg9?…: number@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg4{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg5{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg6{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg7{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg8{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg9{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RandArrayFn

Generates a random spilled array of numbers.

RANDARRAY can return decimal values or whole numbers in a specified range.

Remarks

• Defaults: rows=1, columns=1, min=0, max=1, whole_number=FALSE.
• The function is non-deterministic and recalculates to new values.
• For whole numbers, values are generated in an inclusive integer range.
• rows <= 0, columns <= 0, or invalid integer bounds return #VALUE!.

Examples

title: "Generate a 2x3 decimal matrix"
formula: '=RANDARRAY(2,3)'
expected: "2x3 array of decimals in [0,1)"

title: "Generate six integer dice rolls"
formula: '=RANDARRAY(6,1,1,6,TRUE)'
expected: "6x1 array of integers from 1 to 6"

related:
  - SEQUENCE
  - SORT
  - UNIQUE
faq:
  - q: "Are RANDARRAY bounds inclusive?"
    a: "In whole_number mode, min and max are inclusive integer bounds; in decimal mode values are generated over the numeric interval from min toward max."
  - q: "Why does RANDARRAY recalculate on every recalc pass?"
    a: "RANDARRAY is volatile and non-deterministic by design, so its spilled results are regenerated each evaluation."

[formualizer-docgen:schema:start] Name: RANDARRAY Type: RandArrayFn Min args: 0 Max args: variadic Variadic: true Signature: RANDARRAY(arg1?: number@scalar, arg2?: number@scalar, arg3?: number@scalar, arg4?: number@scalar, arg5?…: logical@scalar) Arg schema: arg1{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg4{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg5{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: none [formualizer-docgen:schema:end]

impl Function for RowFn

Returns the row number of a reference, or of the current cell when omitted.

ROW returns a 1-based row index.

Remarks

• With a range argument, ROW returns the first row in that reference.
• Without arguments, it uses the row of the formula cell.
• Full-column references such as A:A return 1.
• Invalid references return an error (#REF!/#VALUE! depending on context).

Examples

title: "Row of a single-cell reference"
formula: '=ROW(B5)'
expected: 5

title: "Row of a multi-cell range"
formula: '=ROW(C3:E9)'
expected: 3

related:
  - ROWS
  - COLUMN
  - ADDRESS
faq:
  - q: "What does ROW return for a multi-cell reference?"
    a: "ROW returns the first row index of the reference, not an array of every row number."
  - q: "What if ROW() is called without arguments?"
    a: "It uses the formula cell position; if no current cell context exists, it returns #VALUE!."

[formualizer-docgen:schema:start] Name: ROW Type: RowFn Min args: 0 Max args: 1 Variadic: false Signature: ROW(arg1?: range@range) Arg schema: arg1{kinds=range,required=false,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RowsFn

Returns the number of rows in a reference or array.

ROWS reports height, not data density.

Remarks

• For a single cell reference, returns 1.
• For full-column references (for example A:A), returns 1048576.
• For array literals, returns the outer array length.
• Invalid references return an error.

Examples

title: "Count rows in a contiguous range"
formula: '=ROWS(B2:D10)'
expected: 9

title: "Count rows in a full column reference"
formula: '=ROWS(A:A)'
expected: 1048576

related:
  - ROW
  - COLUMNS
  - INDEX
faq:
  - q: "Does ROWS count populated rows or reference height?"
    a: "ROWS returns reference height only; blanks inside the range do not reduce the count."
  - q: "How does ROWS behave for full-column references?"
    a: "A full-column reference (like A:A) returns the sheet row limit, 1048576."

[formualizer-docgen:schema:start] Name: ROWS Type: RowsFn Min args: 1 Max args: 1 Variadic: false Signature: ROWS(arg1: any@range) Arg schema: arg1{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SortByFn

Sorts an array based on one or more aligned sort-by arrays.

SORTBY separates what is returned (array) from what determines ordering (by_array).

Remarks

• Requires at least one by_array aligned to the row count of array.
• sort_order defaults to ascending when omitted.
• Additional by_array/sort_order criteria are processed left-to-right.
• Shape mismatches or invalid criteria return #VALUE!.
• Returns a spilled sorted array.

Examples

title: "Sort names by score"
grid:
  A1: "Charlie"
  A2: "Alice"
  A3: "Bob"
  B1: 3
  B2: 1
  B3: 2
formula: '=SORTBY(A1:A3,B1:B3)'
expected: [["Alice"],["Bob"],["Charlie"]]

title: "Sort descending by key"
grid:
  A1: "Q1"
  A2: "Q2"
  A3: "Q3"
  B1: 100
  B2: 300
  B3: 200
formula: '=SORTBY(A1:A3,B1:B3,-1)'
expected: [["Q2"],["Q3"],["Q1"]]

related:
  - SORT
  - UNIQUE
  - FILTER
faq:
  - q: "How are multiple sort criteria applied?"
    a: "SORTBY evaluates criteria left-to-right, using later by_array values only when earlier criteria compare equal."
  - q: "Why do I get #VALUE! with SORTBY?"
    a: "Each by_array must be one-dimensional and aligned to the primary array row count; mismatched shapes return #VALUE!."

[formualizer-docgen:schema:start] Name: SORTBY Type: SortByFn Min args: 2 Max args: variadic Variadic: true Signature: SORTBY(arg1: range@range, arg2: range@range, arg3?…: number@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SortFn

Sorts an array by a selected row or column and returns a spilled result.

SORT can order rows (default) or columns.

Remarks

• Defaults: sort_index=1, sort_order=1 (ascending), by_col=FALSE.
• sort_index is 1-based in the active sort axis.
• sort_order < 0 sorts descending; otherwise ascending.
• Invalid sort indexes return #VALUE!.
• Empty input returns an empty spill.

Examples

title: "Sort rows by second column"
grid:
  A1: "C"
  B1: 30
  A2: "A"
  B2: 10
  A3: "B"
  B3: 20
formula: '=SORT(A1:B3,2,1,FALSE)'
expected: [["A",10],["B",20],["C",30]]

title: "Sort columns by first row descending"
grid:
  A1: 1
  B1: 3
  C1: 2
  A2: "A"
  B2: "C"
  C2: "B"
formula: '=SORT(A1:C2,1,-1,TRUE)'
expected: [[3,2,1],["C","B","A"]]

related:
  - SORTBY
  - TAKE
  - DROP
faq:
  - q: "What changes when by_col is TRUE?"
    a: "SORT reorders columns instead of rows, and sort_index is interpreted as a row index used as the sort key."
  - q: "What causes #VALUE! in SORT?"
    a: "If sort_index is outside the active axis (row or column axis based on by_col), SORT returns #VALUE!."

[formualizer-docgen:schema:start] Name: SORT Type: SortFn Min args: 1 Max args: variadic Variadic: true Signature: SORT(arg1: range@range, arg2?: number@scalar, arg3?: number@scalar, arg4?…: logical@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg4{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for UniqueFn

Returns distinct rows or columns from a range.

UNIQUE preserves first-occurrence order and can optionally return only values that appear once.

Remarks

• Defaults: by_col=FALSE, exactly_once=FALSE.
• With by_col=FALSE, uniqueness is evaluated by full rows.
• With by_col=TRUE, uniqueness is evaluated by full columns.
• With exactly_once=TRUE, only entries with frequency 1 are returned.
• Result spills as an array.

Examples

title: "Unique values by row"
grid:
  A1: "A"
  A2: "A"
  A3: "B"
  A4: "C"
formula: '=UNIQUE(A1:A4)'
expected: [["A"],["B"],["C"]]

title: "Only values that appear once"
grid:
  A1: 1
  A2: 1
  A3: 2
  A4: 3
formula: '=UNIQUE(A1:A4,FALSE,TRUE)'
expected: [[2],[3]]

related:
  - FILTER
  - SORT
  - SORTBY
faq:
  - q: "What does exactly_once=TRUE change?"
    a: "Instead of returning first occurrences, UNIQUE returns only rows or columns whose full key appears exactly one time."
  - q: "How does by_col affect uniqueness checks?"
    a: "by_col=FALSE compares entire rows, while by_col=TRUE compares entire columns and spills unique columns."

[formualizer-docgen:schema:start] Name: UNIQUE Type: UniqueFn Min args: 1 Max args: variadic Variadic: true Signature: UNIQUE(arg1: range@range, arg2?: logical@scalar, arg3?…: logical@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true}; arg3{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for VLookupFn

Looks up a value in the first column of a table and returns a value from another column.

VLOOKUP searches vertically and returns the matching row’s value from col_index_num.

Remarks

• col_index_num is 1-based and must be within the table width.
• range_lookup defaults to FALSE in this engine (exact match by default).
• When range_lookup=TRUE, approximate match logic is used against the first column.
• If the lookup value is not found, returns #N/A.
• If col_index_num is invalid, returns #REF! (or #VALUE! if non-numeric).
• A matched empty target cell is materialized as numeric 0.

Examples

title: "Exact match in a key/value table"
grid:
  A1: "SKU-1"
  B1: 12.5
  A2: "SKU-2"
  B2: 18
formula: '=VLOOKUP("SKU-2",A1:B2,2,FALSE)'
expected: 18

title: "Approximate tier lookup"
grid:
  A1: 0
  B1: "Bronze"
  A2: 1000
  B2: "Silver"
  A3: 5000
  B3: "Gold"
formula: '=VLOOKUP(3200,A1:B3,2,TRUE)'
expected: "Silver"

related:
  - HLOOKUP
  - XLOOKUP
  - MATCH
faq:
  - q: "What is the default behavior when range_lookup is omitted?"
    a: "This engine defaults range_lookup to FALSE, so VLOOKUP performs exact matching unless TRUE is explicitly provided."
  - q: "What happens if col_index_num points outside the table?"
    a: "A numeric out-of-range column index returns #REF!, while a non-numeric col_index_num returns #VALUE!."

[formualizer-docgen:schema:start] Name: VLOOKUP Type: VLookupFn Min args: 3 Max args: 4 Variadic: false Signature: VLOOKUP(arg1: any@scalar, arg2: any@range, arg3: number@scalar, arg4?: logical@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg4{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for VStackFn

Concatenates arrays vertically into a single spilled array.

VSTACK appends rows from each argument top-to-bottom.

Remarks

• All non-empty range arguments must have the same column count.
• Scalar arguments are treated as 1x1 values.
• Mismatched column counts return #VALUE!.
• Empty inputs are skipped; if all inputs are empty, result is an empty spill.

Examples

title: "Join two 1-row ranges vertically"
grid:
  A1: 1
  B1: 10
  A2: 2
  B2: 20
formula: '=VSTACK(A1:B1,A2:B2)'
expected: [[1,10],[2,20]]

title: "Stack scalar values"
formula: '=VSTACK(5,9)'
expected: [[5],[9]]

related:
  - HSTACK
  - CHOOSEROWS
  - DROP
faq:
  - q: "When does VSTACK return #VALUE!?"
    a: "VSTACK requires matching column counts across non-empty range arguments; differing widths return #VALUE!."
  - q: "What happens if all VSTACK inputs are empty ranges?"
    a: "Empty inputs are skipped, and if every argument is empty the function returns an empty spill."

[formualizer-docgen:schema:start] Name: VSTACK Type: VStackFn Min args: 1 Max args: variadic Variadic: true Signature: VSTACK(arg1…: range|any@range) Arg schema: arg1{kinds=range|any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=Some(1),default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for XLookupFn

Looks up a value in one array and returns the aligned value from another array.

XLOOKUP supports exact, approximate, and wildcard matching with forward or reverse search.

Remarks

• Defaults: match_mode=0 (exact), search_mode=1 (first-to-last).
• if_not_found is optional; if omitted and no match exists, returns #N/A.
• match_mode: 0 exact, -1 exact-or-next-smaller, 1 exact-or-next-larger, 2 wildcard.
• search_mode: 1 forward, -1 reverse. Other modes are accepted with current fallback behavior.
• lookup_array must be 1D. Invalid shape returns #VALUE!.
• If return_array is multi-column or multi-row, the matched row/column is returned as a spill.

Examples

title: "Exact key lookup with fallback"
grid:
  A1: "id"
  A2: 101
  A3: 102
  B1: "name"
  B2: "Ana"
  B3: "Bo"
formula: '=XLOOKUP(102,A2:A3,B2:B3,"Missing")'
expected: "Bo"

title: "Return a full row from a matched key"
grid:
  A1: 1
  A2: 2
  B1: "East"
  C1: 120
  B2: "West"
  C2: 140
formula: '=XLOOKUP(2,A1:A2,B1:C2)'
expected: [["West",140]]

related:
  - XMATCH
  - MATCH
  - FILTER
faq:
  - q: "How do match_mode and search_mode interact?"
    a: "match_mode controls exact/approximate/wildcard behavior, while search_mode controls scan direction; reverse search (-1) returns the last matching position."
  - q: "What happens when no match is found?"
    a: "If if_not_found is provided, XLOOKUP returns that value; otherwise it returns #N/A."
  - q: "Why do I get #VALUE! from XLOOKUP on valid ranges?"
    a: "The lookup_array must be one-dimensional (single row or single column); multi-row-and-column lookup ranges return #VALUE!."

[formualizer-docgen:schema:start] Name: XLOOKUP Type: XLookupFn Min args: 3 Max args: variadic Variadic: true Signature: XLOOKUP(arg1: any@scalar, arg2: range@range, arg3: range@range, arg4?: any@scalar, arg5?: number@scalar, arg6?…: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg4{kinds=any,required=false,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg5{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg6{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for XMatchFn

Returns the 1-based position of a value in a one-dimensional lookup array.

XMATCH extends MATCH with explicit search direction and wildcard mode.

Remarks

• Defaults: match_mode=0 (exact), search_mode=1 (first-to-last).
• match_mode: 0 exact, -1 exact-or-next-smaller, 1 exact-or-next-larger, 2 wildcard.
• search_mode: 1 forward, -1 reverse, 2 ascending binary intent, -2 descending binary intent.
• lookup_array must be a single row or single column, otherwise returns #VALUE!.
• Not found returns #N/A.

Examples

title: "Exact match position"
grid:
  A1: "alpha"
  A2: "beta"
  A3: "gamma"
formula: '=XMATCH("beta",A1:A3)'
expected: 2

title: "Reverse search finds last duplicate"
grid:
  A1: 7
  A2: 9
  A3: 7
formula: '=XMATCH(7,A1:A3,0,-1)'
expected: 3

related:
  - XLOOKUP
  - MATCH
  - INDEX
faq:
  - q: "How do search_mode values affect duplicate matches?"
    a: "search_mode=1 returns the first qualifying match, while search_mode=-1 scans from the end and returns the last qualifying match."
  - q: "When do binary-intent search modes (2 or -2) return #N/A?"
    a: "For approximate modes they require sorted data in the expected direction; unsorted arrays are treated as no valid match and return #N/A."

[formualizer-docgen:schema:start] Name: XMATCH Type: XMatchFn Min args: 2 Max args: variadic Variadic: true Signature: XMATCH(arg1: any@scalar, arg2: range@range, arg3?: number@scalar, arg4?…: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg4{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE, LOOKUP [formualizer-docgen:schema:end]

impl Function for AverageFn

Returns the arithmetic mean of numeric values across scalars and ranges.

AVERAGE sums numeric inputs and divides by the count of numeric values that participated.

Remarks

• Errors in any scalar argument or referenced range propagate immediately.
• In ranges, only numeric/date-time serial values are included; text and blanks are ignored.
• Scalar arguments use lenient number coercion with locale support.
• If no numeric values are found, AVERAGE returns #DIV/0!.

Examples

title: "Average of scalar values"
formula: "=AVERAGE(10, 20, 5)"
expected: 11.666666666666666

title: "Average over a mixed range"
grid:
  A1: 10
  A2: "x"
  A3: 20
formula: "=AVERAGE(A1:A3)"
expected: 15

title: "No numeric values returns divide-by-zero"
formula: "=AVERAGE(\"x\", \"\")"
expected: "#DIV/0!"

related:
  - SUM
  - COUNT
  - AVERAGEIF
  - AVERAGEIFS
faq:
  - q: "When does AVERAGE return #DIV/0!?"
    a: "It returns #DIV/0! when no numeric values are found after filtering/coercion."
  - q: "Do text cells in ranges affect the denominator?"
    a: "No. Only numeric values are counted toward the divisor."

[formualizer-docgen:schema:start] Name: AVERAGE Type: AverageFn Min args: 1 Max args: variadic Variadic: true Signature: AVERAGE(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for CountFn

Counts numeric values across scalars and ranges.

COUNT evaluates all arguments and counts how many are numeric values. Numbers, dates, and text representations of numbers (when supplied directly) are counted.

Remarks

• Text values inside ranges are ignored and not counted.
• Blank cells and logical values in ranges are ignored.

Examples

title: "Counting mixed scalar inputs"
formula: "=COUNT(1, \"x\", 2, 3)"
expected: 3

title: "Counting in a range"
grid:
  A1: 10
  A2: "foo"
  A3: 20
formula: "=COUNT(A1:A3)"
expected: 2

related:
  - COUNTA
  - COUNTBLANK
  - COUNTIF
  - COUNTIFS
faq:
  - q: "Why doesn't COUNT include text in a range?"
    a: "COUNT only counts numeric values; text cells in ranges are ignored."
  - q: "Can direct text like \"12\" be counted?"
    a: "Yes. Direct scalar arguments are coerced and counted when they parse as numbers."

[formualizer-docgen:schema:start] Name: COUNT Type: CountFn Min args: 0 Max args: variadic Variadic: true Signature: COUNT(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for SumFn

Adds numeric values across scalars and ranges.

SUM evaluates all arguments, coercing text to numbers where possible, and returns the total. Blank cells and logical values in ranges are ignored.

Remarks

• If any argument evaluates to an error, SUM propagates the first error it encounters.
• Unparseable text literals (e.g., "foo") will result in a #VALUE! error.

Examples

title: "Basic scalar addition"
formula: "=SUM(10, 20, 5)"
expected: 35

title: "Summing a range"
grid:
  A1: 10
  A2: 20
  A3: "N/A"
formula: "=SUM(A1:A3)"
expected: 30

related:
  - SUMIF
  - SUMIFS
  - SUMPRODUCT
  - AVERAGE
faq:
  - q: "Why does SUM return #VALUE! for some text arguments?"
    a: "Direct scalar text that cannot be parsed as a number raises #VALUE! during coercion."
  - q: "Do text and logical values inside ranges get added?"
    a: "No. In ranged inputs, only numeric cells contribute to the total."

[formualizer-docgen:schema:start] Name: SUM Type: SumFn Min args: 0 Max args: variadic Variadic: true Signature: SUM(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK, PARALLEL_ARGS [formualizer-docgen:schema:end]

impl Function for SumProductFn

Multiplies aligned values across arrays and returns the sum of those products.

SUMPRODUCT supports scalar or range inputs, applies broadcast semantics, and accumulates the product for each aligned cell position.

Remarks

• Input shapes must be broadcast-compatible; otherwise SUMPRODUCT returns #VALUE!.
• Non-numeric values are treated as 0 during multiplication.
• Any explicit error value in the inputs propagates immediately.

Examples

title: "Pairwise sum of products"
formula: "=SUMPRODUCT({1,2,3}, {4,5,6})"
expected: 32

title: "Range-based sumproduct"
grid:
  A1: 2
  A2: 3
  A3: 4
  B1: 10
  B2: 20
  B3: 30
formula: "=SUMPRODUCT(A1:A3, B1:B3)"
expected: 200

title: "Text entries contribute zero"
formula: "=SUMPRODUCT({1,\"x\",3}, {1,1,1})"
expected: 4

related:
  - SUM
  - PRODUCT
  - MMULT
  - SUMIFS
faq:
  - q: "Why does SUMPRODUCT return #VALUE! with some array shapes?"
    a: "The argument arrays must be broadcast-compatible; incompatible shapes raise #VALUE!."
  - q: "How are text values handled in multiplication?"
    a: "Non-numeric values are treated as 0, unless an explicit error is present."

[formualizer-docgen:schema:start] Name: SUMPRODUCT Type: SumProductFn Min args: 1 Max args: variadic Variadic: true Signature: SUMPRODUCT(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for CombinFn

Returns the number of combinations for selecting k items from n.

COMBIN evaluates n choose k using truncated integer inputs.

Remarks

• Fractional inputs are truncated toward zero before evaluation.
• If n < 0, k < 0, or k > n, the function returns #NUM!.
• Argument errors propagate directly.

Examples

title: "Basic combinations"
formula: "=COMBIN(5, 2)"
expected: 10

title: "Fractional arguments are truncated"
formula: "=COMBIN(6.9, 3.2)"
expected: 20

title: "Invalid k returns numeric error"
formula: "=COMBIN(3, 5)"
expected: "#NUM!"

related:
  - COMBINA
  - PERMUT
  - FACT
faq:
  - q: "When does COMBIN return #NUM!?"
    a: "It returns #NUM! if n or k is negative, or if k is greater than n after truncation."
  - q: "Can COMBIN take non-integer values?"
    a: "Yes, but both inputs are truncated toward zero before evaluation."

[formualizer-docgen:schema:start] Name: COMBIN Type: CombinFn Min args: 2 Max args: 2 Variadic: false Signature: COMBIN(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FactFn

Returns the factorial of a non-negative integer.

FACT truncates fractional inputs toward zero before computing the factorial.

Remarks

• Non-numeric values that cannot be coerced return #VALUE!.
• Negative inputs return #NUM!.
• Results above 170! overflow Excel-compatible limits and return #NUM!.

Examples

title: "Basic factorial"
formula: "=FACT(5)"
expected: 120

title: "Fractional input is truncated"
formula: "=FACT(5.9)"
expected: 120

title: "Negative input returns numeric error"
formula: "=FACT(-1)"
expected: "#NUM!"

related:
  - FACTDOUBLE
  - GAMMALN
  - COMBIN
faq:
  - q: "Why does FACT(171) return #NUM!?"
    a: "Excel-compatible factorial support is capped at 170!; larger values overflow and return #NUM!."
  - q: "Does FACT round fractional inputs?"
    a: "No. It truncates toward zero before computing the factorial."

[formualizer-docgen:schema:start] Name: FACT Type: FactFn Min args: 1 Max args: 1 Variadic: false Signature: FACT(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for GcdFn

Returns the greatest common divisor of one or more integers.

GCD truncates each argument toward zero before calculating the divisor.

Remarks

• Inputs must be between 0 and 9.99999999e9 after truncation, or #NUM! is returned.
• Negative values return #NUM!.
• Any argument error propagates immediately.

Examples

title: "Greatest common divisor of two numbers"
formula: "=GCD(24, 36)"
expected: 12

title: "Variadic and fractional arguments"
formula: "=GCD(18.9, 6, 30)"
expected: 6

title: "Negative values are invalid"
formula: "=GCD(-2, 4)"
expected: "#NUM!"

related:
  - LCM
  - MOD
  - QUOTIENT
faq:
  - q: "What happens to decimal inputs in GCD?"
    a: "Each argument is truncated toward zero before the divisor is computed."
  - q: "When does GCD return #NUM!?"
    a: "Negative values or values outside the supported bound return #NUM!."

[formualizer-docgen:schema:start] Name: GCD Type: GcdFn Min args: 1 Max args: variadic Variadic: true Signature: GCD(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LcmFn

Returns the least common multiple of one or more integers.

LCM truncates fractional arguments toward zero and combines values iteratively.

Remarks

• Inputs must be non-negative and within the supported Excel-compatible range.
• If any input is 0, the resulting least common multiple is 0.
• Any argument error propagates immediately.

Examples

title: "Least common multiple for two integers"
formula: "=LCM(4, 6)"
expected: 12

title: "Fractional values are truncated"
formula: "=LCM(6.8, 8.2)"
expected: 24

title: "Negative values return numeric error"
formula: "=LCM(-3, 6)"
expected: "#NUM!"

related:
  - GCD
  - MOD
  - MROUND
faq:
  - q: "Why does LCM return 0 when one argument is 0?"
    a: "LCM is defined as 0 if any truncated input is 0 in this implementation."
  - q: "Are fractional inputs accepted?"
    a: "Yes, but they are truncated toward zero before the LCM calculation."

[formualizer-docgen:schema:start] Name: LCM Type: LcmFn Min args: 1 Max args: variadic Variadic: true Signature: LCM(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PermutFn

Returns the number of permutations for selecting and ordering k items from n.

PERMUT computes n!/(n-k)! after truncating both inputs toward zero.

Remarks

• Fractional inputs are truncated to integers.
• If n < 0, k < 0, or k > n, the function returns #NUM!.
• Argument errors propagate directly.

Examples

title: "Basic permutations"
formula: "=PERMUT(5, 2)"
expected: 20

title: "Fractional arguments are truncated"
formula: "=PERMUT(7.9, 3.1)"
expected: 210

title: "Out-of-range k returns numeric error"
formula: "=PERMUT(4, 6)"
expected: "#NUM!"

related:
  - COMBIN
  - FACT
  - MULTINOMIAL
faq:
  - q: "Why does PERMUT fail when k is larger than n?"
    a: "Permutations require choosing at most n items, so k > n returns #NUM!."
  - q: "How are decimal inputs handled?"
    a: "PERMUT truncates n and k toward zero before computing n!/(n-k)!."

[formualizer-docgen:schema:start] Name: PERMUT Type: PermutFn Min args: 2 Max args: 2 Variadic: false Signature: PERMUT(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for AverageIfFn

Returns the average of cells that satisfy a single criterion.

AVERAGEIF tests each cell in range, then averages matching values from average_range (or from range when average_range is omitted).

Remarks

• Criteria support comparison operators and wildcard text patterns.
• Non-numeric values in the averaged cells are ignored.
• If no cells match, AVERAGEIF returns #DIV/0!.

Examples

title: "Average values greater than a threshold"
grid:
  A1: 10
  A2: 25
  A3: 40
formula: "=AVERAGEIF(A1:A3, \">20\")"
expected: 32.5

title: "Average one range using criteria from another"
grid:
  A1: "East"
  A2: "West"
  A3: "East"
  B1: 10
  B2: 40
  B3: 20
formula: "=AVERAGEIF(A1:A3, \"East\", B1:B3)"
expected: 15

title: "No matches returns divide-by-zero"
formula: "=AVERAGEIF({1,2,3}, \">5\")"
expected: "#DIV/0!"

related:
  - AVERAGE
  - AVERAGEIFS
  - SUMIF
  - COUNTIF
faq:
  - q: "When does AVERAGEIF return #DIV/0!?"
    a: "It returns #DIV/0! when no matching cells contribute numeric values."
  - q: "If average_range is omitted, what gets averaged?"
    a: "The function averages matching numeric cells from the criteria range itself."

[formualizer-docgen:schema:start] Name: AVERAGEIF Type: AverageIfFn Min args: 2 Max args: variadic Variadic: true Signature: AVERAGEIF(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for AverageIfsFn

Returns the average of cells that satisfy multiple criteria.

AVERAGEIFS filters by all criteria pairs, then averages matching numeric values.

Remarks

• The first argument is the average target range.
• Criteria are supplied in (criteria_range, criteria) pairs.
• If no numeric cells match, the function returns #DIV/0!.

Examples

title: "Average with two criteria"
grid:
  A1: "East"
  A2: "East"
  A3: "West"
  B1: 2025
  B2: 2024
  B3: 2025
  C1: 10
  C2: 40
  C3: 30
formula: "=AVERAGEIFS(C1:C3, A1:A3, \"East\", B1:B3, \">=2025\")"
expected: 10

title: "Average over inline arrays"
formula: "=AVERAGEIFS({10,20,30}, {1,2,3}, \">=2\")"
expected: 25

title: "No matches returns divide-by-zero"
formula: "=AVERAGEIFS({10,20}, {\"A\",\"B\"}, \"C\")"
expected: "#DIV/0!"

related:
  - AVERAGEIF
  - AVERAGE
  - SUMIFS
  - COUNTIFS
faq:
  - q: "When does AVERAGEIFS return #DIV/0!?"
    a: "It returns #DIV/0! when no matching numeric cells are available to average."
  - q: "Do non-numeric matched cells count in the average?"
    a: "No. Only numeric target cells contribute to sum and count."

[formualizer-docgen:schema:start] Name: AVERAGEIFS Type: AverageIfsFn Min args: 3 Max args: variadic Variadic: true Signature: AVERAGEIFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for CountAFn

Counts non-empty cells and scalar arguments.

COUNTA counts any value except true empty cells.

Remarks

• Numbers, text, booleans, and errors all count.
• Empty string values ("") are counted as non-empty.
• Truly empty cells are the only values excluded.

Examples

title: "Count mixed populated values"
formula: "=COUNTA(1, \"x\", TRUE, \"\")"
expected: 4

title: "Range count excludes only true blanks"
grid:
  A1: 10
  A2: ""
formula: "=COUNTA(A1:A3)"
expected: 2

title: "Errors are counted"
formula: "=COUNTA(1/0, 5)"
expected: 2

related:
  - COUNT
  - COUNTBLANK
  - COUNTIF
faq:
  - q: "Does COUNTA count empty-string results like \"\"?"
    a: "Yes. Empty text is counted as non-empty by COUNTA."
  - q: "Are error values counted?"
    a: "Yes. Errors are considered populated values and increase the count."

[formualizer-docgen:schema:start] Name: COUNTA Type: CountAFn Min args: 1 Max args: variadic Variadic: true Signature: COUNTA(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for CountBlankFn

Counts blank cells, including empty-string text results.

COUNTBLANK treats both true empty cells and "" text values as blank.

Remarks

• Empty-string text values are counted.
• Numbers, booleans, and non-empty text are not counted.
• Supports scalar arguments and ranges.

Examples

title: "Count blanks in a range"
grid:
  A1: 10
  A2: ""
formula: "=COUNTBLANK(A1:A3)"
expected: 2

title: "Scalar empty-string counts as blank"
formula: "=COUNTBLANK(\"\", 5)"
expected: 1

title: "Non-empty values are excluded"
formula: "=COUNTBLANK(1, \"x\", TRUE)"
expected: 0

related:
  - COUNTA
  - COUNT
  - COUNTIF
faq:
  - q: "Does COUNTBLANK include cells that contain \"\"?"
    a: "Yes. Empty-string text values are treated as blank for COUNTBLANK."
  - q: "Are numeric zeros considered blank?"
    a: "No. Zero is a numeric value, so it is not counted as blank."

[formualizer-docgen:schema:start] Name: COUNTBLANK Type: CountBlankFn Min args: 1 Max args: variadic Variadic: true Signature: COUNTBLANK(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for CountIfFn

Counts cells in a range that satisfy a single criterion.

COUNTIF evaluates each candidate cell against one criteria expression.

Remarks

• Criteria support numeric comparisons and wildcard text matching.
• Matching is case-insensitive for text criteria.
• Non-matching or blank cells are not counted.

Examples

title: "Count numbers greater than 10"
grid:
  A1: 5
  A2: 15
  A3: 22
formula: "=COUNTIF(A1:A3, \">10\")"
expected: 2

title: "Count text with wildcard"
formula: "=COUNTIF({\"alpha\",\"beta\",\"alphabet\"}, \"al*\")"
expected: 2

title: "Exact-match criterion"
formula: "=COUNTIF({1,2,2,3}, \"=2\")"
expected: 2

related:
  - COUNTIFS
  - COUNTA
  - COUNTBLANK
  - SUMIF
faq:
  - q: "Is COUNTIF text matching case-sensitive?"
    a: "No. Text criteria matching is case-insensitive."
  - q: "Can COUNTIF evaluate wildcard criteria?"
    a: "Yes. Criteria expressions support wildcard patterns for text."

[formualizer-docgen:schema:start] Name: COUNTIF Type: CountIfFn Min args: 2 Max args: 1 Variadic: false Signature: COUNTIF(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for CountIfsFn

Counts cells that satisfy all supplied criteria pairs.

COUNTIFS applies each (criteria_range, criteria) pair and counts rows where all tests pass.

Remarks

• Requires one or more criteria pairs.
• Criteria support operators and wildcard matching.
• A row contributes to the result only when every criterion evaluates true.

Examples

title: "Count rows matching two filters"
grid:
  A1: "East"
  A2: "East"
  A3: "West"
  B1: 12
  B2: 8
  B3: 15
formula: "=COUNTIFS(A1:A3, \"East\", B1:B3, \">=10\")"
expected: 1

title: "Wildcard text matching"
formula: "=COUNTIFS({\"apple\",\"pear\",\"apricot\"}, \"ap*\")"
expected: 2

title: "No rows meeting all criteria"
formula: "=COUNTIFS({1,2,3}, \">5\", {\"a\",\"b\",\"c\"}, \"a\")"
expected: 0

related:
  - COUNTIF
  - SUMIFS
  - AVERAGEIFS
  - FILTER
faq:
  - q: "Why can COUNTIFS return 0 even when one criterion matches rows?"
    a: "Each row must satisfy every criterion pair; partial matches are excluded."
  - q: "Does COUNTIFS require at least one criteria pair?"
    a: "Yes. It expects arguments in (range, criteria) pairs."

[formualizer-docgen:schema:start] Name: COUNTIFS Type: CountIfsFn Min args: 2 Max args: variadic Variadic: true Signature: COUNTIFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for SumIfFn

Adds values that satisfy a single criterion.

SUMIF evaluates each cell in range against criteria, then sums corresponding values.

Remarks

• If sum_range is omitted, matching cells from range are summed.
• Criteria support operators like ">10" and wildcard text patterns.
• Cells that do not coerce to numbers in the sum target contribute 0.

Examples

title: "Sum values above a threshold"
grid:
  A1: 5
  A2: 15
  A3: 25
formula: "=SUMIF(A1:A3, \">10\")"
expected: 40

title: "Use separate sum range"
grid:
  A1: "East"
  A2: "West"
  A3: "East"
  B1: 10
  B2: 40
  B3: 20
formula: "=SUMIF(A1:A3, \"East\", B1:B3)"
expected: 30

title: "Wildcard criteria"
formula: "=SUMIF({\"apple\",\"pear\",\"apricot\"}, \"ap*\", {2,3,5})"
expected: 7

related:
  - SUM
  - SUMIFS
  - COUNTIF
  - AVERAGEIF
faq:
  - q: "What happens when matching cells are non-numeric in SUMIF?"
    a: "They contribute 0 to the sum target after coercion logic."
  - q: "Can SUMIF use wildcard criteria like * and ??"
    a: "Yes. Text criteria support wildcard matching semantics."

[formualizer-docgen:schema:start] Name: SUMIF Type: SumIfFn Min args: 2 Max args: variadic Variadic: true Signature: SUMIF(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for SumIfsFn

Adds values that satisfy multiple criteria.

SUMIFS applies all criteria pairs with logical AND and sums the matching cells.

Remarks

• The first argument is always the sum target range.
• Criteria are supplied in (criteria_range, criteria) pairs.
• Criteria ranges are broadcast/padded according to engine matching rules.

Examples

title: "Sum with two conditions"
grid:
  A1: "East"
  A2: "East"
  A3: "West"
  B1: 2024
  B2: 2025
  B3: 2025
  C1: 10
  C2: 20
  C3: 30
formula: "=SUMIFS(C1:C3, A1:A3, \"East\", B1:B3, \">=2025\")"
expected: 20

title: "Numeric criteria on single range"
formula: "=SUMIFS({5,10,20,30}, {1,2,3,4}, \">=2\", {1,2,3,4}, \"<=3\")"
expected: 30

title: "No matching rows yields zero"
formula: "=SUMIFS({10,20}, {\"A\",\"B\"}, \"C\")"
expected: 0

related:
  - SUMIF
  - COUNTIFS
  - AVERAGEIFS
  - SUMPRODUCT
faq:
  - q: "How are multiple SUMIFS criteria combined?"
    a: "All criteria pairs are applied with logical AND; every condition must match."
  - q: "What if criteria range sizes differ?"
    a: "Ranges are broadcast/padded under engine rules instead of strict Excel-size rejection."

[formualizer-docgen:schema:start] Name: SUMIFS Type: SumIfsFn Min args: 3 Max args: variadic Variadic: true Signature: SUMIFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, WINDOWED, STREAM_OK, PARALLEL_ARGS, PARALLEL_CHUNKS [formualizer-docgen:schema:end]

impl Function for AbsFn

Returns the absolute value of a number.

Remarks

• Negative numbers are returned as positive values.
• Zero and positive numbers are unchanged.
• Errors are propagated.

Examples

title: "Absolute value of a negative number"
formula: "=ABS(-12.5)"
expected: 12.5

title: "Absolute value from a cell reference"
grid:
  A1: -42
formula: "=ABS(A1)"
expected: 42

related:
  - SIGN
  - INT
  - MOD
faq:
  - q: "How does ABS handle errors or non-numeric text?"
    a: "Input errors propagate, and non-coercible text returns a coercion error."

[formualizer-docgen:schema:start] Name: ABS Type: AbsFn Min args: 1 Max args: 1 Variadic: false Signature: ABS(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ArabicFn

Converts a Roman numeral string to its Arabic numeric value.

Remarks

• Accepts text input containing Roman symbols (I,V,X,L,C,D,M).
• Surrounding whitespace is trimmed.
• Empty text returns 0.
• Invalid Roman syntax returns #VALUE!.

Examples

title: "Roman to Arabic"
formula: "=ARABIC(\"MCMXCIX\")"
expected: 1999

title: "Trimmed input"
formula: "=ARABIC(\"  XLIV  \")"
expected: 44

related:
  - ROMAN
  - VALUE
faq:
  - q: "What causes ARABIC to return #VALUE!?"
    a: "Invalid Roman symbols/syntax, non-text input, or overlength text produce #VALUE!."

[formualizer-docgen:schema:start] Name: ARABIC Type: ArabicFn Min args: 1 Max args: 1 Variadic: false Signature: ARABIC(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CeilingFn

Rounds a number up to the nearest multiple of a significance.

This implementation defaults significance to 1 and normalizes negative significance to positive.

Remarks

• If significance is omitted, 1 is used.
• significance = 0 returns #DIV/0!.
• Negative significance is treated as its absolute value in this fallback behavior.

Examples

title: "Round up to the nearest multiple"
formula: "=CEILING(5.1,2)"
expected: 6

title: "Round a negative number toward positive infinity"
formula: "=CEILING(-5.1,2)"
expected: -4

related:
  - CEILING.MATH
  - FLOOR
  - ROUNDUP
faq:
  - q: "What happens if CEILING significance is 0?"
    a: "It returns #DIV/0! because a zero multiple is invalid."

[formualizer-docgen:schema:start] Name: CEILING Type: CeilingFn Min args: 1 Max args: variadic Variadic: true Signature: CEILING(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CeilingMathFn

Rounds a number up to the nearest integer or multiple using CEILING.MATH rules.

Remarks

• If significance is omitted (or passed as 0), the function uses 1.
• significance is treated as a positive magnitude.
• For negative numbers, non-zero mode rounds away from zero; otherwise it rounds toward positive infinity.

Examples

title: "Default behavior for a positive number"
formula: "=CEILING.MATH(24.3,5)"
expected: 25

title: "Use mode to round a negative number away from zero"
formula: "=CEILING.MATH(-24.3,5,1)"
expected: -25

related:
  - CEILING
  - FLOOR.MATH
  - ROUNDUP
faq:
  - q: "How does mode affect negative numbers in CEILING.MATH?"
    a: "With non-zero mode, negatives round away from zero; otherwise they round toward +infinity."

[formualizer-docgen:schema:start] Name: CEILING.MATH Type: CeilingMathFn Min args: 1 Max args: variadic Variadic: true Signature: CEILING.MATH(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for EvenFn

Rounds a number away from zero to the nearest even integer.

Remarks

• Values already equal to an even integer stay unchanged.
• Positive and negative values both move away from zero.
• 0 returns 0.

Examples

title: "Round a positive number to even"
formula: "=EVEN(3)"
expected: 4

title: "Round a negative number away from zero"
formula: "=EVEN(-1.1)"
expected: -2

related:
  - ODD
  - ROUNDUP
  - MROUND
faq:
  - q: "Does EVEN ever round toward zero?"
    a: "No. It always rounds away from zero to the nearest even integer."

[formualizer-docgen:schema:start] Name: EVEN Type: EvenFn Min args: 1 Max args: 1 Variadic: false Signature: EVEN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ExpFn

Returns Euler’s number e raised to the given power.

EXP is the inverse of LN for positive-domain values.

Remarks

• Computes e^x using floating-point math.
• Very large positive inputs may overflow to infinity.
• Input errors are propagated.

Examples

title: "Compute e to the first power"
formula: "=EXP(1)"
expected: 2.718281828459045

title: "Invert LN"
formula: "=EXP(LN(5))"
expected: 5

related:
  - LN
  - LOG
  - LOG10
faq:
  - q: "Can EXP overflow?"
    a: "Yes. Very large positive inputs can overflow floating-point range."

[formualizer-docgen:schema:start] Name: EXP Type: ExpFn Min args: 1 Max args: 1 Variadic: false Signature: EXP(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FloorFn

Rounds a number down to the nearest multiple of a significance.

This implementation defaults significance to 1 and normalizes negative significance to positive.

Remarks

• If significance is omitted, 1 is used.
• significance = 0 returns #DIV/0!.
• Negative significance is treated as its absolute value in this fallback behavior.

Examples

title: "Round down to the nearest multiple"
formula: "=FLOOR(5.9,2)"
expected: 4

title: "Round a negative number to a lower multiple"
formula: "=FLOOR(-5.9,2)"
expected: -6

related:
  - FLOOR.MATH
  - CEILING
  - ROUNDDOWN
faq:
  - q: "Why does FLOOR move negative values farther from zero?"
    a: "FLOOR rounds down to a lower multiple, which is more negative for negative inputs."

[formualizer-docgen:schema:start] Name: FLOOR Type: FloorFn Min args: 1 Max args: variadic Variadic: true Signature: FLOOR(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FloorMathFn

Rounds a number down to the nearest integer or multiple using FLOOR.MATH rules.

Remarks

• If significance is omitted (or passed as 0), the function uses 1.
• significance is treated as a positive magnitude.
• For negative numbers, non-zero mode rounds toward zero; otherwise it rounds away from zero.

Examples

title: "Default behavior for a positive number"
formula: "=FLOOR.MATH(24.3,5)"
expected: 20

title: "Use mode to round a negative number toward zero"
formula: "=FLOOR.MATH(-24.3,5,1)"
expected: -20

related:
  - FLOOR
  - CEILING.MATH
  - ROUNDDOWN
faq:
  - q: "How does mode affect negative numbers in FLOOR.MATH?"
    a: "With non-zero mode, negatives round toward zero; otherwise they round away from zero."

[formualizer-docgen:schema:start] Name: FLOOR.MATH Type: FloorMathFn Min args: 1 Max args: variadic Variadic: true Signature: FLOOR.MATH(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for IntFn

Rounds a number down to the nearest integer.

INT uses floor semantics, so negative values move farther from zero.

Remarks

• Equivalent to mathematical floor (floor(x)).
• Coercion is lenient for numeric-like inputs; invalid values return an error.
• Input errors are propagated.

Examples

title: "Drop decimal digits from a positive number"
formula: "=INT(8.9)"
expected: 8

title: "Floor a negative number"
formula: "=INT(-8.9)"
expected: -9

related:
  - TRUNC
  - ROUNDDOWN
  - FLOOR
faq:
  - q: "Why is INT(-8.9) equal to -9 instead of -8?"
    a: "INT uses floor semantics, so negative values round toward negative infinity."

[formualizer-docgen:schema:start] Name: INT Type: IntFn Min args: 1 Max args: 1 Variadic: false Signature: INT(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LnFn

Returns the natural logarithm of a positive number.

Remarks

• number must be greater than 0; otherwise the function returns #NUM!.
• LN(EXP(x)) returns x up to floating-point precision.
• Input errors are propagated.

Examples

title: "Natural log of e cubed"
formula: "=LN(EXP(3))"
expected: 3

title: "Natural log of a fraction"
formula: "=LN(0.5)"
expected: -0.6931471805599453

related:
  - EXP
  - LOG
  - LOG10
faq:
  - q: "Why does LN return #NUM! for 0 or negatives?"
    a: "Natural logarithm is only defined for strictly positive inputs."

[formualizer-docgen:schema:start] Name: LN Type: LnFn Min args: 1 Max args: 1 Variadic: false Signature: LN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for Log10Fn

Returns the base-10 logarithm of a positive number.

Remarks

• number must be greater than 0; otherwise the function returns #NUM!.
• LOG10(POWER(10,x)) returns x up to floating-point precision.
• Input errors are propagated.

Examples

title: "Power of ten to exponent"
formula: "=LOG10(1000)"
expected: 3

title: "Log base 10 of a decimal"
formula: "=LOG10(0.01)"
expected: -2

related:
  - LOG
  - LN
  - EXP
faq:
  - q: "When does LOG10 return #NUM!?"
    a: "It returns #NUM! for non-positive input values."

[formualizer-docgen:schema:start] Name: LOG10 Type: Log10Fn Min args: 1 Max args: 1 Variadic: false Signature: LOG10(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LogFn

Returns the logarithm of a number for a specified base.

Remarks

• If base is omitted, base 10 is used.
• number must be positive.
• base must be positive and not equal to 1.
• Invalid domains return #NUM!.

Examples

title: "Base-10 logarithm"
formula: "=LOG(1000)"
expected: 3

title: "Base-2 logarithm"
formula: "=LOG(8,2)"
expected: 3

related:
  - LN
  - LOG10
  - EXP
faq:
  - q: "Which base values are invalid for LOG?"
    a: "Base must be positive and not equal to 1; otherwise LOG returns #NUM!."

[formualizer-docgen:schema:start] Name: LOG Type: LogFn Min args: 1 Max args: variadic Variadic: true Signature: LOG(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ModFn

Returns the remainder after division, with the sign of the divisor.

Remarks

• If divisor is 0, returns #DIV/0!.
• Result sign follows Excel-style MOD semantics (sign of divisor).
• Errors in either argument are propagated.

Examples

title: "Positive divisor"
formula: "=MOD(10,3)"
expected: 1

title: "Negative dividend"
formula: "=MOD(-3,2)"
expected: 1

related:
  - QUOTIENT
  - INT
  - GCD
faq:
  - q: "Why can MOD return a positive value for a negative dividend?"
    a: "MOD follows the sign of the divisor, matching Excel's modulo semantics."

[formualizer-docgen:schema:start] Name: MOD Type: ModFn Min args: 2 Max args: 2 Variadic: false Signature: MOD(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MroundFn

Rounds a number to the nearest multiple.

Remarks

• Returns 0 when multiple is 0.
• If number and multiple have different signs, returns #NUM!.
• Midpoints are rounded away from zero.

Examples

title: "Round to nearest 5"
formula: "=MROUND(17,5)"
expected: 15

title: "Round negative value"
formula: "=MROUND(-17,-5)"
expected: -15

related:
  - ROUND
  - CEILING
  - FLOOR
faq:
  - q: "Why does MROUND return #NUM! for mixed signs?"
    a: "If number and multiple have different signs (excluding zero), MROUND returns #NUM!."

[formualizer-docgen:schema:start] Name: MROUND Type: MroundFn Min args: 2 Max args: 2 Variadic: false Signature: MROUND(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MultinomialFn

Returns the multinomial coefficient for one or more values.

Remarks

• Each input is truncated toward zero before factorial is applied.
• Any negative term returns #NUM!.
• Values that require factorials outside 0..=170 return #NUM!.

Examples

title: "Compute a standard multinomial coefficient"
formula: "=MULTINOMIAL(2,3,4)"
expected: 1260

title: "Non-integers are truncated first"
formula: "=MULTINOMIAL(1.9,2.2)"
expected: 3

related:
  - FACT
  - COMBIN
  - PERMUT
faq:
  - q: "Why does MULTINOMIAL return #NUM! for large terms?"
    a: "If any required factorial falls outside 0..=170, the function returns #NUM!."

[formualizer-docgen:schema:start] Name: MULTINOMIAL Type: MultinomialFn Min args: 1 Max args: variadic Variadic: true Signature: MULTINOMIAL(arg1…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for OddFn

Rounds a number away from zero to the nearest odd integer.

Remarks

• Values already equal to an odd integer stay unchanged.
• Positive and negative values both move away from zero.
• 0 returns 1.

Examples

title: "Round a positive number to odd"
formula: "=ODD(2)"
expected: 3

title: "Round a negative number away from zero"
formula: "=ODD(-1.1)"
expected: -3

related:
  - EVEN
  - ROUNDUP
  - INT
faq:
  - q: "Why does ODD(0) return 1?"
    a: "ODD rounds away from zero to the nearest odd integer, so zero maps to positive one."

[formualizer-docgen:schema:start] Name: ODD Type: OddFn Min args: 1 Max args: 1 Variadic: false Signature: ODD(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PowerFn

Raises a base number to a specified power.

Remarks

• Equivalent to exponentiation (base^exponent).
• Negative bases with fractional exponents return #NUM!.
• Errors are propagated.

Examples

title: "Integer exponent"
formula: "=POWER(2,10)"
expected: 1024

title: "Fractional exponent"
formula: "=POWER(9,0.5)"
expected: 3

related:
  - SQRT
  - EXP
  - LN
faq:
  - q: "Why can POWER return #NUM! for negative bases?"
    a: "Negative bases with fractional exponents are rejected to avoid complex-number results."

[formualizer-docgen:schema:start] Name: POWER Type: PowerFn Min args: 2 Max args: 2 Variadic: false Signature: POWER(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for QuotientFn

Returns the integer portion of a division result, truncated toward zero.

Remarks

• Fractional remainder is discarded without rounding.
• Dividing by 0 returns #DIV/0!.
• Input errors are propagated.

Examples

title: "Positive quotient"
formula: "=QUOTIENT(10,3)"
expected: 3

title: "Negative quotient truncates toward zero"
formula: "=QUOTIENT(-10,3)"
expected: -3

related:
  - MOD
  - INT
  - TRUNC
faq:
  - q: "How is QUOTIENT different from regular division?"
    a: "It truncates the fractional part toward zero instead of returning a decimal result."

[formualizer-docgen:schema:start] Name: QUOTIENT Type: QuotientFn Min args: 2 Max args: 2 Variadic: false Signature: QUOTIENT(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RomanFn

Converts an Arabic number to a Roman numeral string.

Remarks

• Accepts integer values in the range 0..=3999.
• 0 returns an empty string.
• Optional form controls output compactness (0 classic through 4 simplified).
• Out-of-range values return #VALUE!.

Examples

title: "Classic Roman numeral"
formula: "=ROMAN(1999)"
expected: "MCMXCIX"

title: "Another conversion"
formula: "=ROMAN(44)"
expected: "XLIV"

related:
  - ARABIC
  - TEXT
faq:
  - q: "What input range does ROMAN support?"
    a: "ROMAN accepts truncated integers from 0 through 3999; outside that range it returns #VALUE!."

[formualizer-docgen:schema:start] Name: ROMAN Type: RomanFn Min args: 1 Max args: variadic Variadic: true Signature: ROMAN(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RoundDownFn

Rounds a number toward zero to a specified number of digits.

Remarks

• Positive num_digits affects decimals; negative values affect digits left of the decimal.
• Always reduces magnitude toward zero (unlike INT for negatives).
• Input errors are propagated.

Examples

title: "Trim decimals without rounding up"
formula: "=ROUNDDOWN(3.14159,3)"
expected: 3.141

title: "Round down a negative value at the hundreds place"
formula: "=ROUNDDOWN(-987.65,-2)"
expected: -900

related:
  - ROUND
  - ROUNDUP
  - TRUNC
faq:
  - q: "Does ROUNDDOWN always move toward negative infinity?"
    a: "No. It moves toward zero, which is different from FLOOR-style behavior on negatives."

[formualizer-docgen:schema:start] Name: ROUNDDOWN Type: RoundDownFn Min args: 2 Max args: 2 Variadic: false Signature: ROUNDDOWN(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RoundFn

Rounds a number to a specified number of digits.

Remarks

• Positive digits rounds to the right of the decimal point.
• Negative digits rounds to the left of the decimal point.
• Uses standard half-up style rounding from Rust’s round behavior.

Examples

title: "Round to two decimals"
formula: "=ROUND(3.14159,2)"
expected: 3.14

title: "Round to nearest hundred"
formula: "=ROUND(1234,-2)"
expected: 1200

related:
  - ROUNDUP
  - ROUNDDOWN
  - MROUND
faq:
  - q: "What does a negative digits argument do in ROUND?"
    a: "It rounds digits to the left of the decimal point (for example, tens or hundreds)."

[formualizer-docgen:schema:start] Name: ROUND Type: RoundFn Min args: 2 Max args: 2 Variadic: false Signature: ROUND(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RoundUpFn

Rounds a number away from zero to a specified number of digits.

Remarks

• Positive num_digits affects decimals; negative values affect digits left of the decimal.
• Any discarded non-zero part increases the magnitude of the result.
• Input errors are propagated.

Examples

title: "Round up decimals away from zero"
formula: "=ROUNDUP(3.14159,3)"
expected: 3.142

title: "Round up a negative value at the hundreds place"
formula: "=ROUNDUP(-987.65,-2)"
expected: -1000

related:
  - ROUND
  - ROUNDDOWN
  - CEILING
faq:
  - q: "What does ROUNDUP do when discarded digits are already zero?"
    a: "It leaves the value unchanged because no non-zero discarded part remains."

[formualizer-docgen:schema:start] Name: ROUNDUP Type: RoundUpFn Min args: 2 Max args: 2 Variadic: false Signature: ROUNDUP(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SeriesSumFn

Evaluates a power series from coefficients, start power, and step.

Remarks

• Computes sum(c_i * x^(n + i*m)) in coefficient order.
• Coefficients may be supplied as a scalar, array literal, or range.
• Errors in x, n, m, or coefficient values are propagated.

Examples

title: "Series from an array literal"
formula: "=SERIESSUM(2,0,1,{1,2,3})"
expected: 17

title: "Series from worksheet coefficients"
grid:
  A1: 1
  A2: -1
  A3: 0.5
formula: "=SERIESSUM(0.5,1,2,A1:A3)"
expected: 0.390625

related:
  - SUMPRODUCT
  - POWER
  - EXP
faq:
  - q: "In what order are SERIESSUM coefficients applied?"
    a: "Coefficients are consumed in input order as c_i*x^(n+i*m)."

[formualizer-docgen:schema:start] Name: SERIESSUM Type: SeriesSumFn Min args: 4 Max args: 4 Variadic: false Signature: SERIESSUM(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: any@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SignFn

Returns the sign of a number as -1, 0, or 1.

Remarks

• Returns 1 for positive numbers.
• Returns -1 for negative numbers.
• Returns 0 when input is zero.

Examples

title: "Positive input"
formula: "=SIGN(12)"
expected: 1

title: "Negative input"
formula: "=SIGN(-12)"
expected: -1

related:
  - ABS
  - INT
  - IF
faq:
  - q: "Can SIGN return anything other than -1, 0, or 1?"
    a: "No. After numeric coercion, the output is always exactly -1, 0, or 1."

[formualizer-docgen:schema:start] Name: SIGN Type: SignFn Min args: 1 Max args: 1 Variadic: false Signature: SIGN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SqrtFn

Returns the positive square root of a number.

Remarks

• Input must be greater than or equal to zero.
• Negative input returns #NUM!.

Examples

title: "Square root of a perfect square"
formula: "=SQRT(144)"
expected: 12

title: "Square root from a reference"
grid:
  A1: 2
formula: "=SQRT(A1)"
expected: 1.4142135623730951

related:
  - POWER
  - SQRTPI
  - EXP
faq:
  - q: "When does SQRT return #NUM!?"
    a: "It returns #NUM! for negative inputs because real square roots are undefined there."

[formualizer-docgen:schema:start] Name: SQRT Type: SqrtFn Min args: 1 Max args: 1 Variadic: false Signature: SQRT(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SqrtPiFn

Returns the square root of a number multiplied by pi.

Remarks

• Computes SQRT(number * PI()).
• number must be greater than or equal to 0; otherwise returns #NUM!.
• Input errors are propagated.

Examples

title: "Square root of pi"
formula: "=SQRTPI(1)"
expected: 1.772453850905516

title: "Scale before taking square root"
formula: "=SQRTPI(4)"
expected: 3.544907701811032

related:
  - SQRT
  - PI
  - POWER
faq:
  - q: "When does SQRTPI return #NUM!?"
    a: "It returns #NUM! when the input is negative, because number*PI must be non-negative."

[formualizer-docgen:schema:start] Name: SQRTPI Type: SqrtPiFn Min args: 1 Max args: 1 Variadic: false Signature: SQRTPI(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SumsqFn

Returns the sum of squares of supplied numbers.

Remarks

• Accepts one or more scalar values, arrays, or ranges.
• For ranges, non-numeric cells are ignored while errors are propagated.
• Date/time-like values in ranges are converted to numeric serial values before squaring.

Examples

title: "Sum squares of scalar arguments"
formula: "=SUMSQ(3,4)"
expected: 25

title: "Ignore text cells in a range"
grid:
  A1: 1
  A2: "x"
  A3: 2
formula: "=SUMSQ(A1:A3)"
expected: 5

related:
  - SUM
  - PRODUCT
  - SUMPRODUCT
faq:
  - q: "How does SUMSQ treat text cells in ranges?"
    a: "Non-numeric range cells are ignored, while explicit errors are propagated."

[formualizer-docgen:schema:start] Name: SUMSQ Type: SumsqFn Min args: 1 Max args: variadic Variadic: true Signature: SUMSQ(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for TruncFn

Truncates a number toward zero, optionally at a specified digit position.

Remarks

• If num_digits is omitted, truncation is to an integer.
• Positive num_digits keeps decimal places; negative values zero places to the left.
• Passing more than two arguments returns #VALUE!.

Examples

title: "Truncate to two decimal places"
formula: "=TRUNC(12.3456,2)"
expected: 12.34

title: "Truncate toward zero at the hundreds place"
formula: "=TRUNC(-987.65,-2)"
expected: -900

related:
  - INT
  - ROUND
  - ROUNDDOWN
faq:
  - q: "How does TRUNC differ from INT for negative numbers?"
    a: "TRUNC removes digits toward zero, while INT floors toward negative infinity."

[formualizer-docgen:schema:start] Name: TRUNC Type: TruncFn Min args: 1 Max args: variadic Variadic: true Signature: TRUNC(arg1: number@scalar, arg2…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MaxFn

Returns the largest numeric value from one or more arguments.

MAX scans scalar values and ranges, considering only values that can be treated as numbers.

Remarks

• Errors in any scalar argument or range cell propagate immediately.
• In ranges, non-numeric cells are ignored.
• Scalar text is included only when it can be coerced to a number.
• If no numeric value is found, MAX returns 0.

Examples

title: "Maximum in a numeric range"
grid:
  A1: 5
  A2: 9
  A3: 1
formula: "=MAX(A1:A3)"
expected: 9

title: "Scalar text can be coerced"
formula: "=MAX(2, \"11\", 4)"
expected: 11

title: "No numeric values returns zero"
formula: "=MAX(\"x\")"
expected: 0

related:
  - MIN
  - LARGE
  - SMALL
  - MAXIFS
faq:
  - q: "Why can MAX return 0 for non-numeric input sets?"
    a: "When no numeric values are found, MAX returns 0 by design."
  - q: "Does MAX evaluate scalar text arguments?"
    a: "Yes, but only when scalar text can be coerced to a numeric value."

[formualizer-docgen:schema:start] Name: MAX Type: MaxFn Min args: 1 Max args: variadic Variadic: true Signature: MAX(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for MinFn

Returns the smallest numeric value from one or more arguments.

MIN scans scalar values and ranges, considering only values that can be treated as numbers.

Remarks

• Errors in any scalar argument or range cell propagate immediately.
• In ranges, non-numeric cells are ignored.
• Scalar text is included only when it can be coerced to a number.
• If no numeric value is found, MIN returns 0.

Examples

title: "Minimum in a numeric range"
grid:
  A1: 8
  A2: -2
  A3: 5
formula: "=MIN(A1:A3)"
expected: -2

title: "Coercible scalar text participates"
formula: "=MIN(10, \"3\", 7)"
expected: 3

title: "No numeric values returns zero"
formula: "=MIN(\"x\")"
expected: 0

related:
  - MAX
  - SMALL
  - LARGE
  - MINIFS
faq:
  - q: "Why can MIN return 0 even when no numbers are present?"
    a: "If nothing numeric is found after coercion/scan, MIN falls back to 0."
  - q: "Do errors in referenced ranges get ignored?"
    a: "No. Any encountered range or scalar error is propagated."

[formualizer-docgen:schema:start] Name: MIN Type: MinFn Min args: 1 Max args: variadic Variadic: true Signature: MIN(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AcosFn

Returns the angle in radians whose cosine is the input value.

Use ACOS when you need an angle from a normalized adjacent/hypotenuse ratio.

Remarks

• Domain: input must be between -1 and 1, inclusive.
• Radians: output is in the range [0, PI()].
• Errors: returns #NUM! when the input is outside the valid domain.

Examples

title: "Arccosine of one half"
formula: "=ACOS(0.5)"
expected: 1.0471975511965979

title: "Upper-angle boundary"
formula: "=ACOS(-1)"
expected: 3.141592653589793

related:
  - COS
  - ASIN
  - ATAN2
faq:
  - q: "Why does ACOS reject values like 1.0001?"
    a: "ACOS is only defined on [-1, 1], so out-of-range inputs return #NUM!."

[formualizer-docgen:schema:start] Name: ACOS Type: AcosFn Min args: 1 Max args: 1 Variadic: false Signature: ACOS(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AcoshFn

Returns the inverse hyperbolic cosine of a number.

ACOSH is the inverse of COSH for inputs at or above 1.

Remarks

• Domain: input must be greater than or equal to 1.
• Radians: this function is hyperbolic, so the output is not an angle in radians.
• Errors: returns #NUM! when the input is less than 1.

Examples

title: "Boundary value"
formula: "=ACOSH(1)"
expected: 0

title: "Inverse hyperbolic cosine of ten"
formula: "=ACOSH(10)"
expected: 2.993222846126381

related:
  - COSH
  - ASINH
  - ATANH
faq:
  - q: "When does ACOSH return #NUM!?"
    a: "ACOSH requires input >= 1; values below 1 return #NUM!."

[formualizer-docgen:schema:start] Name: ACOSH Type: AcoshFn Min args: 1 Max args: 1 Variadic: false Signature: ACOSH(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AcotFn

Returns the angle in radians whose cotangent is the input value.

ACOT maps real inputs to principal angles in (0, PI()).

Remarks

• Domain: accepts any real number, including 0.
• Radians: output is in (0, PI()), with ACOT(0) = PI()/2.
• Errors: no function-specific domain errors are produced.

Examples

title: "Arccotangent of one"
formula: "=ACOT(1)"
expected: 0.7853981633974483

title: "Arccotangent of negative one"
formula: "=ACOT(-1)"
expected: 2.356194490192345

related:
  - ATAN
  - ATAN2
  - COT
faq:
  - q: "What is ACOT(0)?"
    a: "ACOT(0) is PI()/2 in the principal-value branch used here."

[formualizer-docgen:schema:start] Name: ACOT Type: AcotFn Min args: 1 Max args: 1 Variadic: false Signature: ACOT(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AsinFn

Returns the angle in radians whose sine is the input value.

Use ASIN to recover an angle from a normalized ratio.

Remarks

• Domain: input must be between -1 and 1, inclusive.
• Radians: output is in the range [-PI()/2, PI()/2].
• Errors: returns #NUM! when the input is outside the valid domain.

Examples

title: "Arcsine of one half"
formula: "=ASIN(0.5)"
expected: 0.5235987755982989

title: "Lower boundary"
formula: "=ASIN(-1)"
expected: -1.5707963267948966

related:
  - SIN
  - ACOS
  - ATAN
faq:
  - q: "When does ASIN return #NUM!?"
    a: "ASIN returns #NUM! when the input is outside the closed interval [-1, 1]."

[formualizer-docgen:schema:start] Name: ASIN Type: AsinFn Min args: 1 Max args: 1 Variadic: false Signature: ASIN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AsinhFn

Returns the inverse hyperbolic sine of a number.

ASINH is the inverse of SINH over all real inputs.

Remarks

• Domain: accepts any real number.
• Radians: this function is hyperbolic, so the output is not an angle in radians.
• Errors: no function-specific domain errors are produced.

Examples

title: "Inverse hyperbolic sine of one"
formula: "=ASINH(1)"
expected: 0.881373587019543

title: "Inverse hyperbolic sine of negative two"
formula: "=ASINH(-2)"
expected: -1.4436354751788103

related:
  - SINH
  - ACOSH
  - ATANH
faq:
  - q: "Does ASINH have restricted input domain?"
    a: "No. ASINH accepts any real-valued input."

[formualizer-docgen:schema:start] Name: ASINH Type: AsinhFn Min args: 1 Max args: 1 Variadic: false Signature: ASINH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for Atan2Fn

Returns the arctangent of y/x, preserving quadrant information.

Remarks

• Formualizer uses Excel-style argument order: ATAN2(x_num, y_num).
• Returns #DIV/0! when both arguments are zero.

Examples

title: "First quadrant angle"
formula: "=ATAN2(1,1)"
expected: 0.7853981633974483

title: "Undefined angle at origin"
formula: "=ATAN2(0,0)"
expected: "#DIV/0!"

related:
  - ATAN
  - ACOT
  - RADIANS
faq:
  - q: "Why does ATAN2 return #DIV/0! at (0,0)?"
    a: "The origin has no defined direction angle, so ATAN2 reports #DIV/0!."

[formualizer-docgen:schema:start] Name: ATAN2 Type: Atan2Fn Min args: 2 Max args: 2 Variadic: false Signature: ATAN2(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AtanFn

Returns the angle in radians whose tangent is the input value.

ATAN is useful for recovering a slope angle from a ratio.

Remarks

• Domain: accepts any real number.
• Radians: output is in the range (-PI()/2, PI()/2).
• Errors: no function-specific domain errors are produced.

Examples

title: "Arctangent of one"
formula: "=ATAN(1)"
expected: 0.7853981633974483

title: "Negative slope angle"
formula: "=ATAN(-1)"
expected: -0.7853981633974483

related:
  - TAN
  - ATAN2
  - ACOT
faq:
  - q: "Does ATAN ever return #NUM! for large values?"
    a: "No. ATAN accepts any real input and asymptotically approaches +/-PI()/2."

[formualizer-docgen:schema:start] Name: ATAN Type: AtanFn Min args: 1 Max args: 1 Variadic: false Signature: ATAN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for AtanhFn

Returns the inverse hyperbolic tangent of a number.

ATANH is the inverse of TANH on the open interval (-1, 1).

Remarks

• Domain: input must be strictly between -1 and 1.
• Radians: this function is hyperbolic, so the output is not an angle in radians.
• Errors: returns #NUM! when the input is <= -1 or >= 1.

Examples

title: "Inverse hyperbolic tangent of one half"
formula: "=ATANH(0.5)"
expected: 0.5493061443340548

title: "Domain boundary error"
formula: "=ATANH(1)"
expected: "#NUM!"

related:
  - TANH
  - ATAN
  - ASINH
faq:
  - q: "Which inputs are invalid for ATANH?"
    a: "ATANH is only defined on (-1, 1); endpoints and outside values return #NUM!."

[formualizer-docgen:schema:start] Name: ATANH Type: AtanhFn Min args: 1 Max args: 1 Variadic: false Signature: ATANH(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CosFn

Returns the cosine of an angle in radians.

Remarks

• Input must be in radians.
• Supports elementwise evaluation for array inputs.

Examples

title: "Cosine at zero"
formula: "=COS(0)"
expected: 1

title: "Cosine at PI"
formula: "=COS(PI())"
expected: -1

related:
  - SIN
  - TAN
  - PI
faq:
  - q: "Why can COS look wrong for degree values like 60?"
    a: "COS interprets 60 as radians, not degrees; use COS(RADIANS(60))."

[formualizer-docgen:schema:start] Name: COS Type: CosFn Min args: 1 Max args: 1 Variadic: false Signature: COS(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CoshFn

Returns the hyperbolic cosine of a number.

COSH computes (e^x + e^-x) / 2.

Remarks

• Domain: accepts any real number.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: no function-specific domain errors are produced.

Examples

title: "Hyperbolic cosine at zero"
formula: "=COSH(0)"
expected: 1

title: "Hyperbolic cosine at one"
formula: "=COSH(1)"
expected: 1.5430806348152437

related:
  - ACOSH
  - SINH
  - TANH
faq:
  - q: "Can COSH produce #NUM! domain errors?"
    a: "No function-specific domain errors are enforced for real inputs."

[formualizer-docgen:schema:start] Name: COSH Type: CoshFn Min args: 1 Max args: 1 Variadic: false Signature: COSH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CotFn

Returns the cotangent of an angle, defined as 1 / TAN(angle).

COT is useful when working with reciprocal tangent relationships.

Remarks

• Domain: valid for all real angles except where TAN(angle) = 0.
• Radians: input is interpreted in radians.
• Errors: returns #DIV/0! at or near integer multiples of PI().

Examples

title: "Cotangent at PI over 4"
formula: "=COT(PI()/4)"
expected: 1

title: "Undefined cotangent at zero"
formula: "=COT(0)"
expected: "#DIV/0!"

related:
  - TAN
  - SEC
  - CSC
faq:
  - q: "Why is COT undefined at integer multiples of PI()?"
    a: "At those points TAN is zero, so 1/TAN triggers a #DIV/0! condition."

[formualizer-docgen:schema:start] Name: COT Type: CotFn Min args: 1 Max args: 1 Variadic: false Signature: COT(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CothFn

Returns the hyperbolic cotangent of a number, defined as COSH(x) / SINH(x).

COTH is the reciprocal of TANH where defined.

Remarks

• Domain: valid for all real numbers except 0.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: returns #DIV/0! when SINH(x) is zero (at x = 0).

Examples

title: "Hyperbolic cotangent at one"
formula: "=COTH(1)"
expected: 1.3130352854993312

title: "Division by zero at origin"
formula: "=COTH(0)"
expected: "#DIV/0!"

related:
  - TANH
  - CSCH
  - SECH
faq:
  - q: "Why is COTH undefined at zero?"
    a: "COTH divides by SINH(x), and SINH(0) is zero, so #DIV/0! is returned."

[formualizer-docgen:schema:start] Name: COTH Type: CothFn Min args: 1 Max args: 1 Variadic: false Signature: COTH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CscFn

Returns the cosecant of an angle, defined as 1 / SIN(angle).

Use CSC for reciprocal-sine calculations in radian-based formulas.

Remarks

• Domain: valid for all real angles except where SIN(angle) = 0.
• Radians: input is interpreted in radians.
• Errors: returns #DIV/0! at or near integer multiples of PI().

Examples

title: "Cosecant at PI over 2"
formula: "=CSC(PI()/2)"
expected: 1

title: "Zero sine denominator"
formula: "=CSC(0)"
expected: "#DIV/0!"

related:
  - SIN
  - COT
  - SEC
faq:
  - q: "When does CSC return #DIV/0!?"
    a: "CSC returns #DIV/0! when SIN(angle) is effectively zero."

[formualizer-docgen:schema:start] Name: CSC Type: CscFn Min args: 1 Max args: 1 Variadic: false Signature: CSC(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CschFn

Returns the hyperbolic cosecant of a number, defined as 1 / SINH(x).

CSCH is the reciprocal of SINH where defined.

Remarks

• Domain: valid for all real numbers except 0.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: returns #DIV/0! when SINH(x) is zero (at x = 0).

Examples

title: "Hyperbolic cosecant at one"
formula: "=CSCH(1)"
expected: 0.8509181282393216

title: "Division by zero at origin"
formula: "=CSCH(0)"
expected: "#DIV/0!"

related:
  - SINH
  - COTH
  - SECH
faq:
  - q: "When does CSCH return #DIV/0!?"
    a: "CSCH returns #DIV/0! when SINH(x) is zero, which occurs at x = 0."

[formualizer-docgen:schema:start] Name: CSCH Type: CschFn Min args: 1 Max args: 1 Variadic: false Signature: CSCH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for DegreesFn

Converts an angle from radians to degrees.

Remarks

• Useful when converting the output of inverse trig functions.
• Output is radians * 180 / PI().

Examples

title: "Convert PI radians"
formula: "=DEGREES(PI())"
expected: 180

title: "Convert PI/2 radians"
formula: "=DEGREES(PI()/2)"
expected: 90

related:
  - RADIANS
  - ATAN
  - ACOS
faq:
  - q: "Does DEGREES change the angle value or just units?"
    a: "It converts units only, multiplying radians by 180/PI()."

[formualizer-docgen:schema:start] Name: DEGREES Type: DegreesFn Min args: 1 Max args: 1 Variadic: false Signature: DEGREES(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PiFn

Returns the mathematical constant π.

Remarks

• PI() takes no arguments.
• Commonly used with trig and geometry formulas.

Examples

title: "Pi constant"
formula: "=PI()"
expected: 3.141592653589793

title: "Circle circumference with radius 2"
formula: "=2*PI()*2"
expected: 12.566370614359172

related:
  - RADIANS
  - DEGREES
  - SIN
faq:
  - q: "Can PI take arguments?"
    a: "No. PI() has arity zero and always returns the same constant."

[formualizer-docgen:schema:start] Name: PI Type: PiFn Min args: 0 Max args: 0 Variadic: false Signature: PI() Arg schema: [] Caps: PURE [formualizer-docgen:schema:end]

impl Function for RadiansFn

Converts an angle from degrees to radians.

Remarks

• Use this before trigonometric functions when your source angle is in degrees.
• Output is degrees * PI() / 180.

Examples

title: "Convert 180°"
formula: "=RADIANS(180)"
expected: 3.141592653589793

title: "Convert 45°"
formula: "=RADIANS(45)"
expected: 0.7853981633974483

related:
  - DEGREES
  - SIN
  - COS
faq:
  - q: "When should I wrap angles with RADIANS?"
    a: "Use it whenever your source angle is in degrees and the downstream trig function expects radians."

[formualizer-docgen:schema:start] Name: RADIANS Type: RadiansFn Min args: 1 Max args: 1 Variadic: false Signature: RADIANS(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SecFn

Returns the secant of an angle, defined as 1 / COS(angle).

Use SEC for reciprocal-cosine calculations in radian-based formulas.

Remarks

• Domain: valid for all real angles except where COS(angle) = 0.
• Radians: input is interpreted in radians.
• Errors: returns #DIV/0! near odd multiples of PI()/2.

Examples

title: "Secant at zero"
formula: "=SEC(0)"
expected: 1

title: "Singularity at PI over 2"
formula: "=SEC(PI()/2)"
expected: "#DIV/0!"

related:
  - COS
  - COT
  - CSC
faq:
  - q: "When does SEC return #DIV/0!?"
    a: "SEC returns #DIV/0! when COS(angle) is effectively zero."

[formualizer-docgen:schema:start] Name: SEC Type: SecFn Min args: 1 Max args: 1 Variadic: false Signature: SEC(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SechFn

Returns the hyperbolic secant of a number, defined as 1 / COSH(x).

SECH produces values in (0, 1] for real inputs.

Remarks

• Domain: accepts any real number.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: no function-specific domain errors are produced.

Examples

title: "Hyperbolic secant at zero"
formula: "=SECH(0)"
expected: 1

title: "Hyperbolic secant at two"
formula: "=SECH(2)"
expected: 0.2658022288340797

related:
  - COSH
  - CSCH
  - COTH
faq:
  - q: "Can SECH be negative for real inputs?"
    a: "No. For real numbers, SECH = 1/COSH is always positive."

[formualizer-docgen:schema:start] Name: SECH Type: SechFn Min args: 1 Max args: 1 Variadic: false Signature: SECH(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SinFn

Returns the sine of an angle in radians.

Remarks

• Input is interpreted as radians, not degrees.
• Supports scalar and array-style elementwise evaluation.

Examples

title: "Sine of PI/2"
formula: "=SIN(PI()/2)"
expected: 1

title: "Sine from a cell value"
grid:
  A1: 0
formula: "=SIN(A1)"
expected: 0

related:
  - COS
  - TAN
  - RADIANS
faq:
  - q: "Does SIN expect degrees or radians?"
    a: "SIN expects radians; convert degree inputs first with RADIANS."

[formualizer-docgen:schema:start] Name: SIN Type: SinFn Min args: 1 Max args: 1 Variadic: false Signature: SIN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SinhFn

Returns the hyperbolic sine of a number.

SINH computes (e^x - e^-x) / 2.

Remarks

• Domain: accepts any real number.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: no function-specific domain errors are produced.

Examples

title: "Hyperbolic sine at zero"
formula: "=SINH(0)"
expected: 0

title: "Hyperbolic sine at one"
formula: "=SINH(1)"
expected: 1.1752011936438014

related:
  - ASINH
  - COSH
  - TANH
faq:
  - q: "Is SINH expecting radians like SIN?"
    a: "No. SINH is hyperbolic and treats input as a pure numeric value, not an angle unit."

[formualizer-docgen:schema:start] Name: SINH Type: SinhFn Min args: 1 Max args: 1 Variadic: false Signature: SINH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for TanFn

Returns the tangent of an angle in radians.

Remarks

• Input is interpreted as radians.
• Near odd multiples of PI()/2, results can become very large.

Examples

title: "Tangent at PI/4"
formula: "=TAN(PI()/4)"
expected: 1

title: "Tangent at zero"
formula: "=TAN(0)"
expected: 0

related:
  - SIN
  - COS
  - ATAN
faq:
  - q: "Why does TAN explode near PI()/2?"
    a: "Because COS approaches zero there, TAN can become extremely large in magnitude."

[formualizer-docgen:schema:start] Name: TAN Type: TanFn Min args: 1 Max args: 1 Variadic: false Signature: TAN(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for TanhFn

Returns the hyperbolic tangent of a number.

TANH computes SINH(x) / COSH(x).

Remarks

• Domain: accepts any real number.
• Radians: this function is hyperbolic, so the input is not treated as an angle in radians.
• Errors: no function-specific domain errors are produced.

Examples

title: "Hyperbolic tangent at zero"
formula: "=TANH(0)"
expected: 0

title: "Hyperbolic tangent at two"
formula: "=TANH(2)"
expected: 0.9640275800758169

related:
  - ATANH
  - SINH
  - COSH
faq:
  - q: "What output range should TANH produce?"
    a: "For real inputs, TANH stays strictly between -1 and 1."

[formualizer-docgen:schema:start] Name: TANH Type: TanhFn Min args: 1 Max args: 1 Variadic: false Signature: TANH(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, ELEMENTWISE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for RandBetweenFn

Returns a random integer between two inclusive bounds.

RANDBETWEEN evaluates both bounds, then samples an integer in [low, high].

Remarks

• Bounds are coerced to numbers and truncated to integers.
• If high < low, the function returns #NUM!.
• The function is volatile and may return a different integer each recalculation.

Examples

title: "Value always falls inside the requested interval"
formula: "=LET(n, RANDBETWEEN(1, 3), AND(n>=1, n<=3, INT(n)=n))"
expected: true

title: "Equal bounds produce a fixed value"
formula: "=RANDBETWEEN(7, 7)"
expected: 7

title: "Upper bound below lower bound is invalid"
formula: "=RANDBETWEEN(5, 1)"
expected: "#NUM!"

related:
  - RAND
  - INT
  - LET
faq:
  - q: "Are both bounds included in RANDBETWEEN?"
    a: "Yes. RANDBETWEEN samples an integer in the closed interval [low, high]."
  - q: "What happens with decimal bounds like RANDBETWEEN(1.9, 4.2)?"
    a: "Bounds are truncated to integers before sampling, so this behaves like RANDBETWEEN(1, 4)."
  - q: "Is RANDBETWEEN deterministic?"
    a: "It is volatile, so results can change on recalculation, though a single evaluation context uses seeded randomness for reproducible execution."

[formualizer-docgen:schema:start] Name: RANDBETWEEN Type: RandBetweenFn Min args: 2 Max args: 2 Variadic: false Signature: RANDBETWEEN(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: VOLATILE [formualizer-docgen:schema:end]

impl Function for RandFn

Returns a uniformly distributed pseudo-random number in the interval [0, 1).

RAND is volatile and recalculates whenever dependent formulas recalculate.

Remarks

• The result is always greater than or equal to 0 and strictly less than 1.
• Because the function is volatile, repeated evaluations can return different values.
• The engine seeds randomness per evaluation context for reproducible execution flows.

Examples

title: "RAND stays within bounds"
formula: "=LET(n, RAND(), AND(n>=0, n<1))"
expected: true

title: "Derived integer bucket from RAND"
formula: "=LET(n, INT(RAND()*10), AND(n>=0, n<=9))"
expected: true

related:
  - RANDBETWEEN
  - LET
  - INT
faq:
  - q: "Can RAND return the same value on every recalculation?"
    a: "Not by default. RAND is volatile, so recalculation can produce a different sample each time."
  - q: "If RAND is used twice in one formula, do both uses share one sample?"
    a: "Only if you bind it once (for example with LET). Two separate RAND calls are two separate draws."
  - q: "Why does RAND look deterministic in some engine runs?"
    a: "Randomness is seeded per evaluation context, which keeps a run reproducible while still treating RAND as volatile across recalculations."

[formualizer-docgen:schema:start] Name: RAND Type: RandFn Min args: 0 Max args: 0 Variadic: false Signature: RAND() Arg schema: [] Caps: VOLATILE [formualizer-docgen:schema:end]

impl Function for IndexFn

Returns the value or reference at a 1-based row and column within an array or range.

INDEX can operate on both references and array literals. When the first argument is a reference, this implementation resolves a referenced cell and materializes its value in value context.

Remarks

• Indexing is 1-based for both row_num and column_num.
• If column_num is omitted for a 1D array, row_num selects the position in that vector.
• row_num <= 0, column_num <= 0, or out-of-bounds indexes return #REF!.
• Non-numeric index arguments return #VALUE!.

Examples

title: "Pick a value from a 2D table"
grid:
  A1: "Item"
  B1: "Price"
  A2: "Pen"
  B2: 2.5
  A3: "Book"
  B3: 8
formula: '=INDEX(A1:B3,3,2)'
expected: 8

title: "Index into a 1D vector"
grid:
  A1: "Q1"
  A2: "Q2"
  A3: "Q3"
formula: '=INDEX(A1:A3,2)'
expected: "Q2"

related:
  - MATCH
  - XLOOKUP
  - OFFSET
faq:
  - q: "How does INDEX behave when column_num is omitted?"
    a: "For 1D arrays, row_num selects the position along that vector; for 2D arrays, omitted column_num defaults to the first column."
  - q: "Which errors indicate bad indexes?"
    a: "Non-numeric index arguments return #VALUE!, while 0/negative or out-of-bounds indexes return #REF!."

[formualizer-docgen:schema:start] Name: INDEX Type: IndexFn Min args: 2 Max args: 3 Variadic: false Signature: INDEX(arg1: any@range, arg2: number@scalar, arg3?: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false} Caps: PURE, RETURNS_REFERENCE [formualizer-docgen:schema:end]

impl Function for IndirectFn

Converts text into a reference and returns the referenced value or range.

INDIRECT lets formulas build references dynamically from strings such as "A1" or "Sheet2!B3:C5".

Remarks

• a1_style defaults to TRUE (A1 style parsing).
• a1_style=FALSE (R1C1 parsing) is currently not implemented and returns #N/IMPL!.
• Invalid or unresolved references return #REF!.
• The function is volatile because target references can change without direct dependency links.

Examples

title: "Resolve a direct cell reference"
grid:
  A1: 99
formula: '=INDIRECT("A1")'
expected: 99

title: "Resolve a range and aggregate it"
grid:
  A1: 5
  A2: 7
  A3: 9
formula: '=SUM(INDIRECT("A1:A3"))'
expected: 21

related:
  - ADDRESS
  - INDEX
  - OFFSET
faq:
  - q: "What happens if a1_style is FALSE?"
    a: "R1C1 parsing is not implemented here yet, so INDIRECT(...,FALSE) returns #N/IMPL!."
  - q: "How are bad reference strings reported?"
    a: "If the text cannot be parsed or resolved to a valid reference, INDIRECT returns #REF!."

[formualizer-docgen:schema:start] Name: INDIRECT Type: IndirectFn Min args: 1 Max args: 2 Variadic: false Signature: INDIRECT(arg1: text@scalar, arg2?: logical|number@scalar) Arg schema: arg1{kinds=text,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=logical|number,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE, VOLATILE, RETURNS_REFERENCE, DYNAMIC_DEPENDENCY [formualizer-docgen:schema:end]

impl Function for OffsetFn

Returns a reference shifted from a starting reference by rows and columns.

OFFSET is volatile and returns a reference that can point to a single cell or a resized range, depending on the optional height and width arguments.

Remarks

• rows and cols shift from the top-left of reference.
• If omitted, height and width default to the original reference size.
• Non-positive target coordinates or dimensions return #REF!.
• Non-numeric offset/size inputs return #VALUE!.
• In value context, a 1x1 result returns a scalar; larger results spill as an array.

Examples

title: "Move one row down and one column right"
grid:
  A1: 10
  B2: 42
formula: '=OFFSET(A1,1,1)'
expected: 42

title: "Offset and resize a range"
grid:
  A1: 1
  A2: 2
  A3: 3
  B1: 4
  B2: 5
  B3: 6
formula: '=SUM(OFFSET(A1,1,0,2,2))'
expected: 16

related:
  - INDEX
  - INDIRECT
  - ADDRESS
faq:
  - q: "What defaults are used when height and width are omitted?"
    a: "OFFSET keeps the source reference size, then applies the row/column shift to that same-sized block."
  - q: "When does OFFSET return #REF!?"
    a: "It returns #REF! if the shifted start goes to row/column <= 0 or if requested height/width are non-positive."

[formualizer-docgen:schema:start] Name: OFFSET Type: OffsetFn Min args: 3 Max args: 5 Variadic: false Signature: OFFSET(arg1: range@range, arg2: number@scalar, arg3: number@scalar, arg4?: number@scalar, arg5?: number@scalar) Arg schema: arg1{kinds=range,required=true,shape=range,by_ref=true,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg4{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false}; arg5{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberStrict,max=None,repeating=None,default=false} Caps: PURE, VOLATILE, RETURNS_REFERENCE, DYNAMIC_DEPENDENCY [formualizer-docgen:schema:end]

impl Function for AvedevFn

[formualizer-docgen:schema:start] Name: AVEDEV Type: AvedevFn Min args: 1 Max args: variadic Variadic: true Signature: AVEDEV(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for BetaDistFn

[formualizer-docgen:schema:start] Name: BETA.DIST Type: BetaDistFn Min args: 4 Max args: variadic Variadic: true Signature: BETA.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar, arg6…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg6{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for BinomDistFn

[formualizer-docgen:schema:start] Name: BINOM.DIST Type: BinomDistFn Min args: 4 Max args: 4 Variadic: false Signature: BINOM.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ChisqDistFn

[formualizer-docgen:schema:start] Name: CHISQ.DIST Type: ChisqDistFn Min args: 3 Max args: 3 Variadic: false Signature: CHISQ.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ChisqInvFn

[formualizer-docgen:schema:start] Name: CHISQ.INV Type: ChisqInvFn Min args: 2 Max args: 2 Variadic: false Signature: CHISQ.INV(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ChisqTestFn

[formualizer-docgen:schema:start] Name: CHISQ.TEST Type: ChisqTestFn Min args: 2 Max args: 2 Variadic: false Signature: CHISQ.TEST(arg1: number@range, arg2: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ConfidenceNormFn

[formualizer-docgen:schema:start] Name: CONFIDENCE.NORM Type: ConfidenceNormFn Min args: 3 Max args: 3 Variadic: false Signature: CONFIDENCE.NORM(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ConfidenceTFn

[formualizer-docgen:schema:start] Name: CONFIDENCE.T Type: ConfidenceTFn Min args: 3 Max args: 3 Variadic: false Signature: CONFIDENCE.T(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CorrelFn

[formualizer-docgen:schema:start] Name: CORREL Type: CorrelFn Min args: 2 Max args: 1 Variadic: false Signature: CORREL(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CovariancePFn

[formualizer-docgen:schema:start] Name: COVARIANCE.P Type: CovariancePFn Min args: 2 Max args: 1 Variadic: false Signature: COVARIANCE.P(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for CovarianceSFn

[formualizer-docgen:schema:start] Name: COVARIANCE.S Type: CovarianceSFn Min args: 2 Max args: 1 Variadic: false Signature: COVARIANCE.S(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for DevsqFn

[formualizer-docgen:schema:start] Name: DEVSQ Type: DevsqFn Min args: 1 Max args: variadic Variadic: true Signature: DEVSQ(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for ExponDistFn

[formualizer-docgen:schema:start] Name: EXPON.DIST Type: ExponDistFn Min args: 3 Max args: 3 Variadic: false Signature: EXPON.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FDistFn

[formualizer-docgen:schema:start] Name: F.DIST Type: FDistFn Min args: 4 Max args: 4 Variadic: false Signature: F.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FInvFn

[formualizer-docgen:schema:start] Name: F.INV Type: FInvFn Min args: 3 Max args: 3 Variadic: false Signature: F.INV(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FTestFn

[formualizer-docgen:schema:start] Name: F.TEST Type: FTestFn Min args: 2 Max args: 2 Variadic: false Signature: F.TEST(arg1: number@range, arg2: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FisherFn

[formualizer-docgen:schema:start] Name: FISHER Type: FisherFn Min args: 1 Max args: 1 Variadic: false Signature: FISHER(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for FisherInvFn

[formualizer-docgen:schema:start] Name: FISHERINV Type: FisherInvFn Min args: 1 Max args: 1 Variadic: false Signature: FISHERINV(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for ForecastLinearFn

[formualizer-docgen:schema:start] Name: FORECAST.LINEAR Type: ForecastLinearFn Min args: 3 Max args: 1 Variadic: false Signature: FORECAST.LINEAR(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for FrequencyFn

[formualizer-docgen:schema:start] Name: FREQUENCY Type: FrequencyFn Min args: 2 Max args: 1 Variadic: false Signature: FREQUENCY(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for GammaDistFn

[formualizer-docgen:schema:start] Name: GAMMA.DIST Type: GammaDistFn Min args: 4 Max args: 4 Variadic: false Signature: GAMMA.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for GaussFn

[formualizer-docgen:schema:start] Name: GAUSS Type: GaussFn Min args: 1 Max args: 1 Variadic: false Signature: GAUSS(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for GeomeanFn

[formualizer-docgen:schema:start] Name: GEOMEAN Type: GeomeanFn Min args: 1 Max args: variadic Variadic: true Signature: GEOMEAN(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for GrowthFn

[formualizer-docgen:schema:start] Name: GROWTH Type: GrowthFn Min args: 1 Max args: variadic Variadic: true Signature: GROWTH(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for HarmeanFn

[formualizer-docgen:schema:start] Name: HARMEAN Type: HarmeanFn Min args: 1 Max args: variadic Variadic: true Signature: HARMEAN(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for HypgeomDistFn

[formualizer-docgen:schema:start] Name: HYPGEOM.DIST Type: HypgeomDistFn Min args: 5 Max args: 5 Variadic: false Signature: HYPGEOM.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar, arg5: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg5{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for InterceptFn

[formualizer-docgen:schema:start] Name: INTERCEPT Type: InterceptFn Min args: 2 Max args: 1 Variadic: false Signature: INTERCEPT(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for KurtFn

[formualizer-docgen:schema:start] Name: KURT Type: KurtFn Min args: 1 Max args: variadic Variadic: true Signature: KURT(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for LARGE

[formualizer-docgen:schema:start] Name: LARGE Type: LARGE Min args: 2 Max args: variadic Variadic: true Signature: LARGE(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for LinestFn

[formualizer-docgen:schema:start] Name: LINEST Type: LinestFn Min args: 1 Max args: variadic Variadic: true Signature: LINEST(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for LogestFn

[formualizer-docgen:schema:start] Name: LOGEST Type: LogestFn Min args: 1 Max args: variadic Variadic: true Signature: LOGEST(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for LognormDistFn

[formualizer-docgen:schema:start] Name: LOGNORM.DIST Type: LognormDistFn Min args: 4 Max args: 4 Variadic: false Signature: LOGNORM.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LognormInvFn

[formualizer-docgen:schema:start] Name: LOGNORM.INV Type: LognormInvFn Min args: 3 Max args: 3 Variadic: false Signature: LOGNORM.INV(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MEDIAN

[formualizer-docgen:schema:start] Name: MEDIAN Type: MEDIAN Min args: 1 Max args: variadic Variadic: true Signature: MEDIAN(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for MaxIfsFn

[formualizer-docgen:schema:start] Name: MAXIFS Type: MaxIfsFn Min args: 3 Max args: variadic Variadic: true Signature: MAXIFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for MinIfsFn

[formualizer-docgen:schema:start] Name: MINIFS Type: MinIfsFn Min args: 3 Max args: variadic Variadic: true Signature: MINIFS(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE, REDUCTION [formualizer-docgen:schema:end]

impl Function for ModeMultiFn

[formualizer-docgen:schema:start] Name: MODE.MULT Type: ModeMultiFn Min args: 1 Max args: variadic Variadic: true Signature: MODE.MULT(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for ModeSingleFn

[formualizer-docgen:schema:start] Name: MODE.SNGL Type: ModeSingleFn Min args: 1 Max args: variadic Variadic: true Signature: MODE.SNGL(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for NegbinomDistFn

[formualizer-docgen:schema:start] Name: NEGBINOM.DIST Type: NegbinomDistFn Min args: 4 Max args: 4 Variadic: false Signature: NEGBINOM.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NormDistFn

[formualizer-docgen:schema:start] Name: NORM.DIST Type: NormDistFn Min args: 4 Max args: 4 Variadic: false Signature: NORM.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NormInvFn

[formualizer-docgen:schema:start] Name: NORM.INV Type: NormInvFn Min args: 3 Max args: 3 Variadic: false Signature: NORM.INV(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NormSDistFn

[formualizer-docgen:schema:start] Name: NORM.S.DIST Type: NormSDistFn Min args: 2 Max args: 2 Variadic: false Signature: NORM.S.DIST(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for NormSInvFn

[formualizer-docgen:schema:start] Name: NORM.S.INV Type: NormSInvFn Min args: 1 Max args: 1 Variadic: false Signature: NORM.S.INV(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PearsonFn

[formualizer-docgen:schema:start] Name: PEARSON Type: PearsonFn Min args: 2 Max args: 1 Variadic: false Signature: PEARSON(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PercentRankExcFn

[formualizer-docgen:schema:start] Name: PERCENTRANK.EXC Type: PercentRankExcFn Min args: 2 Max args: variadic Variadic: true Signature: PERCENTRANK.EXC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PercentRankIncFn

[formualizer-docgen:schema:start] Name: PERCENTRANK.INC Type: PercentRankIncFn Min args: 2 Max args: variadic Variadic: true Signature: PERCENTRANK.INC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PercentileExc

[formualizer-docgen:schema:start] Name: PERCENTILE.EXC Type: PercentileExc Min args: 2 Max args: variadic Variadic: true Signature: PERCENTILE.EXC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PercentileInc

[formualizer-docgen:schema:start] Name: PERCENTILE.INC Type: PercentileInc Min args: 2 Max args: variadic Variadic: true Signature: PERCENTILE.INC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for PhiFn

[formualizer-docgen:schema:start] Name: PHI Type: PhiFn Min args: 1 Max args: 1 Variadic: false Signature: PHI(arg1: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for PoissonDistFn

[formualizer-docgen:schema:start] Name: POISSON.DIST Type: PoissonDistFn Min args: 3 Max args: 3 Variadic: false Signature: POISSON.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ProductFn

[formualizer-docgen:schema:start] Name: PRODUCT Type: ProductFn Min args: 1 Max args: variadic Variadic: true Signature: PRODUCT(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for QuartileExc

[formualizer-docgen:schema:start] Name: QUARTILE.EXC Type: QuartileExc Min args: 2 Max args: variadic Variadic: true Signature: QUARTILE.EXC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for QuartileInc

[formualizer-docgen:schema:start] Name: QUARTILE.INC Type: QuartileInc Min args: 2 Max args: variadic Variadic: true Signature: QUARTILE.INC(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for RankAvgFn

[formualizer-docgen:schema:start] Name: RANK.AVG Type: RankAvgFn Min args: 2 Max args: variadic Variadic: true Signature: RANK.AVG(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for RankEqFn

[formualizer-docgen:schema:start] Name: RANK.EQ Type: RankEqFn Min args: 2 Max args: variadic Variadic: true Signature: RANK.EQ(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for RsqFn

[formualizer-docgen:schema:start] Name: RSQ Type: RsqFn Min args: 2 Max args: 1 Variadic: false Signature: RSQ(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SMALL

[formualizer-docgen:schema:start] Name: SMALL Type: SMALL Min args: 2 Max args: variadic Variadic: true Signature: SMALL(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SkewFn

[formualizer-docgen:schema:start] Name: SKEW Type: SkewFn Min args: 1 Max args: variadic Variadic: true Signature: SKEW(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for SlopeFn

[formualizer-docgen:schema:start] Name: SLOPE Type: SlopeFn Min args: 2 Max args: 1 Variadic: false Signature: SLOPE(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for StandardizeFn

[formualizer-docgen:schema:start] Name: STANDARDIZE Type: StandardizeFn Min args: 3 Max args: 3 Variadic: false Signature: STANDARDIZE(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for StdevPop

[formualizer-docgen:schema:start] Name: STDEV.P Type: StdevPop Min args: 1 Max args: variadic Variadic: true Signature: STDEV.P(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for StdevSample

[formualizer-docgen:schema:start] Name: STDEV.S Type: StdevSample Min args: 1 Max args: variadic Variadic: true Signature: STDEV.S(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for SteyxFn

[formualizer-docgen:schema:start] Name: STEYX Type: SteyxFn Min args: 2 Max args: 1 Variadic: false Signature: STEYX(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for TDist2TFn

[formualizer-docgen:schema:start] Name: T.DIST.2T Type: TDist2TFn Min args: 2 Max args: 2 Variadic: false Signature: T.DIST.2T(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TDistFn

[formualizer-docgen:schema:start] Name: T.DIST Type: TDistFn Min args: 3 Max args: 3 Variadic: false Signature: T.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TInv2TFn

[formualizer-docgen:schema:start] Name: T.INV.2T Type: TInv2TFn Min args: 2 Max args: 2 Variadic: false Signature: T.INV.2T(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TInvFn

[formualizer-docgen:schema:start] Name: T.INV Type: TInvFn Min args: 2 Max args: 2 Variadic: false Signature: T.INV(arg1: number@scalar, arg2: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TTestFn

[formualizer-docgen:schema:start] Name: T.TEST Type: TTestFn Min args: 4 Max args: 4 Variadic: false Signature: T.TEST(arg1: number@range, arg2: number@range, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TrendFn

[formualizer-docgen:schema:start] Name: TREND Type: TrendFn Min args: 1 Max args: variadic Variadic: true Signature: TREND(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for TrimmeanFn

[formualizer-docgen:schema:start] Name: TRIMMEAN Type: TrimmeanFn Min args: 2 Max args: 1 Variadic: false Signature: TRIMMEAN(arg1: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY [formualizer-docgen:schema:end]

impl Function for VarPop

[formualizer-docgen:schema:start] Name: VAR.P Type: VarPop Min args: 1 Max args: variadic Variadic: true Signature: VAR.P(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for VarSample

[formualizer-docgen:schema:start] Name: VAR.S Type: VarSample Min args: 1 Max args: variadic Variadic: true Signature: VAR.S(arg1…: number@range) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE, REDUCTION, NUMERIC_ONLY, STREAM_OK [formualizer-docgen:schema:end]

impl Function for WeibullDistFn

[formualizer-docgen:schema:start] Name: WEIBULL.DIST Type: WeibullDistFn Min args: 4 Max args: 4 Variadic: false Signature: WEIBULL.DIST(arg1: number@scalar, arg2: number@scalar, arg3: number@scalar, arg4: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg4{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ZTestFn

[formualizer-docgen:schema:start] Name: Z.TEST Type: ZTestFn Min args: 2 Max args: variadic Variadic: true Signature: Z.TEST(arg1: number@range, arg2: number@scalar, arg3…: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=range,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg3{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ArrayToTextFn

Converts an array or range into a text representation.

ARRAYTOTEXT(array, [format]) supports concise (0) and strict (1) output styles.

Remarks

• Strict mode returns brace-delimited array syntax with row/column separators.
• Concise mode flattens all values into a comma-space list.
• Cells are converted using the same scalar text rules used by VALUETOTEXT.
• Errors in scalar-only input propagate immediately.

Examples

title: "Concise flattened output"
formula: '=ARRAYTOTEXT({1,2,3})'
expected: "1, 2, 3"

title: "Strict 2D representation"
formula: '=ARRAYTOTEXT({1,2;3,4}, 1)'
expected: "{1,2;3,4}"

related:
  - VALUETOTEXT
  - TEXTJOIN
  - TEXTSPLIT
faq:
  - q: "What changes when format is 1?"
    a: "Format 1 returns brace-delimited array syntax; format 0 flattens values into a comma-space list."

[formualizer-docgen:schema:start] Name: ARRAYTOTEXT Type: ArrayToTextFn Min args: 1 Max args: 2 Variadic: false Signature: ARRAYTOTEXT(arg1: any|range@range, arg2?: number@scalar) Arg schema: arg1{kinds=any|range,required=true,shape=range,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CharFn

Returns the character represented by a numeric code.

CHAR follows Excel-style Windows-1252 behavior for codes 1..255.

Remarks

• Input is truncated to an integer code.
• Valid code range is 1 through 255; outside this range returns #VALUE!.
• Codes in the Windows-1252 extension range (128-159) are mapped to Unicode equivalents.
• Errors are propagated unchanged.

Examples

title: "ASCII character"
formula: '=CHAR(65)'
expected: "A"

title: "Out-of-range code"
formula: '=CHAR(300)'
expected: "#VALUE!"

related:
  - CODE
  - UNICHAR
  - UNICODE
faq:
  - q: "Which character set does CHAR use for codes 128-159?"
    a: "It follows Excel-style Windows-1252 mappings, including extended symbols in that range."

[formualizer-docgen:schema:start] Name: CHAR Type: CharFn Min args: 1 Max args: 1 Variadic: false Signature: CHAR(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CleanFn

Removes non-printable ASCII control characters from text.

Remarks

• Characters with codes 0..31 are removed.
• Printable whitespace like regular spaces is preserved.
• Non-text inputs are coerced to text before cleaning.
• Errors are propagated unchanged.

Examples

title: "Strip control characters"
formula: '=CLEAN("A"&CHAR(10)&"B")'
expected: "AB"

title: "Printable spaces remain"
formula: '=CLEAN("A B")'
expected: "A B"

related:
  - TRIM
  - CHAR
  - SUBSTITUTE
faq:
  - q: "Does CLEAN remove normal spaces or only control characters?"
    a: "It removes only ASCII control characters (0-31); regular printable spaces remain."

[formualizer-docgen:schema:start] Name: CLEAN Type: CleanFn Min args: 1 Max args: 1 Variadic: false Signature: CLEAN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for CodeFn

Returns the numeric code of the first character in text.

CODE mirrors Excel behavior with Windows-1252 compatibility mappings.

Remarks

• Only the first character is inspected.
• Empty text returns #VALUE!.
• Text-like coercion is applied to non-text scalar inputs.
• Known Unicode characters in the Windows-1252 extension map back to their Excel codes.

Examples

title: "ASCII code"
formula: '=CODE("A")'
expected: 65

title: "Extended mapping"
formula: '=CODE(CHAR(128))'
expected: 128

related:
  - CHAR
  - UNICODE
  - UNICHAR
faq:
  - q: "What if the input text is empty?"
    a: "CODE returns #VALUE! because there is no first character to evaluate."

[formualizer-docgen:schema:start] Name: CODE Type: CodeFn Min args: 1 Max args: 1 Variadic: false Signature: CODE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ConcatFn

Concatenates multiple values into one text string.

Remarks

• Accepts one or more arguments.
• Blank values contribute an empty string.
• Numbers and booleans are coerced to text.
• Errors are propagated as soon as encountered.

Examples

title: "Join text pieces"
formula: '=CONCAT("Q", 1, "-", "2026")'
expected: "Q1-2026"

title: "Concatenate with blanks"
formula: '=CONCAT("A", "", "B")'
expected: "AB"

related:
  - CONCATENATE
  - TEXTJOIN
  - VALUE
faq:
  - q: "Do blank arguments add separators or characters?"
    a: "No. CONCAT appends each value directly, and blanks contribute an empty string."

[formualizer-docgen:schema:start] Name: CONCAT Type: ConcatFn Min args: 1 Max args: variadic Variadic: true Signature: CONCAT(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ConcatenateFn

Legacy alias for CONCAT that joins multiple values as text.

Remarks

• Semantics match CONCAT in this implementation.
• Blank values contribute an empty string.
• Numbers and booleans are coerced to text.
• Errors are propagated as soon as encountered.

Examples

title: "Legacy concatenate behavior"
formula: '=CONCATENATE("Jan", "-", 2026)'
expected: "Jan-2026"

title: "Boolean coercion"
formula: '=CONCATENATE("Flag:", TRUE)'
expected: "Flag:TRUE"

related:
  - CONCAT
  - TEXTJOIN
  - VALUE
faq:
  - q: "Is CONCATENATE behavior different from CONCAT here?"
    a: "No. In this engine CONCATENATE uses the same join semantics as CONCAT."

[formualizer-docgen:schema:start] Name: CONCATENATE Type: ConcatenateFn Min args: 1 Max args: variadic Variadic: true Signature: CONCATENATE(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for DollarFn

Formats a number as currency text.

Remarks

• Default decimal places is 2 when omitted.
• Negative values are rendered in parentheses, such as ($1,234.00).
• Uses comma group separators and dollar symbol.
• Input coercion failures or propagated errors return an error.

Examples

title: "Default currency formatting"
formula: '=DOLLAR(1234.5)'
expected: "$1,234.50"

title: "Negative value with zero decimals"
formula: '=DOLLAR(-999.4, 0)'
expected: "($999)"

related:
  - FIXED
  - TEXT
  - VALUE
faq:
  - q: "How are negative numbers displayed?"
    a: "Negative results are formatted in parentheses, for example ($1,234.00)."

[formualizer-docgen:schema:start] Name: DOLLAR Type: DollarFn Min args: 1 Max args: 2 Variadic: false Signature: DOLLAR(arg1: number@scalar, arg2?: number@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ExactFn

Compares two text values for exact equality.

Remarks

• Comparison is case-sensitive.
• No wildcard semantics are applied.
• Non-text values are converted to text before comparison.
• Errors in either argument are propagated.

Examples

title: "Exact same text"
formula: '=EXACT("Form", "Form")'
expected: true

title: "Case difference is not equal"
formula: '=EXACT("Form", "form")'
expected: false

related:
  - FIND
  - SEARCH
  - UPPER
faq:
  - q: "Does EXACT perform case-sensitive comparison?"
    a: "Yes. EXACT compares the resulting text values with exact case and character equality."

[formualizer-docgen:schema:start] Name: EXACT Type: ExactFn Min args: 2 Max args: 1 Variadic: false Signature: EXACT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FindFn

Returns the 1-based position of one text string inside another.

FIND is case-sensitive and does not interpret wildcard characters.

Remarks

• Search is case-sensitive ("A" and "a" are different).
• start_num is 1-based and must be greater than 0.
• If no match is found, returns #VALUE!.
• Errors in either argument are propagated.

Examples

title: "Case-sensitive match"
formula: '=FIND("World", "Hello World")'
expected: 7

title: "Case mismatch fails"
formula: '=FIND("world", "Hello World")'
expected: "#VALUE!"

related:
  - SEARCH
  - EXACT
  - TEXTBEFORE
faq:
  - q: "Do wildcard characters work in FIND?"
    a: "No. FIND treats * and ? as literal characters and matches case-sensitively."

[formualizer-docgen:schema:start] Name: FIND Type: FindFn Min args: 2 Max args: variadic Variadic: true Signature: FIND(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for FixedFn

Formats a number as text with fixed decimal places.

Remarks

• Default decimal places is 2 when omitted.
• Third argument controls comma grouping (TRUE disables commas).
• Values are rounded to the requested decimal precision.
• Numeric coercion failures return #VALUE!.

Examples

title: "Fixed with commas"
formula: '=FIXED(12345.678, 1, FALSE)'
expected: "12,345.7"

title: "Fixed without commas"
formula: '=FIXED(12345.678, 1, TRUE)'
expected: "12345.7"

related:
  - DOLLAR
  - TEXT
  - VALUE
faq:
  - q: "What does the third argument control?"
    a: "Set it to TRUE to suppress thousands separators; FALSE keeps comma grouping."

[formualizer-docgen:schema:start] Name: FIXED Type: FixedFn Min args: 1 Max args: 3 Variadic: false Signature: FIXED(arg1: number@scalar, arg2?: number@scalar, arg3?: logical@scalar) Arg schema: arg1{kinds=number,required=true,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=false}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg3{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LeftFn

Returns the leftmost characters from a text value.

Remarks

• num_chars defaults to 1 when omitted.
• Negative num_chars returns #VALUE!.
• If num_chars exceeds length, the full text is returned.
• Non-text values are coerced to text before slicing.

Examples

title: "Take first two characters"
formula: '=LEFT("Formualizer", 2)'
expected: "Fo"

title: "Default count is one"
formula: '=LEFT("Data")'
expected: "D"

related:
  - RIGHT
  - MID
  - LEN
faq:
  - q: "What if num_chars is negative?"
    a: "LEFT returns #VALUE! when num_chars is below zero."

[formualizer-docgen:schema:start] Name: LEFT Type: LeftFn Min args: 1 Max args: variadic Variadic: true Signature: LEFT(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LenFn

Returns the number of characters in a text value.

Remarks

• Counts Unicode scalar characters, not bytes.
• Empty values return 0.
• Non-text values are converted to their text form before counting.
• Errors are propagated unchanged.

Examples

title: "Basic text length"
formula: '=LEN("hello")'
expected: 5

title: "Whitespace is counted"
formula: '=LEN("a b")'
expected: 3

related:
  - LEFT
  - RIGHT
  - MID
faq:
  - q: "Does LEN ignore spaces?"
    a: "No. LEN counts spaces and other visible characters as part of the total length."

[formualizer-docgen:schema:start] Name: LEN Type: LenFn Min args: 1 Max args: 1 Variadic: false Signature: LEN(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for LowerFn

Converts text to lowercase.

Remarks

• Uses ASCII lowercasing semantics in this implementation.
• Numbers and booleans are first converted to text.
• Errors are propagated unchanged.

Examples

title: "Lowercase letters"
formula: '=LOWER("Data PIPELINE")'
expected: "data pipeline"

title: "Boolean coerced to text"
formula: '=LOWER(TRUE)'
expected: "true"

related:
  - UPPER
  - PROPER
  - EXACT
faq:
  - q: "How are booleans handled by LOWER?"
    a: "Inputs are coerced to text first, so TRUE/FALSE become lowercase string values."

[formualizer-docgen:schema:start] Name: LOWER Type: LowerFn Min args: 1 Max args: 1 Variadic: false Signature: LOWER(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for MidFn

Returns a substring starting at a 1-based position.

Remarks

• start_num is 1-based; values below 1 return #VALUE!.
• num_chars must be non-negative; negatives return #VALUE!.
• If start is beyond the end of the text, returns an empty string.
• Non-text inputs are coerced to text.

Examples

title: "Extract middle segment"
formula: '=MID("spreadsheet", 3, 5)'
expected: "reads"

title: "Start past end returns empty"
formula: '=MID("abc", 10, 2)'
expected: ""

related:
  - LEFT
  - RIGHT
  - REPLACE
faq:
  - q: "How does MID handle out-of-range start positions?"
    a: "If start_num is beyond the text length, MID returns an empty string."

[formualizer-docgen:schema:start] Name: MID Type: MidFn Min args: 3 Max args: 1 Variadic: false Signature: MID(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ProperFn

Capitalizes the first letter of each alphanumeric word.

Remarks

• Word boundaries are reset by non-alphanumeric characters.
• Internal letters in each word are lowercased.
• Non-text inputs are coerced to text.
• Errors are propagated unchanged.

Examples

title: "Title case simple phrase"
formula: '=PROPER("hello world")'
expected: "Hello World"

title: "Hyphen-separated words"
formula: '=PROPER("north-east REGION")'
expected: "North-East Region"

related:
  - UPPER
  - LOWER
  - TRIM
faq:
  - q: "How are word boundaries determined?"
    a: "Any non-alphanumeric character starts a new word boundary for capitalization."

[formualizer-docgen:schema:start] Name: PROPER Type: ProperFn Min args: 1 Max args: 1 Variadic: false Signature: PROPER(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ReplaceFn

Replaces part of a text string by position.

REPLACE(old_text, start_num, num_chars, new_text) works by character index.

Remarks

• start_num is 1-based and must be at least 1.
• num_chars must be non-negative.
• If start is beyond the end, the original text is returned unchanged.
• Non-text inputs are coerced to text.

Examples

title: "Replace middle segment"
formula: '=REPLACE("abcdef", 3, 2, "ZZ")'
expected: "abZZef"

title: "Insert at start"
formula: '=REPLACE("report", 1, 0, "Q1-")'
expected: "Q1-report"

related:
  - SUBSTITUTE
  - MID
  - LEFT
faq:
  - q: "Does REPLACE match text patterns?"
    a: "No. REPLACE is position-based and replaces by start_num and num_chars, not by searching old text."

[formualizer-docgen:schema:start] Name: REPLACE Type: ReplaceFn Min args: 4 Max args: 1 Variadic: false Signature: REPLACE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ReptFn

Repeats a text string a specified number of times.

Remarks

• Repeat count is truncated to an integer.
• Negative counts return #VALUE!.
• Output longer than 32,767 characters returns #VALUE!.
• Non-text first argument is coerced to text.

Examples

title: "Repeat text three times"
formula: '=REPT("ab", 3)'
expected: "ababab"

title: "Negative count"
formula: '=REPT("x", -1)'
expected: "#VALUE!"

related:
  - CONCAT
  - TEXTJOIN
  - SUBSTITUTE
faq:
  - q: "Can REPT return very long strings?"
    a: "Only up to 32,767 characters; longer results return #VALUE! like Excel."

[formualizer-docgen:schema:start] Name: REPT Type: ReptFn Min args: 2 Max args: 2 Variadic: false Signature: REPT(arg1: any@scalar, arg2: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for RightFn

Returns the rightmost characters from a text value.

Remarks

• num_chars defaults to 1 when omitted.
• Negative num_chars returns #VALUE!.
• If num_chars exceeds length, the full text is returned.
• Non-text values are coerced to text before slicing.

Examples

title: "Take last three characters"
formula: '=RIGHT("engine", 3)'
expected: "ine"

title: "Default count is one"
formula: '=RIGHT("abc")'
expected: "c"

related:
  - LEFT
  - MID
  - LEN
faq:
  - q: "If num_chars is larger than the text length, what is returned?"
    a: "RIGHT returns the full text when the requested count exceeds available characters."

[formualizer-docgen:schema:start] Name: RIGHT Type: RightFn Min args: 1 Max args: variadic Variadic: true Signature: RIGHT(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SearchFn

Returns the 1-based position of one text string inside another.

SEARCH is case-insensitive and supports * and ? wildcards.

Remarks

• Search is case-insensitive.
• * matches any sequence and ? matches a single character.
• start_num is 1-based and must be greater than 0.
• If no match is found, returns #VALUE!.

Examples

title: "Case-insensitive search"
formula: '=SEARCH("world", "Hello World")'
expected: 7

title: "Wildcard pattern"
formula: '=SEARCH("d?ta*", "Meta Data Lake")'
expected: 6

related:
  - FIND
  - EXACT
  - SUBSTITUTE
faq:
  - q: "How are case and wildcards handled?"
    a: "SEARCH is case-insensitive and supports * for any sequence plus ? for one character."

[formualizer-docgen:schema:start] Name: SEARCH Type: SearchFn Min args: 2 Max args: variadic Variadic: true Signature: SEARCH(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for SubstituteFn

Replaces matching text within a string.

SUBSTITUTE can replace all occurrences or only a specific instance.

Remarks

• Matching is case-sensitive.
• If old_text is empty, the original text is returned unchanged.
• With instance_num, only that 1-based occurrence is replaced.
• Non-positive instance_num returns #VALUE!.

Examples

title: "Replace all matches"
formula: '=SUBSTITUTE("a-b-a", "a", "x")'
expected: "x-b-x"

title: "Replace only second match"
formula: '=SUBSTITUTE("2024-01-2024", "2024", "FY24", 2)'
expected: "2024-01-FY24"

related:
  - REPLACE
  - TEXTBEFORE
  - TEXTAFTER
faq:
  - q: "Is SUBSTITUTE case-sensitive?"
    a: "Yes. It matches old_text with exact case and replaces either all or the requested instance."

[formualizer-docgen:schema:start] Name: SUBSTITUTE Type: SubstituteFn Min args: 3 Max args: variadic Variadic: true Signature: SUBSTITUTE(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TextAfterFn

Returns text that appears after a delimiter.

Remarks

• Delimiter matching is case-sensitive.
• instance_num defaults to 1; negative instances search from the end.
• instance_num=0 or empty delimiter returns #VALUE!.
• If requested delimiter occurrence is not found, returns #N/A.

Examples

title: "Text after first delimiter"
formula: '=TEXTAFTER("a-b-c", "-")'
expected: "b-c"

title: "Text after last delimiter"
formula: '=TEXTAFTER("a-b-c", "-", -1)'
expected: "c"

related:
  - TEXTBEFORE
  - FIND
  - SEARCH
faq:
  - q: "Is matching case-sensitive?"
    a: "Yes. TEXTAFTER performs case-sensitive delimiter matching in this implementation."

[formualizer-docgen:schema:start] Name: TEXTAFTER Type: TextAfterFn Min args: 2 Max args: 3 Variadic: false Signature: TEXTAFTER(arg1: any@scalar, arg2: any@scalar, arg3?: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TextBeforeFn

Returns text that appears before a delimiter.

Remarks

• Delimiter matching is case-sensitive.
• instance_num defaults to 1; negative instances search from the end.
• instance_num=0 or empty delimiter returns #VALUE!.
• If requested delimiter occurrence is not found, returns #N/A.

Examples

title: "Text before first delimiter"
formula: '=TEXTBEFORE("a-b-c", "-")'
expected: "a"

title: "Text before last delimiter"
formula: '=TEXTBEFORE("a-b-c", "-", -1)'
expected: "a-b"

related:
  - TEXTAFTER
  - FIND
  - SEARCH
faq:
  - q: "What happens when the delimiter is missing?"
    a: "TEXTBEFORE returns #N/A when the requested delimiter occurrence is not found."

[formualizer-docgen:schema:start] Name: TEXTBEFORE Type: TextBeforeFn Min args: 2 Max args: 3 Variadic: false Signature: TEXTBEFORE(arg1: any@scalar, arg2: any@scalar, arg3?: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TextFn

Formats a value as text using a format pattern.

This implementation supports common numeric, percent, grouping, and basic date tokens.

Remarks

• Requires exactly two arguments: value and format text.
• Numeric text is parsed before formatting; invalid numeric text returns #VALUE!.
• Error inputs are propagated unchanged.
• Supported patterns are intentionally limited compared with full Excel formatting.

Examples

title: "Fixed decimal formatting"
formula: '=TEXT(12.3, "0.00")'
expected: "12.30"

title: "Percent formatting"
formula: '=TEXT(0.256, "0%")'
expected: "26%"

related:
  - VALUE
  - FIXED
  - DOLLAR
faq:
  - q: "How complete is format_text support?"
    a: "Only a limited subset of Excel-style numeric/date tokens is supported in this implementation."

[formualizer-docgen:schema:start] Name: TEXT Type: TextFn Min args: 2 Max args: 1 Variadic: false Signature: TEXT(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TextJoinFn

Joins text values using a delimiter, with optional empty-value filtering.

TEXTJOIN(delimiter, ignore_empty, text1, ...) is useful for building labels and lists.

Remarks

• ignore_empty=TRUE skips empty strings and empty cells.
• ignore_empty=FALSE includes empty items, which can produce adjacent delimiters.
• Delimiter and values are coerced to text.
• Any error in inputs propagates immediately.

Examples

title: "Ignore empty entries"
formula: '=TEXTJOIN(",", TRUE, "a", "", "c")'
expected: "a,c"

title: "Keep empty entries"
formula: '=TEXTJOIN("-", FALSE, "a", "", "c")'
expected: "a--c"

related:
  - CONCAT
  - CONCATENATE
  - TEXTSPLIT
faq:
  - q: "What does ignore_empty change?"
    a: "TRUE skips empty values; FALSE keeps them, which can create adjacent delimiters."

[formualizer-docgen:schema:start] Name: TEXTJOIN Type: TextJoinFn Min args: 3 Max args: variadic Variadic: true Signature: TEXTJOIN(arg1…: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TextSplitFn

Splits text into a dynamic 2D array by column and optional row delimiters.

TEXTSPLIT supports multiple delimiters, optional case-insensitive matching, and output padding.

Remarks

• Column delimiter is required; row delimiter is optional.
• match_mode=0 is case-sensitive, match_mode=1 is case-insensitive.
• ignore_empty=TRUE drops empty segments created by adjacent delimiters.
• Rows are padded to equal width using pad_with (default #N/A).

Examples

title: "Split CSV row"
formula: '=TEXTSPLIT("A,B,C", ",")'
expected: "{A,B,C}"

title: "Row and column split with padding"
formula: '=TEXTSPLIT("A,B;C", ",", ";")'
expected: "{A,B;C,#N/A}"

related:
  - TEXTBEFORE
  - TEXTAFTER
  - TEXTJOIN
faq:
  - q: "Is delimiter matching case-sensitive?"
    a: "Yes by default; set match_mode to 1 for case-insensitive delimiter matching."

[formualizer-docgen:schema:start] Name: TEXTSPLIT Type: TextSplitFn Min args: 2 Max args: 6 Variadic: false Signature: TEXTSPLIT(arg1: any@scalar, arg2: any@scalar, arg3?: any@scalar, arg4?: logical@scalar, arg5?: number@scalar, arg6?: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg3{kinds=any,required=false,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg4{kinds=logical,required=false,shape=scalar,by_ref=false,coercion=Logical,max=None,repeating=None,default=true}; arg5{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true}; arg6{kinds=any,required=false,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]

impl Function for TrimFn

Removes leading/trailing whitespace and collapses internal runs to single spaces.

Remarks

• Leading and trailing whitespace is removed.
• Consecutive whitespace inside the text is collapsed to one ASCII space.
• Non-text inputs are coerced to text before trimming.
• Errors are propagated unchanged.

Examples

title: "Normalize spacing"
formula: '=TRIM("  alpha   beta  ")'
expected: "alpha beta"

title: "Already clean text"
formula: '=TRIM("report")'
expected: "report"

related:
  - CLEAN
  - TEXTJOIN
  - SUBSTITUTE
faq:
  - q: "What whitespace does TRIM normalize?"
    a: "It trims edges and collapses internal whitespace runs to single spaces."

[formualizer-docgen:schema:start] Name: TRIM Type: TrimFn Min args: 1 Max args: 1 Variadic: false Signature: TRIM(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for UnicharFn

Returns the Unicode character for a given code point.

Remarks

• Input is truncated to an integer code point.
• Code point 0, surrogate range, and values above 0x10FFFF return #VALUE!.
• Errors are propagated unchanged.
• Non-numeric inputs are coerced with numeric coercion rules.

Examples

title: "Basic Unicode code point"
formula: '=UNICHAR(9731)'
expected: "☃"

title: "Invalid code point"
formula: '=UNICHAR(0)'
expected: "#VALUE!"

related:
  - UNICODE
  - CHAR
  - CODE
faq:
  - q: "Which code points are invalid?"
    a: "0, surrogate values, and anything above 0x10FFFF return #VALUE!."

[formualizer-docgen:schema:start] Name: UNICHAR Type: UnicharFn Min args: 1 Max args: 1 Variadic: false Signature: UNICHAR(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for UnicodeFn

Returns the Unicode code point of the first character in text.

Remarks

• Only the first character is evaluated.
• Empty text returns #VALUE!.
• Non-text inputs are coerced to text before inspection.
• Errors are propagated unchanged.

Examples

title: "Code point for letter A"
formula: '=UNICODE("A")'
expected: 65

title: "Code point for emoji"
formula: '=UNICODE("😀")'
expected: 128512

related:
  - UNICHAR
  - CODE
  - CHAR
faq:
  - q: "If text has multiple characters, which one is used?"
    a: "UNICODE inspects only the first character and ignores the rest."

[formualizer-docgen:schema:start] Name: UNICODE Type: UnicodeFn Min args: 1 Max args: 1 Variadic: false Signature: UNICODE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for UpperFn

Converts text to uppercase.

Remarks

• Uses ASCII uppercasing semantics in this implementation.
• Numbers and booleans are first converted to text.
• Errors are propagated unchanged.

Examples

title: "Uppercase letters"
formula: '=UPPER("Quarterly report")'
expected: "QUARTERLY REPORT"

title: "Number coerced to text"
formula: '=UPPER(123)'
expected: "123"

related:
  - LOWER
  - PROPER
  - EXACT
faq:
  - q: "Is uppercasing fully Unicode-aware?"
    a: "This implementation uses ASCII uppercasing semantics, so non-ASCII case rules are limited."

[formualizer-docgen:schema:start] Name: UPPER Type: UpperFn Min args: 1 Max args: 1 Variadic: false Signature: UPPER(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ValueFn

Converts text that represents a number into a numeric value.

Remarks

• Parsing uses locale-aware invariant number parsing from the function context.
• Non-numeric text returns #VALUE!.
• Booleans and numbers are first coerced to text, then parsed.
• Errors are propagated unchanged.

Examples

title: "Parse decimal text"
formula: '=VALUE("12.5")'
expected: 12.5

title: "Invalid numeric text"
formula: '=VALUE("abc")'
expected: "#VALUE!"

related:
  - TEXT
  - N
  - ISNUMBER
faq:
  - q: "Does VALUE coerce arbitrary text like TRUE/FALSE?"
    a: "VALUE parses numeric text only; non-numeric strings return #VALUE!."

[formualizer-docgen:schema:start] Name: VALUE Type: ValueFn Min args: 1 Max args: 1 Variadic: false Signature: VALUE(arg1: any@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false} Caps: PURE [formualizer-docgen:schema:end]

impl Function for ValueToTextFn

Converts a value to text representation.

VALUETOTEXT(value, [format]) supports concise (0) and strict (1) modes.

Remarks

• Concise mode (0) returns natural text for scalars.
• Strict mode (1) adds explicit quoting for text and serializes arrays with braces.
• In concise mode, error values are propagated as errors.
• In strict mode, error values are rendered as their error text.

Examples

title: "Concise text conversion"
formula: '=VALUETOTEXT(123)'
expected: "123"

title: "Strict quoting for text"
formula: '=VALUETOTEXT("hello", 1)'
expected: '"hello"'

related:
  - ARRAYTOTEXT
  - TEXT
  - VALUE
faq:
  - q: "How are errors handled in concise vs strict mode?"
    a: "Concise mode returns the error, while strict mode converts the error to its text form."

[formualizer-docgen:schema:start] Name: VALUETOTEXT Type: ValueToTextFn Min args: 1 Max args: 2 Variadic: false Signature: VALUETOTEXT(arg1: any@scalar, arg2?: number@scalar) Arg schema: arg1{kinds=any,required=true,shape=scalar,by_ref=false,coercion=None,max=None,repeating=None,default=false}; arg2{kinds=number,required=false,shape=scalar,by_ref=false,coercion=NumberLenientText,max=None,repeating=None,default=true} Caps: PURE [formualizer-docgen:schema:end]