Catena reference

This is the catalog chapter of the Catena sub-series: the complete list of the words the language reserves, the types and formats it understands, every built-in function the calculator can evaluate, the engine settings you can pin to a sequence, and a one-page grammar cheat-sheet. Use it as a lookup, not a tutorial. If you are learning the language, start with the commands and standard library and types and formatting chapters and come back here when you need to confirm a name, an argument count, or an alias.

Two conventions run through the whole chapter:

• Keywords are case-insensitive. IF, if, and If are the same word. The tables print them in upper case because that is how the app displays them, but you may type any case.
• Type and format names are case-sensitive. Num, Date, and Money must be written exactly as shown, with their leading capital. This is the one place where case matters outside your own variable names.

Keywords and reserved words

These words are built into the language and cannot be used as variable names. They fall into four groups.

Control flow and structure. The words that build blocks, loops, decisions, and sequences.

Named operators. Word-form operators used inside expressions and queries.

Literals and registers. Built-in values.

Command verbs. Words that begin a standard-library statement. Each is covered in commands and standard library; brackets around their arguments are optional.

Types and formats

Catena has a small, disjoint set of types and a small set of display formats. Both are used with the AS operator — expression AS Type enforces or converts a type, expression AS Format presents a value a particular way (see types and formatting). Remember that these names are case-sensitive.

Types.

Formats. These affect presentation only; they never change the stored value.

Currency glyphs. A leading glyph marks a money literal: $, €, £, ¥. A trailing ISO 4217 code (for example 100 USD) is also recognised.

Duration units. These words after a number make a Duration literal, in both singular and plural: day/days, hour/hours, minute/minutes, second/seconds, week/weeks, month/months, year/years, millisecond/milliseconds. Date arithmetic uses explicit durations, so date + 30 days is well formed while date + 30 is not.

Function reference

Every built-in mathematical function is listed below, grouped by family. Read the tables this way:

• Name is the canonical form — always lower case (for example sin, sqrt, gcd). This is the primary spelling.
• Alias(es) are additional spellings that call the same function. Upper-case aliases (SIN-style SQRT, LN, ABS) mirror the classic calculator keys; other aliases mirror Casio-style names (P, C, HCF, Ran#). Any listed alias is interchangeable with the canonical name.
• Args is the argument count. A single number is a fixed count; 1..2 means one required plus one optional; 1..n means one or more (variadic); 0..1 means the argument is optional.

Function names are case-sensitive, so type the exact spelling shown. Where a family maps to dedicated keypad keys (the trig and log families in School mode), the School calculator and trigonometry chapters show the keys; here we list the typed names that work in every mode.

Elementary and rounding

Trigonometry

All trigonometric functions read the active angle mode (DEG / RAD / GRA); the hyperbolic family does not. See trigonometry for the full treatment.

Logarithms and exponentials

Angle conversions and coordinates

These always perform the named conversion regardless of the active angle mode.

Number theory

Complex numbers

The magnitude of a complex number shares one name with the vector norm — see mag in the next table.

Vectors

Vectors are held as Bags. See types and formatting for how a Bag stands in for a vector.

Random

Engine settings (ESET)

ESET pins a computation setting to a sequence so it travels with the file — an accountant handing a sequence to staff can guarantee how it rounds and converts. The form is:

ESET <SETTING> <VALUE>

A setting applies to the sequence it appears in and to every sequence called from it; a callee may override it for its own scope, and the override reverts when control returns. Defaults come from the app-wide options.

ESET ROUNDING BANK        # banker's rounding for this sequence and its callees
ESET MAXDEPTH 256         # cap recursion depth

An unknown setting is a validation error with a suggestion.

Grammar cheat-sheet

A user-readable summary of the language shape. This is not the formal grammar; it is the set of statement forms you actually write. Synonyms and localized keywords normalize to the canonical forms shown here.

A sequence is a list of lines. Each line is one statement, optionally followed by a # comment. Blank lines are fine. A line with a bare expression shows its result and pushes it onto Ans, exactly like pressing =.

Assignment. Compute on the left, store on the right:

price * 1.23 -> total
price * 1.23 -> total AS Money      # store and format/convert on the way in

-> is canonical. total <- price * 1.23 and set total = price * 1.23 are accepted aliases. = is never assignment — it is mathematical equality in a comparison. Store targets may be a plain name or a Bag slot: value -> results[1] (by position, 1-based) or value -> results["grand_total"] (by name).

Expressions. Precedence from tightest to loosest: AS (convert/format), then ^ (power, right-associative), then × ÷ (also * /), then + -, then comparisons (=, <>, <, >, <=, >=), then NOT, then AND, then OR. Grouping uses parentheses ( ) and is never optional. Square brackets [ ] build a Bag literal or index into one — never grouping. Multiplication is only ever inferred at a parenthesis boundary ((2)(3) is 2 × 3); 2x is never split.

Decisions.

IF condition
    …
OTHERWISE IF other
    …
OTHERWISE
    …
END

UNLESS condition
    …
END

Loops. All four repetition forms open with REPEAT and close with END; FOR EACH iterates a Bag:

REPEAT 5 TIMES              …   END
REPEAT WITH i FROM 1 TO 10  …   END
REPEAT WHILE condition      …   END
REPEAT UNTIL condition      …   END
FOR EACH item IN prices     …   END

Checkpoints. For input-validation re-prompts within a sequence:

CHECKPOINT retry
…
JUMP TO retry

Reactive rules. WHEN must always be qualified. ALWAYS recomputes eagerly; AS RULE name waits for a CHECK:

WHEN amount > 5000 ALWAYS
    amount * 1.05 -> amount
END

WHEN amount > 5000 AS RULE surcharge
    amount * 1.05 -> amount
END
CHECK surcharge            # run that rule now; bare CHECK runs all settled rules

Sequences. Define with SEQUENCE … END, call with CALL, hand back with RETURN:

SEQUENCE vatTotal(prices)
    SUM(prices) * 1.23 -> total
    RETURN total
END

CALL vatTotal(prices) -> result

Parameters may carry an optional AS Type. A sequence returns a single value or a value bag; with no RETURN it returns an empty bag. The textual SEQUENCE … END wrapper is optional because the name and parameters also live in the file's metadata.

Commands. Command verbs (DISPLAY, PRINT, PROMPT, CURRENCY, API, …) take their arguments with or without brackets, and may end in -> target:

PROMPT "Net price?" -> price
CURRENCY ("USD", price, "EUR") -> itemPrice
OUT itemPrice

Worked-example gallery

Four short, complete sequences that draw the earlier pieces together.

1 — Quadratic roots (decision, sqrt, RETURN). Given a, b, c, return the two real roots or a message when there are none.

SEQUENCE quadratic(a, b, c)
    b * b - 4 * a * c -> disc
    IF disc < 0
        RETURN "no real roots"
    END
    (-b + sqrt(disc)) / (2 * a) -> root1
    (-b - sqrt(disc)) / (2 * a) -> root2
    RETURN [root1, root2]
END

Calling CALL quadratic(1, -5, 6) -> roots returns the Bag [3, 2].

2 — VAT over a shopping bag (aggregate, element-wise, value bag). Take a bag of net prices, return the per-item gross prices and the grand total.

SEQUENCE vat(prices)
    prices * 1.23 -> gross          # element-wise over the whole bag
    SUM(gross) -> total
    total -> gross["grand_total"]   # augment the bag with a named item
    RETURN gross
END

CALL vat([150, 200, 99.50]) -> invoice returns the grossed-up items plus invoice["grand_total"].

3 — Compound growth (counted loop, Ans, store). Grow a balance at 5% for a fixed number of years.

1000 -> balance
REPEAT WITH year FROM 1 TO 10
    balance * 1.05 -> balance
END
OUT balance                          # show the final balance and record it on the tape

OUT prints the last value to the paper tape and shows it, so the result is both visible and kept.

4 — Validated input (checkpoint, prompt, UNLESS). Re-ask until the user gives a positive price.

CHECKPOINT retry
PROMPT "Net price?" AS Num -> price
UNLESS price > 0
    JUMP TO retry
END
price * 1.23 -> total AS Money
OUT total

PROMPT … AS Num validates the entry as a number and re-prompts on bad input; UNLESS price > 0 sends control back to the checkpoint until the value is positive.

Related chapters

• Commands and the standard library — the verbs and standard-library calls in depth.
• Types and formatting — the type model, the AS operator, and the Bag container.
• Trigonometry — the theory and keypad forms behind the trig family.
• The School calculator — the surface that maps many of these functions to keys.