Unary Mathematical Functions HelixQL provides a rich set of single-argument mathematical functions for transforming numeric values, including absolute values, roots, logarithms, exponentials, and rounding operations.
Available Functions ABS - Absolute Value Returns the absolute value of a number.
SQRT - Square Root Returns the square root of a non-negative number.
LN - Natural Logarithm Returns the natural logarithm (base e) of a positive number.
LOG10 - Base-10 Logarithm LOG10(x) // Returns log₁₀(x)
Returns the base-10 logarithm of a positive number.
LOG - Custom Base Logarithm LOG(x, base) // Returns log_base(x)
Returns the logarithm of x with a custom base.
EXP - Exponential Returns e raised to the power of x.
CEIL - Ceiling Rounds up to the nearest integer.
FLOOR - Floor Rounds down to the nearest integer.
ROUND - Round ROUND(x) // Returns round(x)
Rounds to the nearest integer.
When using the SDKs or curling the endpoint, the query name must match what is defined in the queries.hx file exactly.
Example 1: Distance calculations with SQRT Calculate Euclidean distances between points:
QUERY CalculateDistances() => points <- N::Point ::{ x, y, distance_from_origin: SQRT(ADD(POW(_::{x}, 2.0), POW(_::{y}, 2.0))), rounded_distance: ROUND(SQRT(ADD(POW(_::{x}, 2.0), POW(_::{y}, 2.0)))) } RETURN points QUERY CreatePoint(x: F64, y: F64) => point <- AddN<Point>({ x: x, y: y }) RETURN point
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Create points points = [ { "x" : 3.0 , "y" : 4.0 }, { "x" : 5.0 , "y" : 12.0 }, { "x" : 8.0 , "y" : 15.0 }, ] for point in points: client.query( "CreatePoint" , point) result = client.query( "CalculateDistances" , {}) print ( "Point distances:" , result)
Example 2: Logarithmic scaling with LN and LOG10 Use logarithms for normalization and scaling:
QUERY NormalizeMetrics() => metrics <- N::Metric ::{ value, log_scale: LN(_::{value}), log10_scale: LOG10(_::{value}), custom_log: LOG(_::{value}, 2.0) } RETURN metrics QUERY CreateMetric(value: F64) => metric <- AddN<Metric>({ value: value }) RETURN metric
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Create metrics with various scales values = [ 1.0 , 10.0 , 100.0 , 1000.0 , 10000.0 ] for value in values: client.query( "CreateMetric" , { "value" : value}) result = client.query( "NormalizeMetrics" , {}) print ( "Normalized metrics:" , result)
Example 3: Exponential decay with EXP Model time-based decay using exponential functions:
QUERY CalculateDecayFactors(decay_rate: F64) => items <- N::Item ::{ name, age_days, decay_factor: EXP(MUL(decay_rate, _::{age_days})), relevance_score: MUL(_::{base_score}, EXP(MUL(decay_rate, _::{age_days}))) } RETURN items QUERY CreateItem(name: String, age_days: F64, base_score: F64) => item <- AddN<Item>({ name: name, age_days: age_days, base_score: base_score }) RETURN item
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Create items with different ages items = [ { "name" : "Recent Post" , "age_days" : 1.0 , "base_score" : 100.0 }, { "name" : "Week Old Post" , "age_days" : 7.0 , "base_score" : 100.0 }, { "name" : "Month Old Post" , "age_days" : 30.0 , "base_score" : 100.0 }, ] for item in items: client.query( "CreateItem" , item) # Apply decay rate of -0.1 per day result = client.query( "CalculateDecayFactors" , { "decay_rate" : - 0.1 }) print ( "Decay factors:" , result)
Rounding Functions CEIL, FLOOR, and ROUND provide different rounding behaviors:
CEIL(3.2) // Returns 4.0 FLOOR(3.8) // Returns 3.0 ROUND(3.5) // Returns 4.0 ROUND(3.4) // Returns 3.0
Use rounding for display formatting or bucketing:
QUERY BucketScores() => items <- N::Item ::{ raw_score, bucket: MUL(FLOOR(DIV(_::{raw_score}, 10.0)), 10.0) } RETURN items
Domain Restrictions Some functions have domain restrictions:
SQRT(x) : x must be non-negativeLN(x), LOG10(x), LOG(x, base) : x must be positiveLOG(x, base) : base must be positive and not equal to 1 Use in Weight Calculations Unary math functions are powerful in shortest path weight calculations:
// Exponential time decay ::ShortestPathDijkstras<Route>( MUL(_::{distance}, EXP(MUL(-0.05, _::{days_old}))) ) // Logarithmic scaling for large values ::ShortestPathDijkstras<Connection>( LOG10(ADD(_::{traffic}, 1.0)) )
