InputLayer Builtin Functions Reference

Overview

InputLayer provides 55 builtin functions for vector operations, temporal processing, quantization, string manipulation, and math utilities.

Table of Contents

1. Distance Functions
2. Vector Operations
3. LSH Functions
4. Quantization Functions
5. Int8 Distance Functions
6. Temporal Functions
7. Math Functions
8. String Functions
9. Scalar Min/Max Functions

1. Distance Functions

Distance functions for f32 vectors. All return Float64.

euclidean(v1, v2)

Euclidean (L2) distance between two vectors.

// Syntax
D = euclidean(V1, V2)

// Example
similar(Id1, Id2, Dist) <-
    vectors(Id1, V1),
    vectors(Id2, V2),
    Id1 < Id2,
    Dist = euclidean(V1, V2),
    Dist < 1.0

cosine(v1, v2)

Cosine distance (1 - cosine similarity) between two vectors.

// Syntax
D = cosine(V1, V2)

// Example - Find similar documents
similar_docs(Id1, Id2) <-
    doc_embedding(Id1, V1),
    doc_embedding(Id2, V2),
    D = cosine(V1, V2),
    D < 0.1  // Very similar (close to 0)

Note: Returns 0 for identical directions, 1 for orthogonal, 2 for opposite directions.

dot(v1, v2)

Dot product of two vectors.

// Syntax
Score = dot(V1, V2)

// Example - Compute relevance scores
relevance(QueryId, DocId, Score) <-
    query_vector(QueryId, Q),
    doc_vector(DocId, D),
    Score = dot(Q, D)

manhattan(v1, v2)

Manhattan (L1) distance between two vectors. Good for sparse vectors.

// Syntax
D = manhattan(V1, V2)

// Example
nearby(Id1, Id2) <-
    location(Id1, V1),
    location(Id2, V2),
    D = manhattan(V1, V2),
    D < 10.0

2. Vector Operations

Operations for manipulating vectors.

normalize(v)

Normalize vector to unit length.

// Syntax
Normalized = normalize(V)

// Example - Normalize before cosine similarity
normalized_embedding(Id, NormV) <-
    raw_embedding(Id, V),
    NormV = normalize(V)

Note: Returns zero vector if input is zero vector.

vec_dim(v)

Get the dimension (length) of a float32 vector.

// Syntax
Dim = vec_dim(V)

// Example - Filter by dimension
valid_embedding(Id, V) <-
    embedding(Id, V),
    Dim = vec_dim(V),
    Dim = 128

vec_add(v1, v2)

Element-wise addition of two vectors.

// Syntax
Sum = vec_add(V1, V2)

// Example - Combine embeddings
combined(Id, SumV) <-
    text_embedding(Id, T),
    image_embedding(Id, I),
    SumV = vec_add(T, I)

Note: Vectors must have same dimension.

vec_scale(v, scalar)

Scale vector by a scalar value.

// Syntax
Scaled = vec_scale(V, S)

// Example - Apply weight
weighted(Id, ScaledV) <-
    embedding(Id, V),
    weight(Id, W),
    ScaledV = vec_scale(V, W)

3. LSH (Locality Sensitive Hashing) Functions

Functions for approximate nearest neighbor search.

lsh_bucket(v, table_idx, num_hyperplanes)

Compute LSH bucket ID for a float32 vector.

// Syntax
Bucket = lsh_bucket(V, TableIdx, NumHyperplanes)

// Example - Build LSH index
lsh_index(Id, Table, Bucket) <-
    embedding(Id, V),
    Table = 0,
    Bucket = lsh_bucket(V, Table, 8)  // 8 hyperplanes = 256 buckets

Note: More hyperplanes = more buckets = higher precision but lower recall.

lsh_probes(bucket, num_hp, num_probes)

Generate multi-probe sequence for a bucket by Hamming distance.

// Syntax
Probes = lsh_probes(Bucket, NumHyperplanes, NumProbes)

// Example - Get probe sequence
probe_buckets(OrigBucket, Probes) <-
    query_bucket(OrigBucket),
    Probes = lsh_probes(OrigBucket, 8, 4)

lsh_multi_probe(v, table_idx, num_hp, num_probes)

Compute LSH bucket and probes in one call for float32 vectors.

// Syntax
Buckets = lsh_multi_probe(V, TableIdx, NumHyperplanes, NumProbes)

4. Quantization Functions

Functions for int8 vector quantization (memory-efficient storage).

quantize_linear(v)

Linear quantization: maps [min, max] to [-128, 127].

// Syntax
QV = quantize_linear(V)

// Example - Compress embeddings
compressed(Id, QV) <-
    embedding(Id, V),
    QV = quantize_linear(V)

quantize_symmetric(v)

Symmetric quantization: maps [-max_abs, max_abs] to [-127, 127], preserving zero.

QV = quantize_symmetric(V)

Note: Better preserves zero values; recommended for normalized vectors.

dequantize(v)

Convert int8 vector back to f32.

FV = dequantize(QV)

Note: Lossy conversion - original precision not fully recovered.

dequantize_scaled(v, scale)

Dequantize with explicit scale factor.

FV = dequantize_scaled(QV, Scale)

5. Int8 Distance Functions

Native (Fast) Int8 Distance

Direct computation on int8 values for maximum speed.

euclidean_int8(v1, v2)

Euclidean distance for int8 vectors.

D = euclidean_int8(QV1, QV2)

cosine_int8(v1, v2)

Cosine distance for int8 vectors.

D = cosine_int8(QV1, QV2)

dot_int8(v1, v2)

Dot product for int8 vectors.

Score = dot_int8(QV1, QV2)

manhattan_int8(v1, v2)

Manhattan distance for int8 vectors.

D = manhattan_int8(QV1, QV2)

6. Temporal Functions

Functions for time-based queries and temporal reasoning.

time_now()

Get current Unix timestamp in milliseconds.

Now = time_now()

time_diff(t1, t2)

Compute difference between two timestamps.

Diff = time_diff(T1, T2)

time_add(ts, duration_ms)

Add duration to timestamp.

NewTime = time_add(Ts, DurationMs)

time_sub(ts, duration_ms)

Subtract duration from timestamp.

NewTime = time_sub(Ts, DurationMs)

time_decay(ts, now, half_life_ms)

Exponential time decay. Formula: 0.5^(age/half_life).

Weight = time_decay(Ts, Now, HalfLifeMs)

Note: Returns 1.0 at ts=now, 0.5 at age=half_life, approaches 0 for old events.

time_decay_linear(ts, now, max_age_ms)

Linear time decay. Formula: max(0, 1 - age/max_age).

Weight = time_decay_linear(Ts, Now, MaxAgeMs)

Note: Returns 1.0 at ts=now, 0.5 at age=max_age/2, 0.0 at age>=max_age.

time_before(t1, t2)

Check if t1 is before t2.

time_after(t1, t2)

Check if t1 is after t2.

time_between(ts, start, end)

Check if timestamp is within range [start, end] (inclusive).

within_last(ts, now, duration_ms)

Check if timestamp is within the last duration from now.

intervals_overlap(s1, e1, s2, e2)

Check if two time intervals overlap.

interval_contains(s1, e1, s2, e2)

Check if interval [s1, e1] fully contains interval [s2, e2].

interval_duration(start, end)

Get the duration of an interval.

point_in_interval(ts, start, end)

Check if a point is within an interval [start, end] (inclusive).

7. Math Functions

General-purpose math functions. All accept Int64 or Float64 inputs (coerced to f64 internally unless noted).

abs(x)

Generic absolute value. Preserves input type.

A = abs(X)

abs_int64(x)

Absolute value of an integer.

AbsVal = abs_int64(X)

Note: Uses saturating arithmetic for i64::MIN.

abs_float64(x)

Absolute value of a float.

AbsVal = abs_float64(X)

sqrt(x)

Square root.

R = sqrt(X)

Note: Returns Null if x < 0.

pow(base, exp)

Power function.

R = pow(Base, Exp)

log(x)

Natural logarithm (base e).

R = log(X)

Note: Returns Null if x <= 0.

exp(x)

Exponential function (e^x).

R = exp(X)

sin(x)

Sine function (radians).

R = sin(X)

cos(x)

Cosine function (radians).

R = cos(X)

tan(x)

Tangent function (radians).

R = tan(X)

floor(x)

Round down to nearest integer.

R = floor(X)

ceil(x)

Round up to nearest integer.

R = ceil(X)

sign(x)

Sign function. Returns -1, 0, or 1.

S = sign(X)

Note: For float NaN, returns 0.

8. String Functions

Functions for string manipulation.

len(s)

Get string length (byte count).

L = len(S)

// Example
long_names(Name, L) <-
    names(Name),
    L = len(Name),
    L > 10

upper(s)

Convert string to uppercase (Unicode-aware).

U = upper(S)

lower(s)

Convert string to lowercase (Unicode-aware).

L = lower(S)

trim(s)

Remove leading and trailing whitespace.

T = trim(S)

substr(s, start, len)

Extract a substring.

Sub = substr(S, Start, Len)

// Example - Get first 3 characters
prefix(Name, P) <-
    names(Name),
    P = substr(Name, 0, 3)

Note: Returns empty string if start > string length. Clamps to string bounds.

replace(s, find, replacement)

Replace all occurrences of a substring.

R = replace(S, Find, Replacement)

// Example
cleaned(R) <-
    raw("hello-world"),
    R = replace("hello-world", "-", " ")

concat(s1, s2, ...)

Concatenate multiple values into a string. Variable arity (2+ arguments).

R = concat(S1, S2)

// Example - Build full name
full_name(First, Last, Full) <-
    person(First, Last),
    Full = concat(First, " ", Last)

Note: Non-string values are automatically converted to their string representation.

9. Scalar Min/Max Functions

Scalar comparison functions returning the minimum or maximum of two values.

min_val(a, b)

Return the smaller of two values.

M = min_val(A, B)

// Example - Clamp to range
clamped(X, C) <-
    values(X),
    C = max_val(0, min_val(X, 100))

Note: Do not confuse with the min aggregation. min_val is a scalar function comparing two values. Mixed numeric types (Int64 + Float64) return Float64. Strings compare lexicographically.

max_val(a, b)

Return the larger of two values.

M = max_val(A, B)

Note: Do not confuse with the max aggregation. max_val is a scalar function comparing two values. Mixed numeric types (Int64 + Float64) return Float64. Strings compare lexicographically.

Appendix: Function Quick Reference