Geomatic Function Documentation

Create an arc with center, radius, and start/end angles.

Create a cubic Bezier curve from two endpoints and two control points.

Create a quadratic Bezier curve from two endpoints and a control point.

Create a circle with a center point and radius.

Create an ellipse with center, radii, and rotation.

Create an ellipse from two foci and a string length.

Create a line from two points.

Create a point from x and y coordinates.

Create a scalar value from another scalar.

Create a text node with a string value.

Create a triangle from three vertex points.

Calculate the angle at a vertex formed by three points.

Calculate the area of a circle.

Calculate the area of a triangle.

Calculate the angle bisector of two lines that share a point.

Calculate the centroid (geometric center) of a triangle.

Calculate the circumcenter of a triangle (center of circumscribed circle).

Calculate the Euclidean distance between two points.

Calculate the incenter of a triangle (center of inscribed circle).

Calculate the midpoint between two points.

Project a point onto a line (find the closest point on the line).

Reflect a point across a line.

Calculate the slope angle of a line (angle between 0 and 2PI).

Calculate the intersection points of two circles.

Calculate the intersection points of a line and a quadratic Bezier curve.

Calculate the intersection points of a line and a circle.

Calculate the intersection points of a line and an ellipse.

Calculate the intersection point of two lines.

Clear the accumulated history of a trail node.

Evaluate a polynomial at a given x.

Plot y vs x over the visible canvas range.

Plot the output along x while sweeping the independent variable down the y-axis (e.g. x = f(y))

Create a polynomial function from coefficients.

Track the path of a point as its parameters change.

Calculate the convex hull of a set of points using the Graham scan algorithm.

Create a polygon from three or more vertex points.

Create a regular polygon from two points forming one side and the number of sides.

Create a rectangle from a bottom-left corner, width, height, and rotation angle.

Create a regular polygon with center, radius, number of vertices, and start angle.

Create a square from a bottom-left corner, side length, and rotation angle.

Draw a tangent line to a curve at a given x coordinate.

Calculate arccosine of a scalar value (returns radians).

Calculate arcsine of a scalar value (returns radians).

Calculate arctangent of a scalar value (returns radians).

Calculate arctangent of y/x (returns radians).

Round up to nearest integer.

Calculate cosine of a scalar value (in radians).

Convert degrees to radians.

Round down to nearest integer.

Calculate base-10 logarithm of a scalar value.

Return maximum of two or more scalar values.

Return minimum of two or more scalar values.

Calculate modulo (remainder) of first scalar divided by second.

Convert radians to degrees.

Calculate reciprocal (1/x) of a scalar value.

Apply ReLU activation function (max(0, x)).

Round to nearest integer.

Apply sigmoid activation function (1 / (1 + e^(-x))).

Return sign of a scalar (-1, 0, or 1).

Calculate sine of a scalar value (in radians).

Calculate tangent of a scalar value (in radians).

Apply hyperbolic tangent activation function.

Extract the x-coordinate from a point.

Extract the y-coordinate from a point.

Argument (phase angle) of a complex number, in radians

Construct a complex number from real and imaginary parts

Complex conjugate (re - im·i)

Compute the fast Fourier transform of an array of scalars (any length).

Compute the inverse fast Fourier transform of an array (inverse of fft).

Extract the imaginary part of a complex number

Extract the real part of a complex number

Create an array of Scalar values from start (inclusive) to end (exclusive) with a given step size

Create an array of n uniformly spaced points on a circle of radius r

Compute the cumulative sum of an array of scalars

Create an array of evenly spaced values.

Create a 1-D array of n Scalar elements all equal to 1

Create an array of Scalar elements all equal to 1, matching the shape of the input array

Find the maximum element in an array.

Compute the mean of elements in an array of scalars, optionally along a dimension

Find the minimum element in an array.

Compute the standard deviation of elements in an array of scalars, optionally along a dimension

Sum elements of an array.

Compute the variance of elements in an array of scalars, optionally along a dimension

Reshape an array into a new N-dimensional shape

Apply softmax function to an array of scalars

Create a 1-D array of n Scalar elements all equal to 0

Create an array of Scalar elements all equal to 0, matching the shape of the input array

Create an array of elements of the same type.

Get an element from an array by index.

Animate a value over time.

Rotate a point or set of points around a center.

Translate a point or set of points.

Translate an array of geometric objects by dx and dy (imperative)

Run autodiff backpropagation from a target node.

Perform gradient descent on a parameter.

Minimize a scalar value using gradient descent for N iterations

Register parameters for autodiff backpropagation.

Partial derivative ∂target/∂param of a scalar target w.r.t. a Scalar or Point variable, or element-wise over an Array of them (reactive)

Re-evaluate a node using current dependency values and snapshot the result into the store

Vector field from a scalar gradient (y: Scalar) or direct R²→R² map (y: Point).

Zero out gradients for all autodiff parameters.

Returns true if all inputs are true

Interpret a binary string as a one's complement signed integer

Interpret a binary string as a two's complement signed integer

Interpret a binary string as an unsigned integer

Convert a value to a boolean based on its truthiness

Returns true if a == b

Filter an array by a boolean mask. The mask must broadcast with the array, with exactly one non-broadcast axis specifying which indices to keep.

Convert a scalar to its IEEE 754 floating-point binary string (16, 32 or 64 bits)

Returns true if a >= b

Returns true if a > b

Convert a scalar to its integer binary string (two's or one's complement) over a fixed bit width

Returns true if a <= b

Returns true if a < b

Returns the logical negation of a boolean value

Returns true if any input is true

Convert an unsigned non-negative integer to its binary string over a fixed bit width

Returns true if exactly one of the two inputs is true

Clear all nodes from state and canvas.

Create an independent copy of a geometric node

Show properties of a node.

Hide a node from rendering.

Highlight an element.

Remove a node and all its dependencies.

Set the fill color of a node.

Set the stroke color of a node.

Show a previously hidden node.

Point (t, y(t)) on an ODE trajectory at time t (interpolated)

Integrate dp/dt = F(p) through a 2D vector field and draw the trajectory

Simulate dX = a(t,X) dt + b(t,X) dW (Euler–Maruyama) and draw the sample path

Integrate dy/dt = f(t, y) from t=0 and draw the trajectory (t, y(t))

Arc marking the angle at the shared vertex of two lines, with optional label

Straight arrow from p1 to p2 with optional label. padding (0–0.5) shrinks both ends by that fraction of the total length.

Curly bracket between two points with optional label (opens to right of p1→p2)

Curved arrow from p1 to p2 bending toward a control point. padding (0–0.5) trims both ends by that fraction of the curve.

Dimension line between two points with extension lines and auto-distance label

Leader line with arrowhead at p1, elbow, and label at p2

Pin marker at a point with optional label

Text label centered at a point, with optional wrapping box. Width/height semantics: w=0, h=0 → no bounded box, single-line label (default). w>0, h>0 → fixed box. w>0, h=-1 → fixed width, height grows to fit wrapped text. w=-1, h>0 → fixed height, width sized to fit text in that many lines. w=-1, h=-1 → both auto, each capped at 5 canvas units.

Absolute value / modulus (scalar or complex)

Add two or more values (scalar or complex)

Divide the first value by the second (scalar or complex)

Exponential e^a (scalar or complex)

Natural logarithm ln(a) (scalar or complex)

Multiply two or more values (scalar or complex)

Negate a value (scalar or complex)

Raise the first value to the power of the second (scalar or complex)

Square root (scalar or complex)

Subtract the second value from the first (scalar or complex)