Overview

Nota Language is an arbitrary-precision calculator language that both evaluates expressions and renders them as beautifully typeset Unicode text art. Every value is computed at 256-bit decimal precision, so there is no floating-point rounding error.

The two primary data types are Numeric and Matrix. There is no dedicated boolean type; zero is false and non-zero is true.

Numbers

Numbers can be integers, decimals, or use spaces as visual grouping.

423.141 591

Spaces inside numbers are ignored by the parser, so 1 000 000 is the same as 1000000.

Precision

All arithmetic is performed at 256-bit precision (configurable via BIG_FLOAT_PRECISION). Pi and E are stored with over 100 correct digits.

Infinity

Inf
Infinity

Both render as ∞.

Names and Identifiers

Names start with a letter and can contain letters, digits, spaces, and apostrophes.

x
my variable
earth's radius

Names are normalized when rendered:

Multi-word names have each word capitalized. Single Latin letters are lowercase by default; appending ' toggles to uppercase. Greek letter names render as their Unicode symbol; appending ' gives the uppercase form.

Operators

Arithmetic

Comparison

Comparison returns 1 for true and 0 for false.

Logical

Precedence

From lowest to highest:

Parentheses override precedence.

                2          
╭              3  ╮        
│ (2 + 3) × 42    │ - 3 + 2
╰                 ╯        

Assignment

name = expression
name = start..stop

The range form is used by iteration constructs.

Assignments to a built-in constant or function name are rejected.

Function Calls

FunctionName[arg1, arg2, ...]

Arguments use square brackets and are comma-separated. Every function has a fixed arity range and type signature; wrong counts or types produce a computation error.

Built-in Functions

Arithmetic

Abs

Abs[x]

Absolute value. Works on scalars and element-wise on matrices.

Ceil

Ceil[x]

Round up to the nearest integer. Element-wise on matrices.

Floor

Floor[x]

Round down. Element-wise on matrices.

Sqrt

Sqrt[x]

Square root. Renders as a radical sign.

Error if x < 0.

Root

Root[n, x]

n-th root of x. First argument is the degree, second is the radicand.

Both arguments must be positive.

Log

Log[base, x]

Logarithm of x in the given base. Renders with the base as a subscript.

Constraints: base > 0, base ≠ 1, x > 0.

Limit

Limit[x = a, expression]

Numerical limit of expression as x approaches a. Also aliased as Lim.

The limit point can be Inf or -Inf.

          1 
lim      ───
   x → ∞  x 

Trigonometry

Sin

Sin[x]

Sine of x in radians.

Cos

Cos[x]

Cosine of x in radians.

Tan

Tan[x]

Tangent of x in radians.

All three work element-wise on matrices.

Statistics

Max

Max[a, b, ...]
Max[matrix]

Largest value among 1–64 numeric arguments, or the maximum element of a single matrix argument.

Min

Min[a, b, ...]
Min[matrix]

Smallest value, same calling conventions as Max.

Mean

Mean[a, b, ...]
Mean[matrix]

Arithmetic mean. Same calling conventions as Max.

Iteration

Sum

Sum[i = start..stop, expression]

Summation of expression as i runs from start to stop inclusive. Renders as Σ with bounds.

The second argument is evaluated in a fresh sub-scope that sees the iterator.

Product

Product[i = start..stop, expression]

Product of expression over the range. Renders as Π with bounds.

Loop

Loop[i = start..stop, r = expression]

Iterative loop. The second argument must be a declaration; the accumulator r is initialized to zero and updated on every iteration.

Int

Int[x = start..stop, expression, step?]

Numerical integration using composite Simpson’s rule. Renders as ∫ with bounds. The optional third argument is either an interval count (≥ 2) or a step size in the domain.

Matrix

Id

Id[n]

n×n identity matrix.

I[3]

Det

Det[matrix]

Determinant of a square matrix.

           ╭ ⎡ 1  2 ⎤ ╮
Determinant│ ⎢      ⎥ │
           ╰ ⎣ 3  4 ⎦ ╯

Trans

Trans[matrix]

Transpose. Renders with a dagger (†) superscript.

        †
⎡ 1  2 ⎤ 
⎢      ⎥ 
⎣ 3  4 ⎦ 

Rows

Rows[matrix]

Number of rows.

    ╭ ⎡ 1  2 ⎤ ╮
    │ ⎢      ⎥ │
Rows│ ⎢ 3  4 ⎥ │
    │ ⎢      ⎥ │
    ╰ ⎣ 5  6 ⎦ ╯

Cols

Cols[matrix]

Number of columns.

    ╭ ⎡ 1  2 ⎤ ╮
Cols│ ⎢      ⎥ │
    ╰ ⎣ 3  4 ⎦ ╯

Row

Row[matrix, index]

Extract a single row as a column vector. Index is 1-based.

   ╭ ⎡ 1  2 ⎤    ╮
Row│ ⎢      ⎥, 1 │
   ╰ ⎣ 3  4 ⎦    ╯

Column

Column[matrix, index]

Extract a single column as a row vector. Index is 1-based.

      ╭ ⎡ 1  2 ⎤    ╮
Column│ ⎢      ⎥, 1 │
      ╰ ⎣ 3  4 ⎦    ╯

Get

Get[matrix, row, col]

Read a single element. Indices are 1-based. Renders with subscript notation.

⎡ 1  2 ⎤   
⎢      ⎥   
⎣ 3  4 ⎦   
        1,2

Set

Set[row, col, matrix, value]

Return a new matrix with the element at (row, col) replaced. The original is not modified.

   ╭       ⎡ 1  2 ⎤     ╮
Set│ 1, 1, ⎢      ⎥, 99 │
   ╰       ⎣ 3  4 ⎦     ╯

Iota

Iota[columns, rows?]

Matrix filled with sequential integers starting from 1. If rows is omitted, produces a single row.

Shuffle

Shuffle[matrix]

Randomly permutes all elements.

Shuffle[[1  2  3  4]]

REPL

Out

Out[index]

Returns a previous REPL output. Negative indices count from the end.

Out[1]
Out[-1]
Out[-2]

Matrices

Literals

Rows are separated by ;, columns by ,.

Elements can be any expression.

⎡         3 ⎤
⎢ 1 + 1  2  ⎥
⎢           ⎥
⎢   ___     ⎥
⎣ ╲╱ 9   5! ⎦

Nested matrices are not supported.

Builders

Comprehension syntax:

[mapping | variable <- source, conditions...]

The conditions are evaluated in the same sub-scope as the mapper, so they can reference the iterator.

Element-wise Operations

Arithmetic operators and most scalar functions apply element-wise:

Matrix–matrix multiplication uses standard linear algebra rules. Matrix division computes the inverse of the divisor first, so the divisor must be square and non-singular.

Conditions

Piecewise expressions use curly brackets with condition–value pairs separated by ; and a default after ?.

{ condition1: expression1 ? default }
{ condition1: expression1 ; condition2: expression2 ? default }

Conditions are evaluated in order; the first match wins.

Rendering uses the standard curly-bracket piecewise notation:

Unit Conversion

Syntax

sourceUnit : destinationUnit [ value ]

Source and destination can be given by name, abbreviation, or synonym.

Length

Reference unit is the meter.

Area

Reference unit is the square meter.

Time

Reference unit is the second.

Computer Storage

Reference unit is the bit.

Conversion works through the reference unit, so any two units in the same category are interchangeable. Cross-category conversion is rejected.

Constants

Mathematical

        (i × π)
2 × Pi E       

Special

Greek Letters

All 24 Greek letters are available as identifiers. Lowercase by default; append ' for uppercase.

User-Defined Functions

name[param1, param2, ...] = body

The name cannot shadow a built-in function or constant. Parameters are bound in a fresh sub-scope on every call, so definitions can recurse:

Rendering Rules

Nota Language renders each construct as a specific Unicode layout:

Grammar Summary

Lexer Tokens

InOperator         ::= "<-"
ArrowOperator      ::= "->"
RangeOperator      ::= ".."
OrOperator         ::= "||"
AndOperator        ::= "&&"
BarOperator        ::= "|"
ComparisonOperators ::= "==" | "!=" | "<" | ">" | ">=" | "<="
AssignOperator     ::= "="
FactorialOperator  ::= "!"
Number             ::= (( " " Digit | Digit )+ ( "." ... )?)?
Name               ::= Letter ( ( "'" | " " | WordChar )* WordChar )?
ExponentOperator   ::= "^"
MultiplyModuleOperators ::= "*" | "%"
DivisionOperator   ::= "/"
MinusOperator      ::= "-"
PlusOperator       ::= "+"
LeftBracket        ::= "["
RightBracket       ::= "]"
LeftCurlyBracket   ::= "{"
RightCurlyBracket  ::= "}"
LeftParenthesis    ::= "("
RightParenthesis   ::= ")"
QuestionMark       ::= "?"
Comma              ::= ","
Colon              ::= ":"
SemiColon          ::= ";"

Top Level

Statement ::= FunctionDefinition
            | LimitDeclaration
            | Assignment
            | AndOrExpression

Expression Precedence

AndOrExpression      ::= ComparisonExpression ( ("&&" | "||") AndOrExpression )?
ComparisonExpression ::= AddSubExpression ( ComparisonOp ComparisonExpression )?
AddSubExpression     ::= DivisionExpression ( ("+" | "-") AddSubExpression )?
DivisionExpression   ::= MulModExpression ( "/" DivisionExpression )?
MulModExpression     ::= ExponentExpression ( ("*" | "%") MulModExpression )?
ExponentExpression   ::= FactorialExpression ( "^" ExponentExpression )?
FactorialExpression  ::= UnaryExpression "!"?
UnaryExpression      ::= "-" OperationsEnding | OperationsEnding
OperationsEnding     ::= AtomicValue | "(" AndOrExpression ")" | UnaryExpression

Atomic Values

AtomicValue ::= FunctionCall
             | MatrixBuilder
             | MatrixLiteral
             | ConditionExpression
             | NumericLiteral
             | UnitConversion
             | Identifier

Composite Forms

FunctionCall       ::= Name "[" Statement ("," Statement)* "]"
MatrixLiteral      ::= "[" Row (";" Row)* "]"
Row                ::= Statement ("," Statement)*
MatrixBuilder      ::= "[" Statement "|" Identifier "<-" Statement ("," Statement)* "]"
ConditionExpression ::= "{" Pair (";" Pair)* "?" AndOrExpression "}"
Pair               ::= AndOrExpression ":" AndOrExpression
UnitConversion     ::= Identifier ":" Identifier "[" AndOrExpression "]"
Assignment         ::= Name "=" AndOrExpression ( (".." | "->") AndOrExpression )?
FunctionDefinition ::= Name "[" Identifier ("," Identifier)* "]" "=" AndOrExpression
LimitDeclaration   ::= Name "=" AndOrExpression

Quick Reference