qois

qoi =
    expr
  | { assignment }, "return", expr, ";"
;

assignment =
    variable, "=", expr, ";"
;

expr =
    number
  | array
  | unary_operator
  | binary_operator
  | binary_comparison
  | array_transpose
  | subexpression
  | constant
  | data
  | late_bound_constant
  | variable
  | array_indexing
  | arithmetic_functions
  | classification_functions
  | logical_combinators
  | array_functions
  | finite_difference
;

number =
    integer
  | float
  | "Inf"  (* infinity *)
  | "NaN"  (* not a number *)
;

integer =
    [ sign ], digit, { digit }
;
float =
    [ sign ], digit, { digit }, [
        ".", digit, { digit }
    ], [
        "e", [ sign ], digit, { digit }
    ]
;

sign =
    "+" | "-"
;
digit =
    "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
;

array =
    "[", expr, { ",", expr }, [","], "]"
;

unary_operator =
    "+", expr  (* positive / no-op *)
  | "-", expr  (* negation *)
;

binary_operator =
    expr, "+", expr  (* addition *)
  | expr, "-", expr  (* subtraction *)
  | expr, "*", expr  (* multiplication *)
  | expr, "/", expr  (* division *)
  | expr, "**", expr  (* exponentiation / power *)
;

binary_comparison =
    expr, "<", expr  (* 1 if a less than b, 0 otherwise (e.g. with NaN) *)
  | expr, "<=", expr  (* 1 if a less than or equal to b, 0 otherwise (e.g. with NaN) *)
  | expr, "==", expr  (* 1 if a equal to b, 0 otherwise (e.g. with NaN) *)
  | expr, "!=", expr  (* 1 if a not equal to b, 0 otherwise; 1 for NaN != NaN *)
  | expr, ">=", expr  (* 1 if a greater than or equal to b, 0 otherwise (e.g. with NaN) *)
  | expr, ">", expr  (* 1 if a greater than b, 0 otherwise (e.g. with NaN) *)
;

array_transpose =
    expr, ".T"
;

subexpression =
    "(", expr, ")"
;

constant =
    "e"  (* Euler's number *)
  | "pi"  (* pi *)
;

data =
    "x"  (* pointwise data value, x = X[I] *)
  | "X"  (* stencil data neighbourhood, only available in stencil QoIs *)
;

late_bound_constant =
    "c", "[", '"', identifier, '"', "]"  (* late-bound constant pointwise value *)
  | "C", "[", '"', identifier, '"', "]"  (* late-bound constant stencil neighbourhood, only available in stencil QoIs *)
  | "c", "[", '"', "$", identifier, '"', "]"  (* built-in late-bound constant pointwise value *)
  | "C", "[", '"', "$", identifier, '"', "]"  (* built-in late-bound constant stencil neighbourhood, only available in stencil QoIs *)
;

variable =
    "v", "[", '"', identifier, '"', "]"    (* user-defined variable, only available in pointwise QoIs *)
  | "V", "[", '"', identifier, '"', "]"    (* user-defined variable, only available in stencil QoIs *)
;

identifier =
    ( letter | "_" ), { letter | digit | "_" }
;
letter =
    "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k"
  | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v"
  | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G"
  | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R"
  | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"
;

array_indexing =
    expr, "[", "I", "]"  (* stencil neighbourhood centre, only available in stencil QoIs *)
  | expr, "[", index, { ",", index }, [","], "]"  (* array indexing *)
  | "I", "[", index, { ",", index }, [","], "]"  (* indexed 1D array over the per-axis stencil neighbourhood centre indices, only available in stencil QoIs *)
;

index =
    integer_expr  (* single index *)
  | [ integer_expr ], ":", [ integer_expr ]  (* slice index from (inclusive) to (exclusive) *)
  | [ integer_expr ], ":", [ integer_expr ], ":", [ integer_expr ]  (* slice index with step *)
;

integer_expr =
    ? symbolic integer-only expression ?
;

arithmetic_functions =
    "ln", "(", expr, [","], ")"  (* natural logarithm *)
  | "log2", "(", expr, [","], ")"  (* binary logarithm *)
  | "log10", "(", expr, [","], ")"  (* decimal logarithm *)
  | "log", "(", expr, ",", "base", "=", expr, [","], ")"  (* logarithm with arbitrary base *)
  | "exp", "(", expr, [","], ")"  (* exponential e^x *)
  | "exp2", "(", expr, [","], ")"  (* binary exponentiation 2^x *)
  | "exp10", "(", expr, [","], ")"  (* decimal exponentiation 10^x *)
  | "sqrt", "(", expr, [","], ")"  (* square root *)
  | "square", "(", expr, [","], ")"  (* square x^2 *)
  | "reciprocal", "(", expr, [","], ")"  (* reciprocal 1/x *)
  | "abs", "(", expr, [","], ")"   (* absolute value *)
  | "sign", "(", expr, [","], ")"  (* sign function, signed NaN for NaNs *)
  | "floor", "(", expr, [","], ")"  (* round down, towards negative infinity *)
  | "ceil", "(", expr, [","], ")"  (* round up, towards positive infinity *)
  | "trunc", "(", expr, [","], ")"  (* round towards zero *)
  | "round_ties_even", "(", expr, [","], ")"  (* round to nearest integer, ties to even *)
  | "floor_modulo", "(", expr, ",", expr, [","], ")"  (* modulo with respect to floor(division) *)
  | "ceil_modulo", "(", expr, ",", expr, [","], ")"  (* modulo with respect to ceil(division) *)
  | "trunc_modulo", "(", expr, ",", expr, [","], ")"  (* modulo with respect to trunc(division) *)
  | "round_ties_even_modulo", "(", expr, ",", expr, [","], ")"  (* modulo with respect to round_ties_even(division) *)
  | "euclidean_modulo", "(", expr, ",", expr, [","], ")"  (* non-negative modulo with respect to Euclidean division *)
  | "sin", "(", expr, [","], ")"  (* sine sin(x) *)
  | "cos", "(", expr, [","], ")"  (* cosine cos(x) *)
  | "tan", "(", expr, [","], ")"  (* tangent tan(x) *)
  | "asin", "(", expr, [","], ")"  (* inverse sine asin(x) *)
  | "acos", "(", expr, [","], ")"  (* inverse cosine acos(x) *)
  | "atan", "(", expr, [","], ")"  (* inverse tangent atan(x) *)
  | "sinh", "(", expr, [","], ")"  (* hyperbolic sine sinh(x) *)
  | "cosh", "(", expr, [","], ")"  (* hyperbolic cosine cosh(x) *)
  | "tanh", "(", expr, [","], ")"  (* hyperbolic tangent tanh(x) *)
  | "asinh", "(", expr, [","], ")"  (* inverse hyperbolic sine asinh(x) *)
  | "acosh", "(", expr, [","], ")"  (* inverse hyperbolic cosine acosh(x) *)
  | "atanh", "(", expr, [","], ")"  (* inverse hyperbolic tangent atanh(x) *)
;

classification_functions =
    "isfinite", "(", expr, [","], ")"  (* 1 if finite, 0 if infinite or NaN *)
  | "isinf", "(", expr, [","], ")"  (* 1 if infinite, 0 if finite or NaN *)
  | "isnan", "(", expr, [","], ")"  (* 1 if NaN, 0 if finite or infinite *)
;

logical_combinators =
    "not", "(", expr, [","], ")"  (* 1 if == 0, 0 if != 0 *)
  | "all", "(", expr, [","], ")"  (* 1 if all array elements != 0, 0 if any array element == 0 *)
  | "any", "(", expr, [","], ")"  (* 1 if any array element != 0, 0 if all array elements == 0 *)
  | "where", "(", expr, ",", expr, ",", expr, [","], ")"  (* where(c, x, y) = x if (c != 0) else y *)
;

array_functions =
    "size", "(", expr, [","], ")"  (* array size *)
  | "shape", "(", expr, [","], ")"  (* array shape as a 1D array *)
  | "sum", "(", expr, [","], ")"  (* array sum *)
  | "matmul", "(", expr, ",", expr, [","], ")"  (* matrix (2d array) multiplication *)
;

finite_difference =
    "finite_difference", "("  (* finite difference over an expression, only available in stencil QoIs *)
      , expr, ","
      , "order", "=", integer, ","  (* order of the derivative *)
      , "accuracy", "=", integer, ","  (* order of accuracy of the approximation *)
      , "type", "=", ("-1" | "0" | "1"), ","  (* backwards | central | forward difference *)
      , "axis", "=", integer, ","  (* axis, relative to the neighbourhood *)
      , (
            "grid_spacing", "=", expr  (* scalar uniform grid spacing along the axis *)
          | "grid_centre", "=", expr  (* centre of an arbitrary grid along the axis *)
        )
      , (
            [","]
          | ",", "grid_period", "=", expr, [","]  (* optional grid period, e.g. 2*pi or 360 *)
        )
  , ")"
;