nodes/mcDandy-more_math
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
32e7557facaaaddab71d29da9ad6beed047bfe6e
mcDandy-more_math/more_math/Parser/MathExpr.g4
T
mcDandy 2e90d0e235 better description
2026-10-18 00:06:55 +02:00

1998 lines
80 KiB
ANTLR
Raw Blame History

/**
* MathExpr.g4
*
* This grammar defines the syntax for a mathematical expression language.
* It supports:
* - Variable and function definitions
* - Control flow statements (if, while, for)
* - A wide range of mathematical functions (trigonometric, hyperbolic, etc.)
* - Tensor operations (matmul, dot, reshape, etc.)
* - Noise functions (perlin, cellular, etc.)
* - Basic arithmetic, comparison, and bitwise function operations
*/
grammar MathExpr;
// Top-level entry point
start: (funcDef | varDef | stmt)* expr SEMICOLON? EOF;
funcDef:
VARIABLE LPAREN paramList? RPAREN ARROW (expr | block) SEMICOLON # FunctionDef;
varDef:
VARIABLE (LBRACKET expr (COMMA expr)* RBRACKET)* (EQUEALS | PLUS_EQ | MINUS_EQ | MULT_EQ | DIV_EQ | MOD_EQ) expr SEMICOLON;
paramList: VARIABLE (COMMA VARIABLE)*;
stmt:
ifStmt # IfStatement
| whileStmt # WhileStatement
| block # BlockStatement
| breakStmt # BreakStatement
| continueStmt # ContinueStatement
| returnStmt # ReturnStatement
| varDef # VarDefStmt
| forStmt # ForStatement
| expr SEMICOLON # ExprStatement;
ifStmt: IF LPAREN expr RPAREN stmt (ELSE stmt)?;
whileStmt: WHILE LPAREN expr RPAREN stmt;
forStmt: FOR LPAREN VARIABLE IN expr RPAREN stmt;
block: LBRACE stmt* RBRACE;
dictEntryList: dictEntry (COMMA dictEntry)*;
dictEntry: VARIABLE COLON expr
| STRING COLON expr
| NUMBER COLON expr;
breakStmt: BREAK SEMICOLON;
continueStmt: CONTINUE SEMICOLON;
returnStmt: RETURN expr? SEMICOLON;
expr: ternaryExpr | compExpr;
ternaryExpr: compExpr QUESTION expr COLON expr # TernaryExp;
compExpr:
compExpr EQ relationalExpr # EqExp
| compExpr NE relationalExpr # NeExp
| relationalExpr # ToRelational;
relationalExpr:
relationalExpr GT shiftExpr # GtExp
| relationalExpr GE shiftExpr # GeExp
| relationalExpr LT shiftExpr # LtExp
| relationalExpr LE shiftExpr # LeExp
| shiftExpr # ToShift;
addExpr:
addExpr PLUS mulExpr # AddExp
| addExpr MINUS mulExpr # SubExp
| mulExpr # ToMul;
mulExpr:
mulExpr MULT powExpr # MulExp
| mulExpr DIV powExpr # DivExp
| mulExpr MOD powExpr # ModExp
| powExpr # ToPow;
shiftExpr:
shiftExpr LSHIFT addExpr # LShiftExp
| shiftExpr RSHIFT addExpr # RShiftExp
| addExpr # ToAdd;
powExpr: unaryExpr POW powExpr # PowExp | unaryExpr # ToUnary;
unaryExpr:
PLUS unaryExpr # UnaryPlus
| MINUS unaryExpr # UnaryMinus
| indexExpr # ToIndex;
indexExpr:
indexExpr LBRACKET sliceElement (COMMA sliceElement)* RBRACKET # IndexExp
| atom # ToAtom;
sliceElement:
expr COLON expr COLON expr # SliceWithStep
| expr COLON expr # Slice
| COLON expr COLON expr # SliceColonStartStep
| COLON expr # SliceColonStart
| expr COLON COLON expr # SliceExprColonStep
| expr COLON # SliceExpr
| COLON COLON expr # SliceColonStep
| COLON # SliceOnly
| expr # IndexOnly;
// Atoms: function calls, variable, number, constant, or parenthesized expression
atom:
func0 # Func0Exp
| func1 # Func1Exp
| func2 # Func2Exp
| func3 # Func3Exp
| func4 # Func4Exp
| func5 # Func5Exp
| funcN # FuncNExp
| funcNoise # FuncNoiseExp
| VARIABLE # VariableExp
| NUMBER # NumberExp
| CONSTANT # ConstantExp
| STRING # StringExp
| LPAREN paramList RPAREN ARROW (expr | block) # LambdaExp
| LPAREN expr RPAREN # ParenExp
| LPAREN expr RPAREN # ParenExp
| PIPE expr PIPE # AbsExp
| LBRACKET expr (COMMA expr)* RBRACKET # ListExp
| LBRACE dictEntryList? RBRACE # DictExp
| VARIABLE LPAREN exprList? RPAREN # CallExp
| NONE # NoneExp
| BREAK # BreakExp
| CONTINUE # ContinueExp;
exprList: expr (COMMA expr)*;
func0:
/**
timestamp() - returns the current system timestamp
*/
TIMESTAMP LPAREN RPAREN # TimestampFunc;
// Single-argument functions
func1:
/**
sin(x) - applies sine function to value or each element of value
- x: angle in radians (number, list or tensor)
*/
SIN LPAREN expr RPAREN # SinFunc
/**
cos(x) - applies cosine function to value or each element of value
- x: angle in radians (number, list or tensor)
*/
| COS LPAREN expr RPAREN # CosFunc
/**
tan(x) - applies tangent function to value or each element of value
- x: angle in radians (number, list or tensor)
*/
| TAN LPAREN expr RPAREN # TanFunc
/**
asin(x) - applies arcus sine function to value or each element of value
- x: value in -1..1 (number, list or tensor)
*/
| ASIN LPAREN expr RPAREN # AsinFunc
/**
acos(x) - applies arcus cosine function to value or each element of value
- x: value in -1..1 (number, list or tensor)
*/
| ACOS LPAREN expr RPAREN # AcosFunc
/**
atan(x) - applies arcus tangent function to value or each element of value
- x: number, list or tensor; applied to each element
*/
| ATAN LPAREN expr RPAREN # AtanFunc
/**
sinh(x) - applies hyperbolic sine function to value or each element of value
- x: number, list or tensor; applied to each element
*/
| SINH LPAREN expr RPAREN # SinhFunc
/**
cosh(x) - applies hyperbolic cosine function to value or each element of value
- x: number, list or tensor; applied to each element
*/
| COSH LPAREN expr RPAREN # CoshFunc
/**
tanh(x) - applies hyperbolic tangent function to value or each element of value
- x: number, list or tensor; applied to each element
*/
| TANH LPAREN expr RPAREN # TanhFunc
/**
asinh(x) - applies hyperbolic arcus sine function to value or each element of value
- x: number, list or tensor; applied to each element
*/
| ASINH LPAREN expr RPAREN # AsinhFunc
/**
acosh(x) - applies hyperbolic arcus cosine function to value or each element of value
- x: value >= 1 (number, list or tensor)
*/
| ACOSH LPAREN expr RPAREN # AcoshFunc
/**
atanh(x) - applies hyperbolic arcus tangent function to value or each element of value
- x: value in -1..1 (number, list or tensor)
*/
| ATANH LPAREN expr RPAREN # AtanhFunc
/**
abs(x) - applies per element absolute value function. Same as |x| for numbers.
- x: number, list or tensor; applied to each element
*/
| ABS LPAREN expr RPAREN # AbsFunc
/**
sqrt(x) - applies square root per element. Negative numbers return NaN (not a number)
- x: non-negative values (number, list or tensor)
*/
| SQRT LPAREN expr RPAREN # SqrtFunc
/**
ln(x) - applies natural logarithm to value (per element). Negative numbers return NaN (not a number)
- x: positive values (number, list or tensor)
*/
| LN LPAREN expr RPAREN # LnFunc
/**
log(x) - applies base 10 logarithm to value (per element). Negative numbers return NaN (not a number)
- x: positive values (number, list or tensor)
*/
| LOG LPAREN expr RPAREN # LogFunc
/**
log2(x) - applies base 2 logarithm to value (per element). Negative numbers return NaN (not a number)
- x: positive values (number, list or tensor)
*/
| LOG2 LPAREN expr RPAREN # Log2Func
/**
exp(x) - applies e^x to value (per element)
- x: number, list or tensor; applied to each element
*/
| EXP LPAREN expr RPAREN # ExpFunc
/**
log1p(x) - applies ln(1+x) accurately for values near zero
- x: values greater than -1 (number, list or tensor)
*/
| LOG1P LPAREN expr RPAREN # Log1pFunc
/**
expm1(x) - applies exp(x)-1 accurately for values near zero
- x: number, list or tensor; applied to each element
*/
| EXPM1 LPAREN expr RPAREN # Expm1Func
/**
sinc(x) - computes the normalized sinc function sin(pi*x)/(pi*x), with sinc(0)=1
- x: number, list or tensor; applied to each element
*/
| SINC LPAREN expr RPAREN # SincFunc
/**
cbrt(x) - computes the real cube root of each value, including negative values
- x: number, list or tensor; applied to each element
*/
| CBRT LPAREN expr RPAREN # CbrtFunc
/**
reciprocal(x) - computes 1/x element-wise
- x: number, list or tensor; applied to each element
*/
| RECIPROCAL LPAREN expr RPAREN # ReciprocalFunc
/**
isnan(x) - returns 1.0 for NaN values and 0.0 otherwise
- x: number, list or tensor; applied to each element
*/
| ISNAN LPAREN expr RPAREN # IsnanFunc
/**
isinf(x) - returns 1.0 for infinite values and 0.0 otherwise
- x: number, list or tensor; applied to each element
*/
| ISINF LPAREN expr RPAREN # IsinfFunc
/**
isfinite(x) - returns 1.0 for finite values and 0.0 otherwise
- x: number, list or tensor; applied to each element
*/
| ISFINITE LPAREN expr RPAREN # IsfiniteFunc
/**
tnorm(x, [dim]) - normalises tensor or list by multiplication such that sum(x^2)==1.0 for each slice. Defaults to the last dimension; dim selects a different slicing dimension.
- x: tensor or list to normalise
- dim: dimension whose slices are normalised (default: last)
*/
| TNORM LPAREN expr (COMMA expr)? RPAREN # TNormFunc
/**
floor(x) - returns the largest integer less than or equal to x
- x: number, list or tensor; applied to each element
*/
| FLOOR LPAREN expr RPAREN # FloorFunc
/**
ceil(x) - returns the smallest integer greater than or equal to x
- x: number, list or tensor; applied to each element
*/
| CEIL LPAREN expr RPAREN # CeilFunc
/**
round(x) - rounds x to the nearest integer
- x: number, list or tensor; applied to each element
*/
| ROUND LPAREN expr RPAREN # RoundFunc
/**
gamma(x) - computes the gamma function (per element)
- x: number, list or tensor; applied to each element
*/
| GAMMA LPAREN expr RPAREN # GammaFunc
/**
sigm(x) - applies the sigmoid function: 1 / (1 + exp(-x))
- x: number, list or tensor; applied to each element
*/
| SIGM LPAREN expr RPAREN # sigmoidFunc
/**
angle(x) - returns the angle of a complex number or vector
- x: complex or real values (number, list or tensor)
*/
| ANGL LPAREN expr RPAREN # anglFunc
/**
print(x) - prints the value of x to the console while passing output unchanged
- x: value to print; it is also returned unchanged
*/
| PRNT LPAREN expr RPAREN # printFunc
/**
fract(x) - returns the fractional part of x: x - floor(x)
- x: number, list or tensor; applied to each element
*/
| FRACT LPAREN expr RPAREN # FractFunc
/**
relu(x) - applies rectified linear unit function: max(0, x)
- x: number, list or tensor; applied to each element
*/
| RELU LPAREN expr RPAREN # ReluFunc
/**
softsign(x) - applies x / (1 + abs(x)) element-wise
- x: number, list or tensor; applied to each element
*/
| SOFTSIGN LPAREN expr RPAREN # SoftsignFunc
/**
softplus(x) - applies the softplus function: ln(1 + exp(x))
- x: number, list or tensor; applied to each element
*/
| SOFTPLUS LPAREN expr RPAREN # SoftplusFunc
/**
gelu(x) - applies the Gaussian Error Linear Unit (GELU) activation function
- x: number, list or tensor; applied to each element
*/
| GELU LPAREN expr RPAREN # GeluFunc
/**
silu(x) - applies the Sigmoid Linear Unit activation element-wise
- x: number, list or tensor; applied to each element
*/
| SILU LPAREN expr RPAREN # SiluFunc
/**
sign(x) - returns the sign of x: -1, 0, or 1
- x: number, list or tensor; applied to each element
*/
| SIGN LPAREN expr RPAREN # SignFunc
/**
degrees(x) - converts radians to degrees (per element)
- x: angle in radians (number, list or tensor)
*/
| DEGREES LPAREN expr RPAREN # DegreesFunc
/**
radians(x) - converts degrees to radians (per element)
- x: angle in degrees (number, list or tensor)
*/
| RADIANS LPAREN expr RPAREN # RadiansFunc
/**
logical_not(x) - returns 1.0 where x is zero and 0.0 otherwise
- x: values; zero counts as false (number, list or tensor)
*/
| LOGICAL_NOT LPAREN expr RPAREN # LogicalNotFunc
/**
print_shape(x) - prints the shape of the tensor x
- x: value whose shape is printed; it is also returned unchanged
*/
| PRINT_SHAPE LPAREN expr RPAREN # PrintShapeFunc
/**
pinv(permutation) - computes the inverse permutation: where permutation[i] == j the result has result[j] == i. Not the matrix pseudoinverse; use inv(matrix, 1) for that
- permutation: list or tensor holding each index exactly once
*/
| PINV LPAREN expr RPAREN # PinvFunc
/**
inv(x, [pseudo]) - computes the matrix inverse; when pseudo is truthy, computes the Moore-Penrose pseudoinverse instead
- x: matrix, or a batch of matrices in the last two dimensions
- pseudo: truthy to compute the Moore-Penrose pseudoinverse, which also works for singular and non-square matrices (default: false)
*/
| INV LPAREN expr (COMMA expr)? RPAREN # InvFunc
/**
matrix_rank(x, [tol]) - computes the numerical rank of each matrix using optional absolute tolerance tol
- x: matrix, or a batch of matrices in the last two dimensions
- tol: absolute tolerance below which singular values count as zero
*/
| MATRIX_RANK LPAREN expr (COMMA expr)? RPAREN # MatrixRankFunc
/**
sum(x, [dims]) - computes the sum of elements of x, optionally along one or more dimensions
- x: values to add up (number, list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| SUM LPAREN expr (COMMA expr)? RPAREN # SumFunc
/**
mean(x, [dims]) - computes the arithmetic mean of elements of x globally or along one or more dimensions
- x: values to average (number, list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| MEAN LPAREN expr (COMMA expr)? RPAREN # MeanFunc
/**
std(x, [dims]) - computes the sample standard deviation of elements of x globally or along one or more dimensions
- x: values (number, list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| STD LPAREN expr (COMMA expr)? RPAREN # StdFunc
/**
var(x, [dims]) - computes the sample variance of elements of x globally or along one or more dimensions
- x: values (number, list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| VAR LPAREN expr (COMMA expr)? RPAREN # VarFunc
/**
prod(x, [dims]) - computes the product of elements of x globally or along one or more dimensions
- x: values to multiply (number, list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| PROD LPAREN expr (COMMA expr)? RPAREN # ProdFunc
/**
sort(x, [descending], [dim]) - returns x sorted ascending, or descending when descending is truthy. Tensors are sorted along dim (default: last dimension); lists use Python sorting
- x: list or tensor to sort
- descending: truthy to sort from largest to smallest (default: false)
- dim: dimension to sort along (default: last)
*/
| SORT LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # SortFunc
/**
any(x) - returns 1 if any element of x is non-zero otherwise 0
- x: values to test (number, list or tensor)
*/
| ANY LPAREN expr RPAREN # AnyFunc
/**
all(x) - returns 1 if all elements of x are non-zero otherwise 0
- x: values to test (number, list or tensor)
*/
| ALL LPAREN expr RPAREN # AllFunc
/**
edge(x, [kernel_size]) - detects edges in x with a Sobel filter. kernel_size must be odd and at least 3 (default 3).
- x: image or tensor
- kernel_size: odd Sobel kernel size, at least 3 (default: 3)
*/
| EDGE LPAREN expr (COMMA expr)? RPAREN # EdgeFunc
/**
median(x, [dim]) - computes the median globally or along one dimension
- x: values (list or tensor)
- dim: dimension to reduce (default: all elements)
*/
| MEDIAN LPAREN expr (COMMA expr)? RPAREN # MedianFunc
/**
mode(x, [dim]) - computes the mode globally or along one dimension
- x: values (list or tensor)
- dim: dimension to reduce (default: all elements)
*/
| MODE LPAREN expr (COMMA expr)? RPAREN # ModeFunc
/**
cumsum(x, [dim]) - computes the cumulative sum, defaulting to the first dimension.
- x: list or tensor
- dim: dimension to accumulate along (default: 0)
*/
| CUMSUM LPAREN expr (COMMA expr)? RPAREN # CumsumFunc
/**
count(x) - returns the number of elements in x
- x: list, tensor, dictionary or value
*/
| COUNT LPAREN expr RPAREN # CountFunc
/**
keys(dict) - returns a list of dictionary keys in insertion order
- dict: dictionary
*/
| KEYS LPAREN expr RPAREN # KeysFunc
/**
enable_tracking(dict) - enables change tracking for a ChangeTrackingDict and returns it
- dict: ChangeTrackingDict (other values are returned unchanged)
*/
| ENABLE_TRACKING LPAREN expr RPAREN # EnableTrackingFunc
/**
disable_tracking(dict) - disables change tracking for a ChangeTrackingDict and returns it
- dict: ChangeTrackingDict (other values are returned unchanged)
*/
| DISABLE_TRACKING LPAREN expr RPAREN # DisableTrackingFunc
/**
reset_tracking(dict) - resets the change tracking state of a ChangeTrackingDict and returns it
- dict: ChangeTrackingDict (other values are returned unchanged)
*/
| RESET_TRACKING LPAREN expr RPAREN # ResetTrackingFunc
/**
repeat(x, count, [dims]) - repeats tensor elements; count may be scalar or per-dim list
- x: text, list or tensor to repeat
- count: number of repeats, or a list with one count per dimension
- dims: dimension or list of dimensions to repeat along; without it a number repeats each element of the flattened input and a list tiles the whole tensor
*/
| REPEAT LPAREN expr COMMA expr (COMMA expr)? RPAREN # RepeatFunc
/**
cumprod(x) - computes the cumulative product over first dimension.
- x: list or tensor
*/
| CUMPROD LPAREN expr RPAREN # CumprodFunc
/**
stack_pop(slot) - removes and returns the last element of slot stack
- slot: stack number (any integer)
*/
| POP LPAREN expr RPAREN # PopFunc
/**
stack_clear(slot) - clears the contents of slot stack
- slot: stack number (any integer)
*/
| CLEAR LPAREN expr RPAREN # ClearFunc
/**
stack_has(slot) - returns 1.0 if slot exists in stack and is not empty else returns 0.0
- slot: stack number (any integer)
*/
| HAS LPAREN expr RPAREN # HasFunc
/**
stack_get(slot) - returns the last pushed value in slot without popping it
- slot: stack number (any integer)
*/
| GET LPAREN expr RPAREN # GetFunc
/**
argsort(x, [descending], [dim]) - returns the indices that would sort x. descending defaults to false and dim defaults to the last dimension.
- x: list or tensor
- descending: truthy to sort from largest to smallest (default: false)
- dim: dimension to sort along (default: last)
*/
| ARGSORT LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # ArgsortFunc
/**
argmin(x, [as_position], [dim]) - returns the minimum index globally or along dim; as_position returns global coordinates
- x: list or tensor to search
- as_position: truthy to return the coordinates of the minimum instead of a flat index
- dim: dimension to search along; cannot be combined with as_position
*/
| ARGMIN LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # ArgminFunc
/**
argmax(x, [as_position], [dim]) - returns the maximum index globally or along dim; as_position returns global coordinates
- x: list or tensor to search
- as_position: truthy to return the coordinates of the maximum instead of a flat index
- dim: dimension to search along; cannot be combined with as_position
*/
| ARGMAX LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # ArgmaxFunc
/**
softmax(x, [dim]) - applies the softmax function to x (each slice sums to 1.0). dim defaults to the last dimension.
- x: scores (list or tensor)
- dim: dimension whose slices sum to 1 (default: last)
*/
| SOFTMAX LPAREN expr (COMMA expr)? RPAREN # SoftmaxFunc
/**
softmin(x, [dim]) - applies the softmin function to x (same as softmax(-x, [dim])). dim defaults to the last dimension.
- x: scores (list or tensor)
- dim: dimension whose slices sum to 1 (default: last)
*/
| SOFTMIN LPAREN expr (COMMA expr)? RPAREN # SoftminFunc
/**
erf(x) - computes the error function (torch.erf)
- x: number, list or tensor; applied to each element
*/
| ERF LPAREN expr RPAREN # ErfFunc
/**
erfc(x) - computes the complementary error function (torch.special.erfc)
- x: number, list or tensor; applied to each element
*/
| ERFC LPAREN expr RPAREN # ErfcFunc
/**
erfinv(x) - computes the inverse error function (torch.erfinv)
- x: value in -1..1 (number, list or tensor)
*/
| ERFINV LPAREN expr RPAREN # ErfinvFunc
/**
unique(x) - returns the sorted unique elements of x (tensors are flattened first)
- x: list or tensor
*/
| UNIQUE LPAREN expr RPAREN # UniqueFunc
/**
flatten(x) - flattens tensor into a 1D tensor
- x: tensor or nested list
*/
| FLATTEN LPAREN expr RPAREN # FlattenFunc
/**
motion_mask(flow) - generates a motion mask from optical flow
- flow: optical flow [..., 2], e.g. from rife()
*/
| MOTION_MASK LPAREN expr RPAREN # MotionMaskFunc
/**
flow_to_image(flow) - converts optical flow to an RGB image. Up-down is blue-yellow, left-right is green-magenta.
- flow: optical flow [..., 2], e.g. from rife()
*/
| FLOW_TO_IMAGE LPAREN expr RPAREN # FlowToImageFunc
/**
bnot(x) - computes the bitwise NOT
- x: integer values (number, list or tensor)
*/
| BNOT LPAREN expr RPAREN # BitNotFunc
/**
bitcount(x) - returns the number of set bits
- x: integer values (number, list or tensor)
*/
| BITCOUNT LPAREN expr RPAREN # BitCountFunc
/**
shape(x) - returns the shape of tensor as a list
- x: tensor, list or value
*/
| SHAPE LPAREN expr RPAREN # ShapeFunc
/**
upper(text) - converts string to uppercase
- text: text
*/
| UPPER LPAREN expr RPAREN # UpperFunc
/**
lower(text) - converts string to lowercase
- text: text
*/
| LOWER LPAREN expr RPAREN # LowerFunc
/**
trim(text) - removes leading and trailing whitespace from string
- text: text
*/
| TRIM LPAREN expr RPAREN # TrimFunc
/**
entropy(logits) - computes the Shannon entropy (in nats) of softmax(logits) over all elements
- logits: scores (list or tensor)
*/
| ENTROPY LPAREN expr RPAREN # EntropyFunc
/**
fft(x) - computes fast Fourier transform of x
- x: tensor, transformed over all dimensions
*/
| SFFT LPAREN expr RPAREN # SfftFunc
/**
dilate(x, [kernel_size]) - applies morphological dilation to x with a square kernel (default size 3).
- x: mask or image with values 0-1
- kernel_size: size of the square kernel (default: 3)
*/
| DILATE LPAREN expr (COMMA expr)? RPAREN # DilateFunc
/**
erode(x, [kernel_size]) - applies morphological erosion to x with a square kernel (default size 3).
- x: mask or image with values 0-1
- kernel_size: size of the square kernel (default: 3)
*/
| ERODE LPAREN expr (COMMA expr)? RPAREN # ErodeFunc
/**
morph_open(x, [kernel_size]) - applies morphological opening (erosion then dilation) to x with a square kernel (default size 3).
- x: mask or image with values 0-1
- kernel_size: size of the square kernel (default: 3)
*/
| MORPH_OPEN LPAREN expr (COMMA expr)? RPAREN # MorphOpenFunc
/**
morph_close(x, [kernel_size]) - applies morphological closing (dilation then erosion) to x with a square kernel (default size 3).
- x: mask or image with values 0-1
- kernel_size: size of the square kernel (default: 3)
*/
| MORPH_CLOSE LPAREN expr (COMMA expr)? RPAREN # MorphCloseFunc
/**
int(x) - casts x to integer
- x: value to convert; lists convert each item and text is parsed
*/
| INT LPAREN expr RPAREN # IntFunc
/**
float(x) - casts x to float
- x: value to convert; lists convert each item and text is parsed
*/
| FLOAT LPAREN expr RPAREN # FloatFunc
/**
flow_magnitude(flow) - computes the magnitude of optical flow (or any other structure with last dimension of 2)
- flow: optical flow [..., 2], e.g. from rife()
*/
| FLOW_MAG LPAREN expr RPAREN # FlowMagFunc
/**
flow_angle(flow) - computes the angle atan2(dy, dx) of optical flow (like angle(), with real and imaginary parts in the last dimension)
- flow: optical flow [..., 2], e.g. from rife()
*/
| FLOW_ANG LPAREN expr RPAREN # FlowAngFunc
/**
as_nested(values) - converts a list to a nested tensor (special object containing tensors of different shapes behaving like a tensor)
- values: list of tensors; their shapes may differ
*/
| AS_NESTED LPAREN expr RPAREN # AsNestedFunc
/**
svd(x, [full_matrices]) - computes the singular value decomposition of x. Returns a list of 3 tensors U, S, Vh such that x = matmul(matmul(U, diagonal_matrix(S, shape(U))), Vh)
- x: matrix, or a batch of matrices in the last two dimensions
- full_matrices: truthy to return full-size U and Vh (default: false)
*/
| SVD LPAREN expr (COMMA expr)? RPAREN # SvdFunc;
func2:
/**
pow(base, exponent) - computes base raised to the power of exponent
- base: number, list or tensor to raise
- exponent: power to raise base to; tensors broadcast
*/
POWE LPAREN expr COMMA expr RPAREN # PowFunc
/**
atan2(y, x) - computes the arc tangent of y/x, using the signs of both arguments to determine the quadrant
- y: y coordinate (numerator)
- x: x coordinate (denominator)
*/
| ATAN2 LPAREN expr COMMA expr RPAREN # Atan2Func
/**
hypot(x, y) - computes the element-wise Euclidean distance from the origin
- x: first coordinate (number, list or tensor)
- y: second coordinate (number, list or tensor)
*/
| HYPOT LPAREN expr COMMA expr RPAREN # HypotFunc
/**
logaddexp(x, y) - computes log(exp(x) + exp(y)) element-wise using a numerically stable method
- x: first log-space value (number, list or tensor)
- y: second log-space value (number, list or tensor)
*/
| LOGADDEXP LPAREN expr COMMA expr RPAREN # LogaddexpFunc
/**
logical_and(x, y) - returns 1.0 if both values are non-zero, else 0.0
- x: values; non-zero counts as true
- y: values; non-zero counts as true
*/
| LOGICAL_AND LPAREN expr COMMA expr RPAREN # LogicalAndFunc
/**
logical_or(x, y) - returns 1.0 if either value is non-zero, else 0.0
- x: values; non-zero counts as true
- y: values; non-zero counts as true
*/
| LOGICAL_OR LPAREN expr COMMA expr RPAREN # LogicalOrFunc
/**
isclose(a, b, [rtol], [atol]) - elementwise approximate equality test
- a: first values to compare
- b: second values to compare
- rtol: relative tolerance (default: 1e-5)
- atol: absolute tolerance (default: 1e-8)
*/
| ISCLOSE LPAREN expr COMMA expr (COMMA expr (COMMA expr)?)? RPAREN # IscloseFunc
/**
allclose(a, b, [rtol], [atol]) - returns 1.0 if all elements are approximately equal, else 0.0
- a: first values to compare
- b: second values to compare
- rtol: relative tolerance (default: 1e-5)
- atol: absolute tolerance (default: 1e-8)
*/
| ALLCLOSE LPAREN expr COMMA expr (COMMA expr (COMMA expr)?)? RPAREN # AllcloseFunc
/**
tmin(a, b) - element-wise minimum of a and b; min(a, b) for plain numbers
- a: first values; tensors broadcast
- b: second values; tensors broadcast
*/
| TMIN LPAREN expr COMMA expr RPAREN # TMinFunc
/**
tmax(a, b) - element-wise maximum of a and b; max(a, b) for plain numbers
- a: first values; tensors broadcast
- b: second values; tensors broadcast
*/
| TMAX LPAREN expr COMMA expr RPAREN # TMaxFunc
/**
snorm(x, [dim]) - frobenius norm of tensor. Along dimension if dimension specified. Dimension can be a list. Defaults to no dimension.
- x: number, list or tensor
- dim: dimension or list of dimensions to reduce (default: all elements)
*/
| SNORM LPAREN expr (COMMA expr)? RPAREN # SNormFunc
/**
step(x, edge) - returns 0 if x < edge, else 1
- x: values to test (number, list or tensor)
- edge: threshold; the result is 1 where x >= edge, otherwise 0
*/
| STEP LPAREN expr COMMA expr RPAREN # StepFunc
/**
topk(x, k, [dim]) - returns the k largest elements along dim. For tensors it keeps them in place; dim defaults to the last.
- x: list or tensor
- k: number of elements to keep
- dim: dimension to select along (default: last)
*/
| TOPK LPAREN expr COMMA expr (COMMA expr)? RPAREN # TopkFunc
/**
botk(x, k, [dim]) - returns the k smallest elements along dim. For tensors it keeps them in place; dim defaults to the last.
- x: list or tensor
- k: number of elements to keep
- dim: dimension to select along (default: last)
*/
| BOTK LPAREN expr COMMA expr (COMMA expr)? RPAREN # BotkFunc
/**
quartile(x, q, [dim]) - computes the q-th quartile globally or along dim
- x: values (list or tensor)
- q: quartile number 0-4 (0 = minimum, 2 = median, 4 = maximum)
- dim: dimension to reduce (default: all elements)
*/
| QUARTILE LPAREN expr COMMA expr (COMMA expr)? RPAREN # QuartileFunc
/**
percentile(x, p, [dim]) - computes the p-th percentile globally or along dim
- x: values (list or tensor)
- p: percentile 0-100
- dim: dimension to reduce (default: all elements)
*/
| PERCENTILE LPAREN expr COMMA expr (COMMA expr)? RPAREN # PercentileFunc
/**
quantile(x, q, [dim]) - computes the q-th quantile globally or along dim
- x: values (list or tensor)
- q: quantile 0-1
- dim: dimension to reduce (default: all elements)
*/
| QUANTILE LPAREN expr COMMA expr (COMMA expr)? RPAREN # QuantileFunc
/**
dot(x, y) - computes the dot product of x and y after flattening both to 1D. Use cross(x, y) if you need a per-vector product with the last dimension kept.
- x: first tensor; flattened before multiplying
- y: second tensor with the same number of elements
*/
| DOT LPAREN expr COMMA expr RPAREN # DotFunc
/**
outer(x, y) - computes the outer product of flattened x and y
- x: first tensor; flattened first
- y: second tensor; flattened first
*/
| OUTER LPAREN expr COMMA expr RPAREN # OuterFunc
/**
cosine_similarity(x, y) - computes the cosine similarity between x and y.
- x: vectors along the last dimension
- y: vectors along the last dimension
*/
| COSSIM LPAREN expr COMMA expr RPAREN # CossimFunc
/**
startswith(text, prefix) - returns 1 if text starts with prefix, else 0
- text: text to check
- prefix: start to look for
*/
| STARTSWITH LPAREN expr COMMA expr RPAREN # StartswithFunc
/**
endswith(text, suffix) - returns 1 if text ends with suffix, else 0
- text: text to check
- suffix: ending to look for
*/
| ENDSWITH LPAREN expr COMMA expr RPAREN # EndswithFunc
/**
logsumexp(x, [dims]) - computes log(sum(exp(x))) stably, optionally reducing along one or more dimensions
- x: values (list or tensor)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| LOGSUMEXP LPAREN expr (COMMA expr)? RPAREN # LogsumexpFunc
/**
rfft(x, [dim]) - computes the one-dimensional real-input FFT along dim (default: last dimension)
- x: real-valued signal
- dim: dimension to transform (default: last)
*/
| RFFT LPAREN expr (COMMA expr)? RPAREN # RfftFunc
/**
trace(x) - sums the main diagonal of each square matrix in x
- x: matrix, or a batch of matrices in the last two dimensions
*/
| TRACE LPAREN expr RPAREN # TraceFunc
/**
det(x) - computes the determinant of each square matrix in x
- x: matrix, or a batch of matrices in the last two dimensions
*/
| DET LPAREN expr RPAREN # DetFunc
/**
flip(x, dims) - reverses the order of elements along the specified dimensions. Text is reversed as a whole
- x: tensor, list or text
- dims: dimension or list of dimensions to reverse
*/
| FLIP LPAREN expr COMMA expr RPAREN # FlipFunc
/**
cov(x, y) - computes the sample covariance of the flattened x and y (which must have the same number of elements)
- x: first values; flattened
- y: second values with the same number of elements
*/
| COV LPAREN expr COMMA expr RPAREN # CovFunc
/**
correlation(x, y) - computes the Pearson correlation coefficient between x and y
- x: first values
- y: second values
*/
| CORR LPAREN expr COMMA expr RPAREN # CorrFunc
/**
append(list, item) - adds item to the end of list. To join tensors along a dimension use concatenate(...)
- list: list, tensor or value to extend
- item: item, list or tensor added to the end of list
*/
| APPEND LPAREN expr COMMA expr RPAREN # AppendFunc
/**
add_key(dict, key, value) - adds or replaces a dictionary entry and returns the updated dictionary
- dict: dictionary to change; it is also returned
- key: entry name
- value: entry value
*/
| ADD_KEY LPAREN expr COMMA expr COMMA expr RPAREN # AddKeyFunc
/**
permute(x, dims) - permutes the dimensions of tensor x according to dims
- x: tensor
- dims: new order of the dimensions, e.g. [0, 2, 1]
*/
| PERM LPAREN expr COMMA expr RPAREN # PermuteFunc
/**
gaussian(x, sigma, [auto_channels]) - applies a separable Gaussian blur to x. Channels are expected last unless auto_channels is truthy
- x: image or tensor to blur
- sigma: blur strength as the standard deviation in elements; 0 or less returns x unchanged
- auto_channels: truthy to find the channel dimension automatically; otherwise channels must be last (default: false)
*/
| GAUSSIAN LPAREN expr COMMA expr (COMMA expr)? RPAREN # GaussianFunc
/**
topk_indices(x, k, [dim]) - returns the indices of the k largest elements along dim; without dim, returns indices into flatten(x)
- x: list or tensor
- k: number of indices to return
- dim: dimension to select along (default: indices into flatten(x))
*/
| TOPK_IND LPAREN expr COMMA expr (COMMA expr)? RPAREN # TopkIndFunc
/**
botk_indices(x, k, [dim]) - returns the indices of the k smallest elements along dim; without dim, returns indices into flatten(x)
- x: list or tensor
- k: number of indices to return
- dim: dimension to select along (default: indices into flatten(x))
*/
| BOTK_IND LPAREN expr COMMA expr (COMMA expr)? RPAREN # BotkIndFunc
/**
batch_shuffle(x, indices) - shuffles and duplicates or skips the batch dimension of x according to indices
- x: tensor whose first dimension is the batch
- indices: batch indices to take, in order; batches may repeat or be skipped
*/
| BATCH_SHUFFLE LPAREN expr COMMA expr RPAREN # BatchShuffleFunc
/**
stack_push(slot, val) - pushes val onto the end of slot stack
- slot: stack number (any integer)
- val: value to push; it is also returned
*/
| PUSH LPAREN expr COMMA expr RPAREN # PushFunc
/**
get_value(tensor, position) - reads the value at an N-D position of tensor. Superseded by tensor[position] indexing
- tensor: tensor to read from
- position: list with one index per dimension
*/
| GET_VALUE LPAREN expr COMMA expr RPAREN # GetValueFunc
/**
tensor(shape, [value], [dtype_template]) - creates a tensor with specified shape and optional value/type. Default value is 0 and default format FP32
- shape: list of dimension sizes
- value: fill value (default: 0)
- dtype_template: tensor whose dtype the result uses (default: float32)
*/
| TENSOR LPAREN indexExpr (COMMA expr (COMMA expr)? )? RPAREN # EmptyTensorFunc
/**
zeros(shape, [dtype_template]) - creates a zero-filled tensor on the current device
- shape: list of dimension sizes
- dtype_template: tensor whose dtype the result uses (default: float32)
*/
| ZEROS LPAREN expr (COMMA expr)? RPAREN # ZerosFunc
/**
ones(shape, [dtype_template]) - creates a one-filled tensor on the current device
- shape: list of dimension sizes
- dtype_template: tensor whose dtype the result uses (default: float32)
*/
| ONES LPAREN expr (COMMA expr)? RPAREN # OnesFunc
/**
eye(n, [dtype_template]) - creates an n-by-n identity matrix
- n: number of rows and columns
- dtype_template: tensor whose dtype the result uses (default: float32)
*/
| EYE LPAREN expr (COMMA expr)? RPAREN # EyeFunc
/**
one_hot(indices, classes) - converts integer class indices to float32 one-hot vectors
- indices: integer class indices
- classes: number of classes, i.e. the length of each one-hot vector
*/
| ONE_HOT LPAREN expr COMMA expr RPAREN # OneHotFunc
/**
mse(a, b, [reduction]) - mean squared error; reduction is mean (default), sum, or none
- a: first values (broadcast against b)
- b: second values
- reduction: "mean" (default), "sum", or "none" for element-wise values
*/
| MSE LPAREN expr COMMA expr (COMMA expr)? RPAREN # MseFunc
/**
mae(a, b, [reduction]) - mean absolute error; reduction is mean (default), sum, or none
- a: first values (broadcast against b)
- b: second values
- reduction: "mean" (default), "sum", or "none" for element-wise values
*/
| MAE LPAREN expr COMMA expr (COMMA expr)? RPAREN # MaeFunc
/**
psnr(a, b, [data_range]) - peak signal-to-noise ratio in dB; data_range defaults to 1
- a: first image
- b: second image
- data_range: difference between the largest and smallest possible value (default: 1)
*/
| PSNR LPAREN expr COMMA expr (COMMA expr)? RPAREN # PsnrFunc
/**
weighted_mean(x, weights, [dims]) - computes the weighted mean globally or along one or more dimensions
- x: values (list or tensor)
- weights: weight of each element, broadcast against x
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
| WEIGHTED_MEAN LPAREN expr COMMA expr (COMMA expr)? RPAREN # WeightedMeanFunc
/**
huber_loss(prediction, target, [delta], [reduction]) - computes Huber loss; delta defaults to 1 and reduction to mean
- prediction: predicted values
- target: expected values
- delta: error size where the loss changes from quadratic to linear (default: 1)
- reduction: "mean" (default), "sum", or "none" for element-wise values
*/
| HUBER_LOSS LPAREN expr COMMA expr (COMMA expr (COMMA expr)?)? RPAREN # HuberLossFunc
/**
cross_entropy(logits, target, [dim], [reduction]) - computes cross-entropy from class logits and class indices or target probabilities
- logits: unnormalised class scores
- target: class indices, or class probabilities with the same shape as logits
- dim: class dimension (default: 1, or 0 for a single vector)
- reduction: "mean" (default), "sum", or "none" for element-wise values
*/
| CROSS_ENTROPY LPAREN expr COMMA expr (COMMA expr (COMMA expr)?)? RPAREN # CrossEntropyFunc
/**
leaky_relu(x, [negative_slope]) - applies leaky ReLU element-wise; negative_slope defaults to 0.01
- x: number, list or tensor; applied to each element
- negative_slope: slope used for negative inputs (default: 0.01)
*/
| LEAKY_RELU LPAREN expr (COMMA expr)? RPAREN # LeakyReluFunc
/**
pad(x, padding) - pads tensor x with specified padding (dim 0 neg, dim 0 pos, dim 1 ...)
- x: tensor to pad
- padding: amounts as [dim0_before, dim0_after, dim1_before, dim1_after, ...]
*/
| PAD LPAREN expr COMMA expr RPAREN # PadFunc
/**
cross(x, y) - computes the cross product of x and y. Last dimension must be 3
- x: vectors with 3 components in the last dimension
- y: vectors with 3 components in the last dimension
*/
| CROSS LPAREN expr COMMA expr RPAREN # CrossFunc
/**
matmul(x, y) - computes the matrix multiplication of x and y
- x: left matrix or batch of matrices
- y: right matrix or batch of matrices
*/
| MATMUL LPAREN expr COMMA expr RPAREN # MatmulFunc
/**
solve(A, b) - solves the square linear system A*x=b without explicitly forming A inverse
- A: square coefficient matrix
- b: right-hand side
*/
| SOLVE LPAREN expr COMMA expr RPAREN # SolveFunc
/**
flow_apply(image, flow) - applies optical flow to an image
- image: image to warp
- flow: per-pixel displacement [..., 2], e.g. from rife()
*/
| FLOW_APPLY LPAREN expr COMMA expr RPAREN # FlowApplyFunc
/**
rife(image1, image2, [tiling_size], [iterations], [multi_scale]) - computes the optical flow field ([H, W, 2]) between image1 and image2 using a RAFT-based model
- image1: first frame
- image2: second frame
- tiling_size: splits the image to overlapping tiling_size*tiling_size parts to conserve memory. Default is 0 (auto: enables 1024x1024 tiling when over 2MPx). When tiling_size is between 0 - 1 it takes as a fraction of the resolution
- iterations: how many times to run the flow model. Default 12
- multi_scale: also use low resolution of base image for giant movements. Default false
*/
| RIFE LPAREN expr COMMA expr (COMMA expr (COMMA expr (COMMA expr)?)?)? RPAREN # RifeFunc
/**
bitwise_and(x, y) - computes the element-wise bitwise AND of x and y
- x: integer values (number, list or tensor)
- y: integer values (number, list or tensor)
*/
| BAND LPAREN expr COMMA expr RPAREN # BitAndFunc
/**
bitwise_xor(x, y) - computes the element-wise bitwise XOR of x and y
- x: integer values (number, list or tensor)
- y: integer values (number, list or tensor)
*/
| XOR LPAREN expr COMMA expr RPAREN # BitXorFunc
/**
bitwise_or(x, y) - computes the element-wise bitwise OR of x and y
- x: integer values (number, list or tensor)
- y: integer values (number, list or tensor)
*/
| BOR LPAREN expr COMMA expr RPAREN # BitOrFunc
/**
split(text, [delimiter]) - splits string to list of strings based on delimiter. Default is space.
- text: text to split
- delimiter: text to split on (default: a space)
*/
| SPLIT LPAREN expr (COMMA expr)? RPAREN # SplitFunc
/**
join(items, [separator]) - joins items as text using separator (default ""). Use concatenate(...) to join tensors
- items: list or tensor of items to join
- separator: text placed between the items (default: "")
*/
| JOIN LPAREN expr (COMMA expr)? RPAREN # JoinFunc
/**
substring(text, start, [length]) - returns length characters of text starting at start. If length is not supplied, it returns the rest of the string
- text: source text
- start: index of the first character
- length: number of characters (default: the rest of the text)
*/
| SUBSTRING LPAREN expr COMMA expr (COMMA expr)? RPAREN # SubstringFunc
/**
find(text, search) - returns the index of the first occurrence of search in text, or -1 if it is not found
- text: text to search in
- search: text to look for
*/
| FIND LPAREN expr COMMA expr RPAREN # FindFunc
/**
replace(value, old, new) - replaces every occurrence of old with new; works on text, lists and tensors
- value: text, list or tensor
- old: text or value to look for
- new: replacement
*/
| REPLACE LPAREN expr COMMA expr COMMA expr RPAREN # ReplaceFunc
/**
int_to_rgb(color) - unpacks 0xRRGGBB integers into 0-1 RGB colors. Tensors get R, G, B stacked in a new last dimension, lists return a list of colors and a number returns a 3-item list
- color: packed 0xRRGGBB integer, list or tensor
*/
| INT_TO_RGB LPAREN expr RPAREN # Int_to_rgbFunc
/**
rgb_to_int(rgb) / rgb_to_int(r, g, b) - packs 0-1 RGB components into 0xRRGGBB integers. With one argument the last dimension (or a 3-item list) holds R, G, B; with three, each argument is one channel
- rgb: colors with R, G, B (0-1) in the last dimension, or a 3-item list
- r: red channel 0-1
- g: green channel 0-1
- b: blue channel 0-1
*/
| RGB_TO_INT LPAREN expr ( COMMA expr COMMA expr)? RPAREN # Rgb_to_intFunc
/**
interpolate_linear(x, scale) - resizes x [N, C, ...] with (bi/tri)linear interpolation. A number scales every spatial dimension; a list is the target spatial size
- x: tensor shaped [N, C, ...] with 1-3 spatial dimensions
- scale: a number scales every spatial dimension; a list gives the target spatial size
*/
| INTERPOLATE_LINEAR LPAREN expr COMMA expr RPAREN # InterpolateLinearFunc
/**
interpolate_area(x, scale) - resizes x [N, C, ...] with area interpolation. A number scales every spatial dimension; a list is the target spatial size
- x: tensor shaped [N, C, ...] with 1-3 spatial dimensions
- scale: a number scales every spatial dimension; a list gives the target spatial size
*/
| INTERPOLATE_AREA LPAREN expr COMMA expr RPAREN # InterpolateAreaFunc
/**
interpolate_nearest_exact(x, scale) - resizes x [N, C, ...] with nearest-neighbour interpolation. A number scales every spatial dimension; a list is the target spatial size
- x: tensor shaped [N, C, ...] with 1-3 spatial dimensions
- scale: a number scales every spatial dimension; a list gives the target spatial size
*/
| INTERPOLATE_NEAREST LPAREN expr COMMA expr RPAREN # InterpolateNearestExactFunc
/**
remove_key(dict, key) - removes a dictionary entry and returns the updated dictionary
- dict: dictionary to change; it is also returned
- key: entry name to remove; missing keys are ignored
*/
| REMOVE_KEY LPAREN expr COMMA expr RPAREN # RemoveKeyFunc;
func3:
/**
clamp(x, min, max) - clamps x between min and max per element
- x: number, list or tensor; applied to each element
- min: lower bound
- max: upper bound
*/
CLAMP LPAREN expr COMMA expr COMMA expr RPAREN # ClampFunc
/**
lerp(a, b, t) - linear interpolation between a and b by t per element. t can be float or tensor.
- a: value at t = 0
- b: value at t = 1
- t: progress from 0 (gives a) to 1 (gives b)
*/
| LERP LPAREN expr COMMA expr COMMA expr RPAREN # LerpFunc
/**
smoothstep(x, edge0, edge1) - smooth interpolation between edge0 and edge1
- x: input values
- edge0: value mapped to 0
- edge1: value mapped to 1
*/
| SMOOTHSTEP LPAREN expr COMMA expr COMMA expr RPAREN # SmoothstepFunc
/**
transpose(x, dim0, dim1) / swapaxes(x, dim0, dim1) - swaps two tensor dimensions
- x: tensor
- dim0: first dimension to swap
- dim1: second dimension to swap
*/
| TRANSPOSE LPAREN expr COMMA expr COMMA expr RPAREN # TransposeFunc
/**
range(start, stop, step) - creates a range of values between start (inclusive) and stop (exclusive) using step. Use linspace if you want value count.
- start: first value
- stop: end of the range (not included)
- step: distance between consecutive values
*/
| RANGE LPAREN expr COMMA expr COMMA expr RPAREN # RangeFunc
/**
moment(x, center, order) - computes the order-th moment of x around center: mean((x - center)^order)
- x: values (list or tensor)
- center: centre the moment is taken around
- order: order of the moment
*/
| MOMENT LPAREN expr COMMA expr COMMA expr RPAREN # MomentFunc
/**
cubic_ease(a, b, t) - cubic ease between a and b
- a: value at t = 0
- b: value at t = 1
- t: progress from 0 (gives a) to 1 (gives b)
*/
| CUBIC_EASE LPAREN expr COMMA expr COMMA expr RPAREN # CubicEaseFunc
/**
elastic_ease(a, b, t) - elastic ease between a and b
- a: value at t = 0
- b: value at t = 1
- t: progress from 0 (gives a) to 1 (gives b)
*/
| ELASTIC_EASE LPAREN expr COMMA expr COMMA expr RPAREN # ElasticEaseFunc
/**
sine_ease(a, b, t) - sine easing between a and b
- a: value at t = 0
- b: value at t = 1
- t: progress from 0 (gives a) to 1 (gives b)
*/
| SINE_EASE LPAREN expr COMMA expr COMMA expr RPAREN # SineEaseFunc
/**
smootherstep(x, edge0, edge1) - smoother interpolation between edge0 and edge1
- x: input values
- edge0: value mapped to 0
- edge1: value mapped to 1
*/
| SMOOTHERSTEP LPAREN expr COMMA expr COMMA expr RPAREN # SmootherstepFunc
/**
crop(x, start, size) - crops the region of x beginning at start (the low corner). The result always has shape size; parts outside x are zero-filled. On text, returns at most size characters
- x: tensor or text
- start: low corner of the region, one index per dimension
- size: size of the result, one value per dimension
*/
| CROP LPAREN expr COMMA expr COMMA expr RPAREN # CropFunc
/**
ifft(x, [shape]) - inverse fast Fourier transform of x. shape (defaults to the node's tensor shape) sizes the K/Kx/Ky/.../frequency variables made available while evaluating x, it does not resize x itself.
- x: spectrum to transform back; may use the K/Kx/Ky/frequency variables
- shape: shape used for the K/Kx/Ky frequency variables (default: the node's input shape)
*/
| SIFFT LPAREN expr (COMMA expr)? RPAREN # SifftFunc
/**
irfft(x, [n], [dim]) - computes the inverse one-dimensional real FFT along dim (default: last dimension)
- x: complex half-spectrum, e.g. from rfft()
- n: length of the output signal (default: 2 * (input length - 1))
- dim: dimension to transform (default: last)
*/
| IRFFT LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # IrfftFunc
/**
overlay(base, overlay, offset, [opacity]) - overlays overlay on base at offset. Opacity controls blending. It can be tensor or float. If it is tensor it should be the same shape as overlay.
- base: background value, list, text or tensor
- overlay: value placed on top of base
- offset: position of the overlay's low corner in base, one value per dimension
- opacity: 0-1 blend amount; a number or a tensor shaped like overlay (default: 1)
*/
| OVERLAY LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # OverlayFunc
/**
linspace(start, stop, count) - creates count evenly spaced values from start to stop (both included). Use range to control the step instead.
- start: first value
- stop: last value (included)
- count: number of values
*/
| LINSPACE LPAREN expr COMMA expr COMMA expr RPAREN # LinspaceFunc
/**
roll(x, shifts, [dim]) - circularly shifts tensor x along dim (default 0)
- x: tensor
- shifts: number of places to shift; elements pushed off one end come back at the other
- dim: dimension to shift along (default: 0)
*/
| ROLL LPAREN expr COMMA expr (COMMA expr)? RPAREN # RollFunc
/**
rgb_to_oklab(rgb) / rgb_to_oklab(r, g, b) - converts 0-1 sRGB to OKLab. With one argument its last dimension holds R, G, B; with three, the channels are stacked into the last dimension of the result
- rgb: sRGB colors (0-1) with R, G, B in the last dimension, or a 3-item list
- r: red channel 0-1
- g: green channel 0-1
- b: blue channel 0-1
*/
| RGB_TO_OKLAB LPAREN expr (COMMA expr COMMA expr)? RPAREN # RgbToOklabFunc
/**
rgb_to_cielab(rgb) / rgb_to_cielab(r, g, b) - converts 0-1 sRGB to CIELAB (D65) divided by 100, so L is 0-1. With one argument its last dimension holds R, G, B; with three, the channels are stacked into the last dimension of the result
- rgb: sRGB colors (0-1) with R, G, B in the last dimension, or a 3-item list
- r: red channel 0-1
- g: green channel 0-1
- b: blue channel 0-1
*/
| RGB_TO_CIELAB LPAREN expr (COMMA expr COMMA expr)? RPAREN # RgbToCielabFunc
/**
rgb_to_hsv(rgb, [degrees]) / rgb_to_hsv(r, g, b, [degrees]) - converts RGB to HSV. With one color argument its last dimension holds R, G, B; with three, the channels are stacked into the last dimension of the result. If degrees is truthy, hue is 0-360 instead of 0-1
- rgb: colors (0-1) with R, G, B in the last dimension, or a 3-item list
- degrees: truthy to use hue in 0-360 instead of 0-1
- r: red channel 0-1
- g: green channel 0-1
- b: blue channel 0-1
*/
| RGB_TO_HSV LPAREN expr (COMMA expr COMMA expr)? (COMMA expr)? RPAREN # RgbToHsvFunc
/**
hsv_to_rgb(hsv, [degrees]) / hsv_to_rgb(h, s, v, [degrees]) - converts HSV to RGB. With one color argument its last dimension holds H, S, V; with three, the channels are stacked into the last dimension of the result. If degrees is truthy, hue is read as 0-360 instead of 0-1
- hsv: colors with H, S, V in the last dimension, or a 3-item list
- degrees: truthy to use hue in 0-360 instead of 0-1
- h: hue 0-1 (0-360 with degrees)
- s: saturation 0-1
- v: value (brightness) 0-1
*/
| HSV_TO_RGB LPAREN expr (COMMA expr COMMA expr)? (COMMA expr)? RPAREN # HsvToRgbFunc
/**
where(condition, if_true, if_false) - returns if_true where condition is non-zero, otherwise if_false. Runs per element
- condition: non-zero selects if_true, zero selects if_false
- if_true: value used where condition is non-zero
- if_false: value used where condition is zero
*/
| WHERE LPAREN expr COMMA expr COMMA expr RPAREN # WhereFunc
/**
oklab_to_rgb(oklab) / oklab_to_rgb(l, a, b) - converts OKLab to 0-1 sRGB. With one argument its last dimension holds L, a, b; with three, the channels are stacked into the last dimension of the result
- oklab: OKLab colors with L, a, b in the last dimension, or a 3-item list
- l: lightness
- a: green-red axis
- b: blue-yellow axis
*/
| OKLAB_TO_RGB LPAREN expr (COMMA expr COMMA expr)? RPAREN # OklabToRgbFunc
/**
cielab_to_rgb(cielab) / cielab_to_rgb(l, a, b) - converts CIELAB divided by 100 (as returned by rgb_to_cielab) to 0-1 sRGB. With one argument its last dimension holds L, a, b; with three, the channels are stacked into the last dimension of the result
- cielab: CIELAB colors / 100 with L, a, b in the last dimension, or a 3-item list
- l: lightness / 100 (0-1)
- a: green-red axis / 100
- b: blue-yellow axis / 100
*/
| CIELAB_TO_RGB LPAREN expr (COMMA expr COMMA expr)? RPAREN # CielabToRgbFunc
/**
text_image(text, font, size, [max_width], [weight], [rotation_angle], [line_spacing], [italic], [underline]) - renders text to a 2D tensor with values 0-1
- text: text to render; line breaks start new lines
- font: font name to look up in the system fonts, or a path to a font file
- size: font size in pixels
- max_width: wrap lines wider than this many pixels (default: 0, no wrapping)
- weight: font weight 100-900 as in CSS (default: 400)
- rotation_angle: rotation in degrees, counter-clockwise (default: 0)
- line_spacing: line distance as a multiple of the line height (default: 1)
- italic: truthy for italic text (default: false)
- underline: truthy to underline the text (default: false)
*/
| TEXT_IMAGE LPAREN expr COMMA expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # TextImageFunc
/**
coords(shape, dim, [dtype_template]) - generates a tensor with the specified shape whose values are the coordinates of each element along dim. An optional tensor supplies the output dtype (default float32).
- shape: list of dimension sizes
- dim: dimension whose index becomes the value
- dtype_template: tensor whose dtype the result uses (default: float32)
*/
| COORDS LPAREN expr COMMA expr (COMMA expr)? RPAREN # CoordsFunc
/**
gather(x, dim, indices) - gathers elements of x along dim at the given indices. The result has the shape of indices.
- x: source tensor
- dim: dimension to gather along
- indices: indices along dim; the result has their shape
*/
| GATHER LPAREN expr COMMA expr COMMA expr RPAREN # GatherFunc
/**
scatter(x, dim, indices, src) - writes the elements of src into x along dim at the given indices. The result has the shape of x.
- x: tensor to write into
- dim: dimension to scatter along
- indices: position along dim for each element of src
- src: values to write
*/
| SCATTER LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # ScatterFunc
/**
scatter_add(x, dim, indices, src) - adds the elements of src into x along dim at the given indices. The result has the shape of x.
- x: tensor to add into
- dim: dimension to scatter along
- indices: position along dim for each element of src
- src: values to add
*/
| SCATTER_ADD LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # ScatterAddFunc;
func4:
/**
swap(x, dim, index1, index2) - swaps the elements at index1 and index2 along dim
- x: tensor
- dim: dimension to swap along
- index1: first position
- index2: second position
*/
SWAP LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # SwapFunc
/**
nan_to_num(x, nan, pos_inf, neg_inf) - replaces NaN, +inf and -inf in x with the given values (named after SQL NVL)
- x: values to clean
- nan: replacement for NaN
- pos_inf: replacement for +infinity
- neg_inf: replacement for -infinity
*/
| NVL LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # NvlFunc
/**
logspace(start, stop, count, base) - creates count values from base^start to base^stop, evenly spaced in the exponent
- start: exponent of the first value
- stop: exponent of the last value
- count: number of values
- base: base of the exponent
*/
| LOGSPACE LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # LogspaceFunc
/**
distance(x1, y1, x2, y2) - computes Euclidean distance between (x1, y1) and (x2, y2)
- x1: x of the first point
- y1: y of the first point
- x2: x of the second point
- y2: y of the second point
*/
| DIST LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # DistFunc
/**
histogram(x, bins, min, max) - counts the elements of flatten(x) in bins equal-width bins over [min, max]
- x: values; flattened
- bins: number of equal-width bins
- min: lower edge of the first bin
- max: upper edge of the last bin
*/
| HISTOGRAM LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN # HistogramFunc;
func5:
/**
remap(x, in_min, in_max, out_min, out_max) - remaps values from input range to output range
- x: values to remap (number, list or tensor)
- in_min: start of the input range
- in_max: end of the input range
- out_min: value in_min maps to
- out_max: value in_max maps to
*/
REMAP LPAREN expr COMMA expr COMMA expr COMMA expr COMMA expr RPAREN # RemapFunc
/**
diagonal_matrix(values, shape, [offset], [dim1], [dim2]) - creates a tensor of the given shape with values on a diagonal and zeros elsewhere
- values: values placed on the diagonal
- shape: shape of the result
- offset: diagonal offset: positive above, negative below the main diagonal (default: 0)
- dim1: first dimension of the matrix (default: -2)
- dim2: second dimension of the matrix (default: -1)
*/
| DIAG LPAREN expr COMMA expr (COMMA expr (COMMA expr (COMMA expr)?)?)? RPAREN # DiagonalMatrixFunc;
// N-argument functions
funcN:
/**
norm(x, [p], [dims]) - computes the p-norm globally or along one or more dimensions (default p=2)
- x: number, list or tensor
- p: norm order (default: 2)
- dims: dimension or list of dimensions to reduce (default: all elements)
*/
NORM LPAREN expr (COMMA expr (COMMA expr)?)? RPAREN # NormFunc
/**
slerp(a, b, t, [dim]) - interpolates vector directions spherically and magnitudes linearly. Without dim, all elements form one vector; dim selects a vector-component axis and other axes identify independent vectors.
- a: vectors at t = 0
- b: vectors at t = 1
- t: progress from 0 (gives a) to 1 (gives b)
- dim: dimension holding the vector components (default: all elements form one vector)
*/
| SLERP LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # SlerpFunc
/**
normalize(x, [p], [dim], [eps]) - normalizes x along dim using the p-norm (defaults: p=2, dim=-1, eps=1e-12)
- x: list or tensor
- p: norm order (default: 2)
- dim: dimension to work along (default: last)
- eps: smallest allowed divisor (default: 1e-12)
*/
| NORMALIZE LPAREN expr (COMMA expr (COMMA expr (COMMA expr)?)?)? RPAREN # NormalizeFunc
/**
group_norm(x, groups, [weight], [bias], [eps]) - applies channel-first GroupNorm to [N, C, ...] input
- x: tensor shaped [N, C, ...]
- groups: number of channel groups; must divide the channel count
- weight: per-channel scale, length C (default: none)
- bias: per-channel shift, length C (default: none)
- eps: value added to the variance for stability (default: 1e-5)
*/
| GROUP_NORM LPAREN expr COMMA expr (COMMA expr (COMMA expr (COMMA expr)?)?)? RPAREN # GroupNormFunc
/**
smin(x, ...) - computes the minimum of inputs or elements. Tensors must have the same size or be broadcastable to same size. When called as smin(x, dims) with x a tensor/list, reduces x along dims (a single dim or list of dims) instead.
- x: values; one list or tensor gives its smallest element, several values give the smallest of all
*/
| SMIN LPAREN expr (COMMA expr)* RPAREN # SMinFunc
/**
smax(x, ...) - computes the maximum of inputs or elements. Tensors must have the same size or be broadcastable to same size. When called as smax(x, dims) with x a tensor/list, reduces x along dims (a single dim or list of dims) instead.
- x: values; one list or tensor gives its largest element, several values give the largest of all
*/
| SMAX LPAREN expr (COMMA expr)* RPAREN # SMaxFunc
/**
map(tensor, coord1, [coord2], [coord3]) - samples/remaps input tensor using coordinates
- tensor: tensor to sample from
- coord1: sample positions (element indices) along the first mapped dimension; mapped dimensions are the last ones of tensor
- coord2: sample positions along the second mapped dimension
- coord3: sample positions along the third mapped dimension
*/
| MAP LPAREN expr COMMA expr (COMMA expr (COMMA expr)?)? RPAREN # MapFunc
/**
ezconvolution(tensor, size_x, kernel) / ezconvolution(tensor, size_x, size_y, kernel) / ezconvolution(tensor, size_x, size_y, size_z, kernel) - convolves tensor with a 1D, 2D or 3D kernel, guessing whether channels come first or last. kernel is evaluated over the kernel grid with kx/ky/kz coordinates
- tensor: input, channels first or last
- size_x: kernel size along the first spatial dimension
- kernel: expression for the kernel weights, evaluated over the kernel grid with kx/ky/kz offsets from its centre
- size_y: kernel size along the second spatial dimension
- size_z: kernel size along the third spatial dimension
*/
| EZCONV LPAREN expr (COMMA expr)+ RPAREN # EzConvFunc
/**
convolution(tensor, size_x, kernel) / convolution(tensor, size_x, size_y, kernel) / convolution(tensor, size_x, size_y, size_z, kernel) - convolves tensor [batch, channel, spatial...] with a 1D, 2D or 3D kernel. kernel is evaluated over the kernel grid with kx/ky/kz coordinates
- tensor: input shaped [batch, channel, spatial...]
- size_x: kernel size along the first spatial dimension
- kernel: expression for the kernel weights, evaluated over the kernel grid with kx/ky/kz offsets from its centre
- size_y: kernel size along the second spatial dimension
- size_z: kernel size along the third spatial dimension
*/
| CONV LPAREN expr (COMMA expr)+ RPAREN # ConvFunc
/**
reshape(x, shape) - reshapes tensor x to the specified shape
- x: tensor
- shape: new shape; the total number of elements must stay the same
*/
| RESHAPE LPAREN expr COMMA expr RPAREN # ReshapeFunc
/**
squeeze(x, [dim]) - removes size-1 dimensions from tensor x, optionally at dim
- x: tensor
- dim: only remove this dimension, if it has size 1
*/
| SQUEEZE LPAREN expr (COMMA expr)? RPAREN # SqueezeFunc
/**
unsqueeze(x, dim) - inserts a size-1 dimension into tensor x at dim
- x: tensor
- dim: position of the new size-1 dimension
*/
| UNSQUEEZE LPAREN expr COMMA expr RPAREN # UnsqueezeFunc
/**
concatenate(x, ..., dim) - concatenates one or more tensors along the specified dimension
- x: first tensor or list; more may follow before dim
- dim: dimension to join along (the last argument)
*/
| CONCAT LPAREN expr (COMMA expr)+ RPAREN # ConcatFunc
/**
stack(tensors, [dim]) - stacks a list of tensors along a new dimension
- tensors: list of tensors with equal shapes
- dim: position of the new dimension (default: 0)
*/
| STACK LPAREN expr (COMMA expr)? RPAREN # StackFunc
/**
nonzero(x) - returns an N-by-rank tensor of coordinates for nonzero elements
- x: tensor
*/
| NONZERO LPAREN expr RPAREN # NonzeroFunc
/**
get_changed_keys(dict) - returns the keys that were modified or added in a ChangeTrackingDict
- dict: ChangeTrackingDict
*/
| GET_CHANGED_KEYS LPAREN expr RPAREN # GetChangedKeysFunc
/**
get_added_keys(dict) - returns the keys that were newly added to a ChangeTrackingDict
- dict: ChangeTrackingDict
*/
| GET_ADDED_KEYS LPAREN expr RPAREN # GetAddedKeysFunc
/**
get_removed_keys(dict) - returns the keys that were removed from a ChangeTrackingDict
- dict: ChangeTrackingDict
*/
| GET_REMOVED_KEYS LPAREN expr RPAREN # GetRemovedKeysFunc
/**
get_unchanged_keys(dict) - returns the keys that are unchanged in a ChangeTrackingDict
- dict: ChangeTrackingDict
*/
| GET_UNCHANGED_KEYS LPAREN expr RPAREN # GetUnchangedKeysFunc;
funcNoise:
/**
random_normal(seed, [shape]) - generates normally distributed random noise
- seed: random seed; the same seed always gives the same values
- shape: output shape as a list (default: the shape of the node's input)
*/
NOISE LPAREN expr (COMMA expr)? RPAREN # NoiseFunc
/**
pink_noise(seed, [shape]) - generates deterministic pink noise (approximately 1/f power spectrum) with zero mean and unit variance per row
- seed: random seed; the same seed always gives the same values
- shape: output shape as a list (default: the shape of the node's input)
*/
| PINK_NOISE LPAREN expr (COMMA expr)? RPAREN # PinkNoiseFunc
/**
brown_noise(seed, [shape]) - generates deterministic brown noise (approximately 1/f^2 power spectrum) with zero mean and unit variance per row
- seed: random seed; the same seed always gives the same values
- shape: output shape as a list (default: the shape of the node's input)
*/
| BROWN_NOISE LPAREN expr (COMMA expr)? RPAREN # BrownNoiseFunc
/**
random_uniform(seed, [shape]) - generates uniformly distributed random noise
- seed: random seed; the same seed always gives the same values
- shape: output shape as a list (default: the shape of the node's input)
*/
| RAND LPAREN expr (COMMA expr)? RPAREN # RandFunc
/**
random_exponential(seed, rate, [shape]) - generates exponentially distributed random values
- seed: random seed; the same seed always gives the same values
- rate: events per unit; the mean is 1 / rate
- shape: output shape as a list (default: the shape of the node's input)
*/
| EXPONENTIAL LPAREN expr COMMA expr (COMMA expr)? RPAREN # ExponentialFunc
/**
random_bernoulli(seed, probability, [shape]) - generates Bernoulli distributed random values (0 or 1). Probability can be a tensor
- seed: random seed; the same seed always gives the same values
- probability: chance of a 1; a tensor gives one probability per element and sets the shape
- shape: output shape as a list (default: the shape of the node's input)
*/
| BERNOULLI LPAREN expr COMMA expr (COMMA expr)? RPAREN # BernoulliFunc
/**
random_poisson(seed, rate, [shape]) - generates Poisson distributed random values.
- seed: random seed; the same seed always gives the same values
- rate: expected count; a tensor gives one rate per element and sets the shape
- shape: output shape as a list (default: the shape of the node's input)
*/
| POISSON LPAREN expr COMMA expr (COMMA expr)? RPAREN # PoissonFunc
/**
random_cauchy(seed, median, sigma, [shape]) - generates Cauchy distributed random values.
- seed: random seed; the same seed always gives the same values
- median: centre of the distribution
- sigma: half width at half maximum
- shape: output shape as a list (default: the shape of the node's input)
*/
| CAUCHY LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # CauchyFunc
/**
random_log_normal(seed, mean, std, [shape]) - generates log-normally distributed random values.
- seed: random seed; the same seed always gives the same values
- mean: mean of the underlying normal distribution
- std: standard deviation of the underlying normal distribution
- shape: output shape as a list (default: the shape of the node's input)
*/
| LOGNORMAL LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # LogNormalFunc
/**
random_gamma(seed, concentration, scale, [shape]) - generates Gamma distributed random values.
- seed: random seed; the same seed always gives the same values
- concentration: shape (concentration) k
- scale: scale theta; the mean is k * theta
- shape: output shape as a list (default: the shape of the node's input)
*/
| GAMMADIST LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # GammaDistFunc
/**
random_beta(seed, alpha, beta, [shape]) - generates Beta distributed random values
- seed: random seed; the same seed always gives the same values
- alpha: first concentration
- beta: second concentration
- shape: output shape as a list (default: the shape of the node's input)
*/
| BETADIST LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # BetaDistFunc
/**
random_laplace(seed, loc, scale, [shape]) - generates Laplace distributed random values
- seed: random seed; the same seed always gives the same values
- loc: centre of the distribution
- scale: spread (diversity)
- shape: output shape as a list (default: the shape of the node's input)
*/
| LAPLACEDIST LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # LaplaceDistFunc
/**
random_gumbel(seed, loc, scale, [shape]) - generates Gumbel distributed random values
- seed: random seed; the same seed always gives the same values
- loc: mode of the distribution
- scale: spread
- shape: output shape as a list (default: the shape of the node's input)
*/
| GUMBELDIST LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # GumbelDistFunc
/**
random_weibull(seed, scale, concentration, [shape]) - generates Weibull distributed random values
- seed: random seed; the same seed always gives the same values
- scale: scale lambda
- concentration: shape k
- shape: output shape as a list (default: the shape of the node's input)
*/
| WEIBULLDIST LPAREN expr COMMA expr COMMA expr (COMMA expr)? RPAREN # WeibullDistFunc
/**
random_chi2(seed, df, [shape]) - generates Chi-squared distributed random values
- seed: random seed; the same seed always gives the same values
- df: degrees of freedom
- shape: output shape as a list (default: the shape of the node's input)
*/
| CHI2DIST LPAREN expr COMMA expr (COMMA expr)? RPAREN # Chi2DistFunc
/**
random_studentt(seed, df, [shape]) - generates Student-t distributed random values
- seed: random seed; the same seed always gives the same values
- df: degrees of freedom
- shape: output shape as a list (default: the shape of the node's input)
*/
| STUDENTTDIST LPAREN expr COMMA expr (COMMA expr)? RPAREN # StudentTDistFunc
/**
perlin_noise(seed, scale, [octaves], [offset], [shape]) - generates Perlin gradient noise in 0-1 (default 1 octave)
- seed: random seed; the same seed always gives the same values
- scale: feature size in elements; larger values give smoother noise
- octaves: number of detail layers, each half the size of the previous (default: 1)
- offset: shift of the sampling grid, one value per dimension (default: 0)
- shape: output shape as a list (default: the shape of the node's input)
*/
| PERLIN LPAREN expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # PerlinFunc
/**
cellular_noise(seed, scale, [jitter], [offset], [shape]) - generates Cellular/Voronoi noise in 0-1: distance to the nearest feature point (jitter 0-1, default 0.5)
- seed: random seed; the same seed always gives the same values
- scale: cell size in elements
- jitter: 0-1 randomness of the cell points (default: 0.5)
- offset: shift of the sampling grid, one value per dimension (default: 0)
- shape: output shape as a list (default: the shape of the node's input)
*/
| CELLULAR LPAREN expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # CellularFunc
/**
plasma_noise(seed, scale, [octaves], [offset], [shape]) - generates Plasma/Turbulence noise in 0-1 - same as perlin but default octaves 4
- seed: random seed; the same seed always gives the same values
- scale: feature size in elements; larger values give smoother noise
- octaves: number of detail layers, each half the size of the previous (default: 4)
- offset: shift of the sampling grid, one value per dimension (default: 0)
- shape: output shape as a list (default: the shape of the node's input)
*/
| PLASMA LPAREN expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # PlasmaFunc
/**
ridged_noise(seed, scale, [octaves], [offset], [shape]) - generates ridged multi-fractal noise in 0-1 (default 4 octaves)
- seed: random seed; the same seed always gives the same values
- scale: feature size in elements; larger values give smoother noise
- octaves: number of detail layers, each half the size of the previous (default: 4)
- offset: shift of the sampling grid, one value per dimension (default: 0)
- shape: output shape as a list (default: the shape of the node's input)
*/
| RIDGED LPAREN expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # RidgedFunc
/**
domain_warp_noise(seed, scale, warp_scale, warp_strength, [octaves], [warp_octaves], [offset], [shape]) - generates domain warped Perlin noise in 0-1 (defaults: 4 octaves, 2 warp octaves)
- seed: random seed; the same seed always gives the same values
- scale: feature size in elements; larger values give smoother noise
- warp_scale: feature size of the warp field in elements
- warp_strength: how far the warp field displaces the coordinates
- octaves: detail layers of the base noise (default: 4)
- warp_octaves: detail layers of the warp field (default: 2)
- offset: shift of the sampling grid, one value per dimension (default: 0)
- shape: output shape as a list (default: the shape of the node's input)
*/
| DOMAIN_WARP LPAREN expr COMMA expr COMMA expr COMMA expr (COMMA expr)? (COMMA expr)? (COMMA expr)? (COMMA expr)? RPAREN # DomainWarpFunc;
// LEXER RULES
SIN: 'sin';
COS: 'cos';
TAN: 'tan';
ASIN: 'asin';
ACOS: 'acos';
ATAN: 'atan';
ATAN2: 'atan2';
SINH: 'sinh';
COSH: 'cosh';
TANH: 'tanh';
ASINH: 'asinh';
ACOSH: 'acosh';
ATANH: 'atanh';
ABS: 'abs';
SQRT: 'sqrt';
LN: 'ln';
LOG: 'log';
LOG2: 'log2';
EXP: 'exp';
LOG1P: 'log1p';
EXPM1: 'expm1';
SINC: 'sinc';
CBRT: 'cbrt';
RECIPROCAL: 'reciprocal';
LOGADDEXP: 'logaddexp';
LOGSUMEXP: 'logsumexp';
NORM: 'norm';
NORMALIZE: 'normalize';
GROUP_NORM: 'group_norm';
OUTER: 'outer';
TRACE: 'trace';
DET: 'det';
RFFT: 'rfft';
IRFFT: 'irfft';
ISNAN: 'isnan';
ISINF: 'isinf';
ISFINITE: 'isfinite';
SMIN: 'smin';
SMAX: 'smax';
TMIN: 'tmin';
TMAX: 'tmax';
TNORM: 'tnorm';
SNORM: 'snorm';
FLOOR: 'floor';
CEIL: 'ceil';
ROUND: 'round';
GAMMA: 'gamma';
POWE: 'pow';
SIGM: 'sigm';
CLAMP: 'clamp';
SFFT: 'fft';
SIFFT: 'ifft';
ANGL: 'angle';
PRNT: 'print';
PRINT_SHAPE: 'print_shape' | 'pshp';
NVL: 'nvl' | 'nan_to_num';
LERP: 'lerp';
SLERP: 'slerp';
STEP: 'step';
SMOOTHSTEP: 'smoothstep';
FRACT: 'fract';
RELU: 'relu';
SOFTSIGN: 'softsign';
LEAKY_RELU: 'leaky_relu';
SOFTPLUS: 'softplus';
GELU: 'gelu';
SILU: 'silu';
SIGN: 'sign';
DEGREES: 'degrees';
RADIANS: 'radians';
LOGICAL_NOT: 'logical_not';
LOGICAL_AND: 'logical_and';
LOGICAL_OR: 'logical_or';
HYPOT: 'hypot';
MAP: 'map';
EZCONV: 'ezconvolution' | 'ezconv';
CONV: 'convolution' | 'conv';
SWAP: 'swap';
TRANSPOSE: 'transpose' | 'swapaxes';
PERM: 'permute' | 'perm';
RESHAPE: 'reshape' | 'rshp';
RANGE: 'range';
LINSPACE: 'linspace';
LOGSPACE: 'logspace';
TOPK: 'topk';
BOTK: 'botk';
PINV: 'pinv';
INV: 'inv';
SUM: 'sum';
MEAN: 'mean';
STD: 'std';
VAR: 'var';
PROD: 'prod';
ISCLOSE: 'isclose';
ALLCLOSE: 'allclose';
QUARTILE: 'quartile' | 'quartil';
PERCENTILE: 'percentile' | 'prcnt';
QUANTILE: 'quantile';
DOT: 'dot';
MOMENT: 'moment';
ERF: 'erf';
ERFC: 'erfc';
ERFINV: 'erfinv';
ANY: 'any';
ALL: 'all';
EDGE: 'edge';
GAUSSIAN: 'blur' | 'gaussian';
MEDIAN: 'median';
MODE: 'mode';
CUMSUM: 'cumsum';
CUMPROD: 'cumprod';
TOPK_IND: 'topk_ind' | 'topk_indices';
BOTK_IND: 'botk_ind' | 'botk_indices';
CUBIC_EASE: 'cubic_ease' | 'cubic';
ELASTIC_EASE: 'elastic_ease' | 'elastic';
SINE_EASE: 'sine_ease' | 'sine';
SMOOTHERSTEP: 'smootherstep';
DIST: 'dist' | 'distance';
REMAP: 'remap';
COSSIM: 'cossim' | 'cosine_similarity';
COUNT: 'count' | 'cnt' | 'length';
KEYS: 'keys';
ENABLE_TRACKING: 'enable_tracking' | 'track_on';
DISABLE_TRACKING: 'disable_tracking' | 'track_off';
RESET_TRACKING: 'reset_tracking' | 'track_reset';
GET_CHANGED_KEYS: 'get_changed_keys' | 'changed_keys';
GET_ADDED_KEYS: 'get_added_keys' | 'added_keys';
GET_REMOVED_KEYS: 'get_removed_keys' | 'removed_keys';
GET_UNCHANGED_KEYS: 'get_unchanged_keys' | 'unchanged_keys';
REPEAT: 'repeat';
FLATTEN: 'flatten';
APPEND: 'append';
GET_VALUE: 'get_value';
FLOW_APPLY: 'flow_apply';
BATCH_SHUFFLE: 'batch_shuffle' | 'shuffle' | 'select';
MOTION_MASK: 'motion_mask';
FLOW_TO_IMAGE: 'flow_to_image';
FLOW_MAG: 'flow_mag' | 'flow_magnitude';
FLOW_ANG: 'flow_ang' | 'flow_angle';
WHERE: 'where';
HISTOGRAM: 'histogram' | 'hist';
OVERLAY: 'overlay';
PAD: 'pad';
CROSS: 'cross';
MATMUL: 'matmul';
SOLVE: 'solve';
MATRIX_RANK: 'matrix_rank';
RIFE: 'rife';
BNOT: 'bnot' | 'bitwise_not';
BITCOUNT: 'bitcount' | 'popcount' | 'popcnt';
SHAPE: 'shape';
BAND: 'band' | 'bitwise_and';
XOR: 'bxor' | 'bitwise_xor';
BOR: 'bor' | 'bitwise_or';
TENSOR: 'tensor';
ZEROS: 'zeros';
ONES: 'ones';
EYE: 'eye';
ONE_HOT: 'one_hot';
MSE: 'mse';
MAE: 'mae';
PSNR: 'psnr';
WEIGHTED_MEAN: 'weighted_mean';
HUBER_LOSS: 'huber_loss';
CROSS_ENTROPY: 'cross_entropy';
ADD_KEY: 'add_key';
REMOVE_KEY: 'remove_key' | 'rm_key';
PUSH: 'stack_push';
POP: 'stack_pop';
CLEAR: 'stack_clear';
HAS: 'stack_has';
GET: 'stack_get';
CONCAT: 'cat'|'concat'|'concatenate';
STACK: 'stack';
NONZERO: 'nonzero';
INT: 'int';
FLOAT: 'float';
UPPER: 'upper';
LOWER: 'lower';
TRIM: 'trim';
SPLIT: 'split';
JOIN: 'join';
SUBSTRING: 'substring'|'substr';
FIND: 'find';
REPLACE: 'replace';
DILATE: 'dilate';
ERODE: 'erode';
MORPH_OPEN: 'morph_open';
MORPH_CLOSE: 'morph_close';
RGB_TO_OKLAB: 'rgb_to_oklab';
RGB_TO_CIELAB: 'rgb_to_cielab';
OKLAB_TO_RGB: 'oklab_to_rgb';
CIELAB_TO_RGB: 'cielab_to_rgb';
RGB_TO_HSV: 'rgb_to_hsv';
HSV_TO_RGB: 'hsv_to_rgb';
INT_TO_RGB: 'int_to_rgb';
RGB_TO_INT: 'rgb_to_int';
INTERPOLATE_LINEAR: 'interpolate_linear';
INTERPOLATE_AREA: 'interpolate_area';
INTERPOLATE_NEAREST: 'interpolate_nearest' | 'interpolate_nearest_exact';
TEXT_IMAGE: 'text_image';
AS_NESTED: 'as_nested_tensor' | 'as_nested';
SVD: 'svd'|'singular_value_decomposition';
DIAG: 'diagonal_matrix'|'diag';
IF: 'if';
ELSE: 'else';
WHILE: 'while';
FOR: 'for';
IN: 'in';
BREAK: 'break';
CONTINUE: 'continue';
RETURN: 'return';
TIMESTAMP: 'timestamp'|'now';
SORT: 'sort';
ARGSORT: 'argsort';
ARGMIN: 'argmin';
ARGMAX: 'argmax';
SOFTMAX: 'softmax';
SOFTMIN: 'softmin';
UNIQUE: 'unique';
FLIP: 'flip';
STARTSWITH: 'startswith';
ENDSWITH: 'endswith';
SQUEEZE: 'squeeze';
UNSQUEEZE: 'unsqueeze';
ROLL: 'roll';
COV: 'cov';
CORR: 'corr' | 'correlation';
ENTROPY: 'entropy';
CROP: 'crop';
NONE: 'none'|'None'|'null'|'NULL';
COORDS: 'coords'|'coordinates';
GATHER: 'gather';
SCATTER: 'scatter';
SCATTER_ADD: 'scatter_add';
NOISE: 'noise' | 'randn' | 'random_normal';
PINK_NOISE: 'pink_noise' | 'pink';
BROWN_NOISE: 'brown_noise' | 'brown';
RAND: 'rand' | 'randu' | 'random_uniform';
CAUCHY: 'randc' | 'random_cauchy';
EXPONENTIAL: 'rande' | 'random_exponential';
LOGNORMAL: 'randln' | 'random_log_normal';
BERNOULLI: 'randb' | 'random_bernoulli';
POISSON: 'randp' | 'random_poisson';
GAMMADIST: 'randg' | 'random_gamma';
BETADIST: 'randbeta' | 'random_beta';
LAPLACEDIST: 'randl' | 'random_laplace';
GUMBELDIST: 'randgumbel' | 'random_gumbel';
WEIBULLDIST: 'randw' | 'random_weibull';
CHI2DIST: 'randchi2' | 'random_chi2';
STUDENTTDIST: 'randt' | 'random_studentt';
PERLIN: 'perlin' | 'perlin_noise';
CELLULAR: 'cellular' | 'voronoi' | 'worley' | 'cellular_noise'|'voronoi_noise';
PLASMA: 'plasma' | 'turbulence' | 'plasma_noise';
RIDGED: 'ridged' | 'ridged_noise';
DOMAIN_WARP: 'domain_warp'|'domain_warp_noise';
PLUS: '+';
MINUS: '-';
MULT: '*';
DIV: '/';
MOD: '%';
POW: '^';
LSHIFT: '<<';
RSHIFT: '>>';
GE: '>=';
GT: '>';
LE: '<=';
LT: '<';
EQ: '==';
EQUEALS: '=';
PLUS_EQ: '+=';
MINUS_EQ: '-=';
MULT_EQ: '*=';
DIV_EQ: '/=';
MOD_EQ: '%=';
NE: '!=';
PIPE: '|';
LPAREN: '(';
RPAREN: ')';
COMMA: ',';
SEMICOLON: ';';
ARROW: '->';
LBRACKET: '[';
RBRACKET: ']';
QUESTION: '?';
COLON: ':';
LBRACE: '{';
RBRACE: '}';
NUMBER: ([0-9]+ ('.' [0-9]*)? | '.' [0-9]+) ([eE][+-]? [0-9]+)?;
CONSTANT: ('pi' | 'PI' | 'e' | 'E');
STRING: '"' (~["\\\r\n] | '\\' .)* '"'
| '\'' (~['\\\r\n] | '\\' .)* '\''
;
VARIABLE: [a-zA-Z_] [a-zA-Z_0-9]*;
SL_COMMENT: '#' ~[\r\n]* -> skip;
ML_COMMENT: '/*' .*? '*/' -> skip;
WS: [ \t\r\n]+ -> skip;
Reference in New Issue View Git Blame Copy Permalink