Mathematical Expressions
The EasyEdge Operations Engine includes a comprehensive mathematical expression parser that supports a wide range of operators and functions. This is the foundation for performing any numerical calculation within your Computation String. All calculations are performed using high-precision 64-bit floating-point numbers.
Core Concepts
Operands
Operands are the variables of your expressions. They are represented by single lowercase letters from a to z. Each operand must be linked to a system object (like a sensor tag, a data field, or another operation's result) in the operation's configuration.
At runtime, just before the expression is evaluated, the engine replaces each operand with the current numerical value of the object it is linked to. This real-time substitution is what makes the expressions dynamic and responsive to the state of your system.
Literals
Literals are fixed, constant values written directly into the expression. The engine supports standard numeric formats:
Integers: 100, -5, 0, 0x2F
Floating-point numbers: 98.6, -0.01, 3.14159
Operators
Operators are the symbols that perform actions on operands and literals. The engine respects the standard mathematical order of operations.
Order of Operations (Precedence)
Expressions are not evaluated strictly from left to right. Operators have a defined precedence, which determines the order of execution. You can always use parentheses () to override this natural order and force a specific part of an expression to be evaluated first.
The order of precedence, from highest to lowest, is:
Parentheses: ()
Power: ^
Unary Minus: - (e.g., -a)
Multiplication, Division, Modulo: *, /, %
Addition, Subtraction: +, -
Relational Operators: ==, !=, <, <=, >, >=
Logical & Bitwise Operators: not, and, or, xor, nand, nor, xnor, mand, mor
Arithmetic Operators
These are the fundamental operators for performing calculations.
Operator
Description
Example
+
Addition
a + 10
-
Subtraction
b - 5.5
*
Multiplication
c * 2
/
Division
d / 3
^
Power (Exponentiation)
a ^ 2
%
Modulo (Remainder)
b % 3
Relational Operators
These operators compare two values and return 1.0 (for true) or 0.0 (for false). They are essential for creating conditional logic, especially within the if() function.
Operator
Description
Example
== or =
Equal to
a == 100
!=
Not equal to
b != 0
<
Less than
c < 50
<=
Less than or equal to
d <= 10.5
>
Greater than
a > 0
>=
Greater than or equal to
b >= 99
Logical and Bitwise Operators
These operators combine multiple relational expressions or perform bit-level manipulations.
Operator
Description
Example
and or &
Logical AND. Returns 1.0 if both inputs are non-zero.
a > 0 and b < 10
or or |
Logical OR. Returns 1.0 if either input is non-zero.
a == 1 or a == 2
not
Logical NOT. Returns 1.0 if the input is zero, 0.0 otherwise.
not (b == 0)
xor
Logical XOR. Returns 1.0 if inputs are different.
a xor b
nand
Logical NAND. The inverse of and.
a nand b
nor
Logical NOR. The inverse of or.
a nor b
xnor
Logical XNOR. The inverse of xor.
a xnor b
mand
Multi-argument AND. Returns 1.0 only if all inputs are true.
a mand b mand c
mor
Multi-argument OR. Returns 1.0 if any input is true.
a mor b mor c
Built-in Mathematical Functions
A rich library of mathematical functions is available for more advanced calculations.
General Functions
Function
Description
Example
abs(x)
Absolute value of x
abs(a - 100)
avg(x1,…,xn)
Average of all inputs
avg(a, b, c)
ceil(x)
Rounds x up to the nearest integer
ceil(a / 10.5)
clamp(min,x,max)
Clamps x to be within the range [min, max]
clamp(0, a, 100)
equal(x,y)
Numeric test for equality with a small tolerance
equal(a, 100.001)
floor(x)
Rounds x down to the nearest integer
floor(b * 3.14)
frac(x)
Fractional part of x
frac(3.7) returns 0.7
hypot(x,y)
Calculates √(x²+y²)
hypot(a, b)
iclamp(min,x,max)
Inverse clamp. If x is in [min,max], returns x, else returns the nearest bound.
iclamp(-1, 2, 1) returns 1
inrange(min,x,max)
Returns 1.0 if x is in the range [min, max], otherwise 0.0.
inrange(0, a, 100)
max(x1,…,xn)
Maximum value among the inputs
max(c, d, a)
min(x1,…,xn)
Minimum value among the inputs
min(a, b, 10)
mul(x1,…,xn)
Product of all inputs
mul(a, b, c)
not_equal(x,y)
Numeric test for inequality with a small tolerance
not_equal(a, 99.999)
pow(x,y)
x raised to the power of y (same as x ^ y)
pow(a, 3)
root(x,n)
The n-th root of x
root(27, 3) returns 3
round(x)
Rounds x to the nearest integer
round(c)
roundn(x,n)
Rounds x to n decimal places
roundn(a, 3)
sgn(x)
Sign of x (-1, 0, or 1)
sgn(a - 50)
sqrt(x)
Square root of x
sqrt(a)
sum(x1,…,xn)
Sum of all inputs
sum(a, b, c)
trunc(x)
Integer part of x (truncates toward zero)
trunc(-3.9) returns -3
Conditional Function
Function
Description
Example
if(cond,t,f)
If cond is non-zero (true), returns t, otherwise returns f.
if(a > 10, b, c)
Exponential & Logarithmic Functions
Function
Description
Example
exp(x)
e raised to the power of x
exp(a)
expm1(x)
e^x - 1, more accurate for small x
expm1(a)
log(x)
Natural logarithm of x
log(a)
log1p(x)
Natural logarithm of (1+x), more accurate for small x
log1p(a)
log2(x)
Base-2 logarithm of x
log2(a)
log10(x)
Base-10 logarithm of x
log10(b)
logn(x,n)
Logarithm of x to base n
logn(a, 16)
Trigonometric Functions
Note: All angle inputs and outputs are in radians.
Function
Description
Example
sin(x)
Sine of x
sin(b)
cos(x)
Cosine of x
cos(c)
tan(x)
Tangent of x
tan(d)
asin(x)
Arc sine of x
asin(a)
acos(x)
Arc cosine of x
acos(b)
atan(x)
Arc tangent of x
atan(c)
atan2(y,x)
Arc tangent of y/x, using signs to determine quadrant
atan2(a, b)
sinh(x)
Hyperbolic sine of x
sinh(a)
cosh(x)
Hyperbolic cosine of x
cosh(b)
tanh(x)
Hyperbolic tangent of x
tanh(c)
asinh(x)
Inverse hyperbolic sine of x
asinh(a)
acosh(x)
Inverse hyperbolic cosine of x
acosh(b)
atanh(x)
Inverse hyperbolic tangent of x
atanh(c)
cot(x)
Cotangent of x
cot(a)
csc(x)
Cosecant of x
csc(b)
sec(x)
Secant of x
sec(c)
sinc(x)
Sinc function (sin(x)/x)
sinc(a)
Angle Conversion Functions
Function
Description
Example
deg2rad(d)
Converts degrees to radians
deg2rad(180)
deg2grad(d)
Converts degrees to gradians
deg2grad(90)
rad2deg(r)
Converts radians to degrees
rad2deg(pi)
grad2deg(g)
Converts gradians to degrees
grad2deg(100)
Special Functions
Function
Description
Example
erf(x)
Error function
erf(a)
erfc(x)
Complementary error function
erfc(a)
ncdf(x)
Normal cumulative distribution function
ncdf(a)
Bitwise Functions (b* prefix)
For low-level data manipulation, a full suite of bitwise functions is available. These functions operate on the 53-bit integer representation of the values (any fractional part is truncated). All bitwise functions are prefixed with b.
Function
Description
Example
band(x,y)
Bitwise AND (x & y)
band(a, 15)
bor(x,y)
Bitwise OR (x | y)
bor(a, 0x01)
bxor(x,y)
Bitwise XOR (x ^ y)
bxor(a, 0xff)
bnot(x)
Bitwise NOT (~x)
bnot(a)
bshl(x,n)
Bitwise Shift Left (x << n)
bshl(a, 2)
bshr(x,n)
Bitwise Shift Right (x >> n)
bshr(a, 1)
bnand(x,y)
Bitwise NAND (~(x & y))
bnand(a, b)
bnor(x,y)
Bitwise NOR (~(x | y))
bnor(a, b)
bxnor(x,y)
Bitwise XNOR (~(x ^ y))
bxnor(a, b)
Understanding Bitwise Operations: A Practical Example
Imagine a device status register is read into operand a. The value of a is 13. You want to check if the 2nd bit (value 2) and the 4th bit (value 8) are both active.
13 in binary is 00001101
The mask to check for both bits is 2 | 8, which is 10.
10 in binary is 00001010
Computation String: band(a, 10) == 10
Evaluation Steps:
band(13, 10) is calculated.
00001101 (13)
& 00001010 (10)
----------
00001000 (8)
The result 8 is then compared: 8 == 10. This is false, so the expression returns 0.0. This correctly indicates that only one of the requested bits (the 4th bit) was active, not both.
Last updated