Stream Evaluator Reference

abs

The abs function will return the absolute value of the provided single parameter. The abs function will fail to execute if the value is non-numeric. If a null value is found then null will be returned as the result.

abs(1) // 1, not really a good use case for it
abs(-1) // 1, not really a good use case for it
abs(add(fieldA,fieldB)) // absolute value of fieldA + fieldB
abs(fieldA) // absolute value of fieldA

acos

The acos function returns the trigonometric arccosine of a number.

acos(100.4)  // returns the arccosine of 100.4
acos(fieldA) // returns the arccosine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the arccosine of fieldA, else return the arccosine of fieldB

add

The add function will take 2 or more numeric values and add them together. The add function will fail to execute if any of the values are non-numeric. If a null value is found then null will be returned as the result.

add(1,2,3,4) // 1 + 2 + 3 + 4 == 10
add(1,fieldA) // 1 + value of fieldA
add(fieldA,1.4) // value of fieldA + 1.4
add(fieldA,fieldB,fieldC) // value of fieldA + value of fieldB + value of fieldC
add(fieldA,div(fieldA,fieldB)) // value of fieldA + (value of fieldA / value of fieldB)
add(fieldA,if(gt(fieldA,fieldB),fieldA,fieldB)) // if fieldA > fieldB then fieldA + fieldA, else fieldA + fieldB

analyze

The analyze function analyzes text using a Lucene/Solr analyzer and returns a list of tokens emitted by the analyzer. The analyze function can be called on its own or within the select and cartesianProduct streaming expressions.

and

The and function will return the logical AND of at least 2 boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

and(true,fieldA) // true && fieldA
and(fieldA,fieldB) // fieldA && fieldB
and(or(fieldA,fieldB),fieldC) // (fieldA || fieldB) && fieldC
and(fieldA,fieldB,fieldC,or(fieldD,fieldE),fieldF)

anova

The anova function calculates the analysis of variance for two or more numeric arrays.

anova(numericArray1, numericArray2) // calculates ANOVA for two numeric arrays
anova(numericArray1, numericArray2, numericArray2) // calculates ANOVA for three numeric arrays

array

The array function returns an array of numerics or other objects including other arrays.

array(1, 2, 3)  // Array of numerics
array(array(1,2,3), array(4,5,6)) // Array of arrays

asin

The asin function returns the trigonometric arcsine of a number.

asin(100.4)  // returns the sine of 100.4
asine(fieldA) // returns the sine for fieldA.
if(gt(fieldA,fieldB),asin(fieldA),asin(fieldB)) // if fieldA > fieldB then return the asine of fieldA, else return the asine of fieldB

atan

The atan function returns the trigonometric arctangent of a number.

atan(100.4)  // returns the arctangent of 100.4
atan(fieldA) // returns the arctangent for fieldA.
if(gt(fieldA,fieldB),atan(fieldA),atan(fieldB)) // if fieldA > fieldB then return the arctanget of fieldA, else return the arctangent of fieldB

betaDistribution

The betaDistribution function returns a beta probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

betaDistribution(1, 5)

binomialCoefficient

The binomialCoefficient function returns a Binomial Coefficient, the number of k-element subsets that can be selected from an n-element set.

binomialCoefficient(8, 3) // Returns the number of 3 element subsets from an 8 element set.

binomialDistribution

The binomialDistribution function returns a binomial probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

binomialDistribution(1000, .5)

cbrt

The cbrt function returns the trigonometric cube root of a number.

cbrt(100.4)  // returns the square root of 100.4
cbrt(fieldA) // returns the square root for fieldA.
if(gt(fieldA,fieldB),cbrt(fieldA),cbrt(fieldB)) // if fieldA > fieldB then return the cbrt of fieldA, else return the cbrt of fieldB

ceil

The ceil function rounds a decimal value to the next highest whole number.

ceil(100.4) // returns 101.
ceil(fieldA) // returns the next highest whole number for fieldA.
if(gt(fieldA,fieldB),ceil(fieldA),ceil(fieldB)) // if fieldA > fieldB then return the ceil of fieldA, else return the ceil of fieldB.

col

The col function returns a numeric array from a list of Tuples. The col function is used to create numeric arrays from stream sources.

col(tupleList, fieldName)

colAt

The colAt function returns the column of a matrix at a specific index as a numeric array.

colAt(matrix, 10)

columnCount

The columnCount function returns the number of columns in a matrix.

columnCount(matrix)

constantDistribution

The constantDistribution function returns a constant probability distribution based on its parameter. This function is part of the probability distribution framework and is designed to work with the sample and cumulativeProbability functions.

When sampled the constant distribution always returns its constant value.

constantDistribution(constantValue)

conv

The conv function returns the convolution of two numeric arrays.

conv(numericArray1, numericArray2)

copyOf

The copyOf function creates a copy of a numeric array.

copyOf(numericArray, length)

copyOfRange

The copyOfRange function creates a copy of a range of a numeric array.

copyOfRange(numericArray, startIndex, endIndex)

corr

The corr function returns the correlation of two numeric arrays or the correlation matrix for a matrix.

The corr function support Pearson’s, Kendall’s and Spearman’s correlations.

corr(numericArray1, numericArray2) // Compute the Pearsons correlation for two numeric arrays
corr(numericArray1, numericArray2, type=kendalls) // Compute the Kendalls correlation for two numeric arrays
corr(matrix) // Compute the Pearsons correlation matrix for a matrix
corr(matrix, type=spearmans) // Compute the Spearmans correlation matrix for a matrix

cos

The cos function returns the trigonometric cosine of a number.

cos(100.4)  // returns the arccosine of 100.4
cos(fieldA) // returns the arccosine for fieldA.
if(gt(fieldA,fieldB),cos(fieldA),cos(fieldB)) // if fieldA > fieldB then return the arccosine of fieldA, else return the cosine of fieldB

cosineSimilarity

The cosineSimilarity function returns the cosine similarity of two numeric arrays.

cosineSimilarity(numericArray, numericArray)

cov

The cov function returns the covariance of two numeric array or the covariance matrix for matrix.

cov(numericArray, numericArray) // Computes the covariance of a two numeric arrays
cov(matrix) // Computes the covariance matrix for the matrix.

cumulativeProbability

The cumulativeProbability function returns the cumulative probability of a random variable within a probability distribution. The cumulative probability is the total probability of all random variables less then or equal to a random variable.

cumulativeProbability(normalDistribution(500, 25), 502) // Returns the cumulative probability of the random sample 502 in a normal distribution with a mean of 500 and standard deviation of 25.

derivative

The derivative function returns the derivative of a function. The derivative function can compute the derivative of the spline function and the loess function. The derivative can also take the derivative of a derivative.

derivative(spline(...))
derivative(loess(...))
derivative(derivative(...))

describe

The describe function returns a tuple containing the descriptive statistics for an array.

describe(numericArray)

diff

The diff functions performs time series differencing.

Time series differencing is often used to make a time series stationary before further analysis.

diff(numericArray1) // Perform time series differencing with a default lag of 1.
diff(numericArray1, 30) // Perform time series differencing with a lag of 30.

distance

The distance function computes the distance of two numeric arrays or the distance matrix for a matrix.

distance(numericArray1, numericArray2) // Computes the euclidean distance for two numeric arrays.
distance(numericArray1, numericArray2, type=manhattan) // Computes the manhattan distance for two numeric arrays.
distance(matrix) // Computes the euclidean distance matrix for a matrix.
distance(matrix, type=canberra) // Computes the canberra distance matrix for a matrix.

div

The div function will take two numeric values and divide them. The function will fail to execute if any of the values are non-numeric or null, or the 2nd value is 0. Returns a numeric value.

div(1,2) // 1 / 2
div(1,fieldA) // 1 / fieldA
div(fieldA,1.4) // fieldA / 1.4
div(fieldA,add(fieldA,fieldB)) // fieldA / (fieldA + fieldB)

dotProduct

The dotProduct function returns the dotproduct of two numeric arrays.

dotProduct(numericArray, numericArray)

ebeAdd

The ebeAdd function performs an element-by-element addition of two numeric arrays.

ebeAdd(numericArray, numericArray)

ebeDivide

The ebeDivide function performs an element-by-element division of two numeric arrays.

ebeDivide(numericArray, numericArray)

ebeMultiple

The ebeMultiply function performs an element-by-element multiplication of two numeric arrays.

ebeMultiply(numericArray, numericArray)

ebeSubtract

The ebeSubtract function performs an element-by-element subtraction of two numeric arrays.

ebeSubtract(numericArray, numericArray)

empiricalDistribution

The empiricalDistribution function returns empirical distribution function, a continuous probability distribution function based on an actual data set. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

This function is designed to work with continuous data. To build a distribution from a discrete data set use the enumeratedDistribution.

empiricalDistribution(numericArray)

enumeratedDistribution

The enumeratedDistribution function returns a discrete probability distribution function based on an actual data set or a pre-defined set of data and probabilities. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

The enumeratedDistribution can be called in two different scenarios:

1) Single array of discrete values. This works like an empirical distribution for discrete data.

2) An array of singleton discrete values and an array of double values representing the probabilities of the discrete values.

This function is designed to work with discrete data. To build a distribution from a continuous data set use the empiricalDistribution.

enumeratedDistribution(integerArray) // This creates an enumerated distribution from the observations in the numeric array.
enumeratedDistribution(array(1,2,3,4), array(.25,.25,.25,.25)) // This creates an enumerated distribution with four discrete values (1,2,3,4) each with a probability of .25.

eor

The eor function will return the logical exclusive or of at least two boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

eor(true,fieldA) // true iff fieldA is false
eor(fieldA,fieldB) // true iff either fieldA or fieldB is true but not both
eor(eq(fieldA,fieldB),eq(fieldC,fieldD)) // true iff either fieldA == fieldB or fieldC == fieldD but not both

eq

The eq function will return whether all the parameters are equal, as per Java’s standard equals(…​) function. The function accepts parameters of any type, but will fail to execute if all the parameters are not of the same type. That is, all are Boolean, all are String, or all are Numeric. If any any parameters are null and there is at least one parameter that is not null then false will be returned. Returns a boolean value.

eq(1,2) // 1 == 2
eq(1,fieldA) // 1 == fieldA
eq(fieldA,val(foo)) fieldA == "foo"
eq(add(fieldA,fieldB),6) // fieldA + fieldB == 6

expMovingAge

The expMovingAverage function computes an exponential moving average for a numeric array.

expMovingAvg(numericArray, 5) //Computes an exponential moving average with a window size of 5.

factorial

The factorial function returns the factorial of its parameter.

factorial(100) //Computes the factorial of 100

finddelay

The finddelay function performs a cross-correlation between two numeric arrays and returns the delay.

finddelay(numericArray1, numericArray2)

floor

The floor function rounds a decimal value to the next lowest whole number.

floor(100.4) // returns 100.
ceil(fieldA) // returns the next lowestt whole number for fieldA.
if(gt(fieldA,fieldB),floor(fieldA),floor(fieldB)) // if fieldA > fieldB then return the floor of fieldA, else return the floor of fieldB.

freqTable

The freqTable function returns a frequency distribution from an array of discrete values.

This function is designed to work with discrete values. To work with continuous data use the hist function.

freqTable(integerArray)

gammaDistribution

The gammaDistribution function returns a gamma probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

gammaDistribution(1, 10)

geometricDistribution

The geometricDistribution function returns a geometric probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

geometricDistribution(.5) // Creates a geometric distribution with probability of .5

getAttribute

The getAttribute function returns an attribute from a matrix by its key. Any function that returns a matrix can also set attributes on the matrix with additional information. The setAttribute function can also be used to set attributes on a matrix. The key to an attribute is always a string. The value of attribute can be any object including numerics, arrays, maps, matrixes, etc.

getAttribute(matrix, key)

getAttributes

The getAttributes function returns the attribute map from matrix. See the getAttribute function for more details on attributes.

getAttributes(matrix)

getColumnLabels

The getColumnLabels function returns the columns labels of a matrix. The column labels can be optionally set by any function that returns a matrix. The column labels can also be set via the setColumnLabels function.

getRowLabels

The getRowLabels function returns the row labels of a matrix. The row labels can be optionally set by any function that returns a matrix. The row labels can also be set via the setRowLabels function.

getValue

The getValue function returns the value of a single Tuple entry by key.

grandSum

The grandSum function sums all the values in a matrix.

grandSum(matrix)

gt

The gt function will return whether the first parameter is greater than the second parameter. The function accepts numeric or string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

gt(1,2) // 1 > 2
gt(1,fieldA) // 1 > fieldA
gt(fieldA,val(foo)) // fieldA > "foo"
gt(add(fieldA,fieldB),6) // fieldA + fieldB > 6

gteq

The gteq function will return whether the first parameter is greater than or equal to the second parameter. The function accepts numeric and string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

gteq(1,2) // 1 >= 2
gteq(1,fieldA) // 1 >= fieldA
gteq(fieldA,val(foo)) fieldA >= "foo"
gteq(add(fieldA,fieldB),6) // fieldA + fieldB >= 6

hist

The hist function creates a histogram from a numeric array. The hist function is designed to work with continuous variables.

hist(numericArray, bins)

hsin

The hsin function returns the trigonometric hyperbolic sine of a number.

hsin(100.4)  // returns the hsine of 100.4
hsin(fieldA) // returns the hsine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the hsine of fieldA, else return the hsine of fieldB

if

The if function works like a standard conditional if/then statement. If the first parameter is true, then the second parameter will be returned, else the third parameter will be returned. The function accepts a boolean as the first parameter and anything as the second and third parameters. An error will occur if the first parameter is not a boolean or is null.

if(fieldA,fieldB,fieldC) // if fieldA is true then fieldB else fieldC
if(gt(fieldA,5), fieldA, 5) // if fieldA > 5 then fieldA else 5
if(eq(fieldB,null), null, div(fieldA,fieldB)) // if fieldB is null then null else fieldA / fieldB

indexOf

The indexOf function returns the index of a string in an array of strings.

indexOf(stringArray, string)

integrate

The integrate function computes the integral of an interpolation function for a specific range of the curve.

integrate(function, start, end)

length

The length function returns the length of a numeric array.

length(numericArray)

lerp (TOD0)

loess

The leoss function is a smoothing curve fitter which uses a local regression algorithm. Unlike the spline function which touches each control point, the loess function puts a smooth curve through the control points without having to touch the control points. The loess result can be used by the derivative function to produce smooth derivatives from data that is not smooth.

loess(yValues) // This creates the xValues automatically and fits a smooth curve through the data points.
loess(xValues, yValues) // This will fit a smooth curve through the data points.
loess(xValues, yValues, bandwidth=.15) // This will fit a smooth curve through the data points using 15 percent of the data points for each local regression line.

log

The log function will return the natural log of the provided single parameter. The log function will fail to execute if the value is non-numeric. If a null value is found, then null will be returned as the result.

log(100)
log(add(fieldA,fieldB))
log(fieldA)

logNormalDistribution

The logNormalDistribution function returns a log normal probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

logNormalDistribution(.3, .0)

kolmogorovSmirnov

The kolmogorovSmirnov function performs a Kolmogorov Smirnov test, between a reference continuous probability distribution and a sample set.

The supported distribution functions are: empiricalDistribution, normalDistribution, logNormalDistribution, weibullDistribution, gammaDistribution, and betaDistribution.

kolmogorovSmirnov(normalDistribution(10, 2), sampleSet)

lt

The lt function will return whether the first parameter is less than the second parameter. The function accepts numeric or string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

lt(1,2) // 1 < 2
lt(1,fieldA) // 1 < fieldA
lt(fieldA,val(foo)) fieldA < "foo"
lt(add(fieldA,fieldB),6) // fieldA + fieldB < 6

lteq

The lteq function will return whether the first parameter is less than or equal to the second parameter. The function accepts numeric and string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

lteq(1,2) // 1 <= 2
lteq(1,fieldA) // 1 <= fieldA
lteq(fieldA,val(foo)) fieldA <= "foo"
lteq(add(fieldA,fieldB),6) // fieldA + fieldB <= 6

markovChain

The markovChain function can be used to perform Markov Chain simulations. The markovChain function takes as its parameter a transition matrix and returns a mathematical model that can be sampled using the sample function. Each sample taken from the Markov Chain represents the current state of system.

sample(markovChain(transitionMatrix), 5)  // This creates a Markov Chain given a specific transition matrix. The sample function takes 5 samples from the Markov Chain, representing the next five states of the system.

matrix

The matrix function returns a matrix which can be operated on by functions that support matrix operations.

matrix(numericArray1, numericArray2, numericArray3) // Returns a matrix with three rows of data: numericaArray1, numericArray2, numericArray3

meanDifference

The meanDifference function calculates the mean of the differences following the element-by-element subtraction between two numeric arrays.

meanDifference(numericArray, numericArray)

minMaxScale

The minMaxScale function scales numeric arrays within a minimum and maximum value. By default minMaxScale scales between 0 and 1. The minMaxScale function can operate on both numeric arrays and matrices.

When operating on a matrix the minMaxScale function operates on each row of the matrix.

minMaxScale(numericArray) // scale a numeric array between 0 and 1
minMaxScale(numericArray, 0, 100) // scale a numeric array between 1 and 100
minMaxScale(matrix) // Scale each row in a matrix between 0 and 1
minMaxScale(matrix, 0, 100) // Scale each row in a matrix between 0 and 100

mod

The mod function returns the remainder (modulo) of the first parameter divided by the second parameter.

mod(100,3) // returns the remainder of 100 / 3 .
mod(100,fieldA) // returns the remainder of 100 divided by the value of fieldA.
mod(fieldA,1.4) // returns the remainder of fieldA divided by 1.4.
if(gt(fieldA,fieldB),mod(fieldA,fieldB),mod(fieldB,fieldA)) // if fieldA > fieldB then return the remainder of fieldA/fieldB, else return the remainder of fieldB/fieldA.

monteCarlo

The monteCarlo function performs a Monte Carlo simulation based on its parameters. The monteCarlo function runs another function a specified number of times and returns the results. The function being run typically has one or more variables that are drawn from probability distributions on each run. The sample function is used in the function to draw the samples.

The simulation’s result array can then be treated as an empirical distribution to understand the probabilities of the simulation results.

let(a=uniformIntegerDistribution(1, 6),
    b=uniformIntegerDistribution(1, 6),
    c=monteCarlo(add(sample(a), sample(b)), 1000))

movingAvg

The movingAvg function calculates a moving average over an array of numbers.

movingAverage(numericArray, 30)

movingMedian

The movingMedian function calculates a moving median over an array of numbers.

movingMedian(numericArray, 30)

mult

The mult function will take two or more numeric values and multiply them together. The mult function will fail to execute if any of the values are non-numeric. If a null value is found then null will be returned as the result.

mult(1,2,3,4) // 1 * 2 * 3 * 4
mult(1,fieldA) // 1 * value of fieldA
mult(fieldA,1.4) // value of fieldA * 1.4
mult(fieldA,fieldB,fieldC) // value of fieldA * value of fieldB * value of fieldC
mult(fieldA,div(fieldA,fieldB)) // value of fieldA * (value of fieldA / value of fieldB)
mult(fieldA,if(gt(fieldA,fieldB),fieldA,fieldB)) // if fieldA > fieldB then fieldA * fieldA, else fieldA * fieldB

normalDistribution

The normalDistribution function returns a normal probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

normalDistribution(mean, stddev)

normalizeSum

The normalizeSum function scales numeric arrays so that they sum to 1. The normalizeSum function can operate on both numeric arrays and matrices.

When operating on a matrix the normalizeSum function operates on each row of the matrix.

normalizeSum(numericArray)
normalizeSum(matrix)

not

The not function will return the logical NOT of a single boolean parameter. The function will fail to execute if the parameter is non-boolean or null. Returns a boolean value.

not(true) // false
not(fieldA) // true if fieldA is false else false
not(eq(fieldA,fieldB)) // true if fieldA != fieldB

olsRegress

The olsRegress function performs ordinary least squares, multivariate, linear regression.

The olsRegress function returns a single Tuple containing the regression model with estimated regression parameters, RSquared and regression diagnostics.

The output of olsRegress can be used with the predict function to predict values based on the regression model.

olsRegress(matrix, numericArray) // This performs the olsRegression analysis on given regressor matrix and outcome array.

or

The or function will return the logical OR of at least 2 boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

or(true,fieldA) // true || fieldA
or(fieldA,fieldB) // fieldA || fieldB
or(and(fieldA,fieldB),fieldC) // (fieldA && fieldB) || fieldC
or(fieldA,fieldB,fieldC,and(fieldD,fieldE),fieldF)

poissonDistribution

The poissonDistribution function returns a poisson probability distribution based on its parameter. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

poissonDistribution(mean)

polyFit

The polyFit function performs polynomial curve fitting.

polyFit(yValues) // This creates the xValues automatically and fits a curve through the data points using the default 3 degree polynomial.
polyFit(yValues, 5) // This creates the xValues automatically and fits a curve through the data points using a 5 degree polynomial.
polyFit(xValues, yValues, 5) // This will fit a curve through the data points using a 5 degree polynomial.

pow

The pow function returns the value of its first parameter raised to the power of its second parameter.

pow(2,3) // returns 2 raised to the 3rd power.
pow(4,fieldA) // returns 4 raised by the value of fieldA.
pow(fieldA,1.4) // returns the value of fieldA raised by 1.4.
if(gt(fieldA,fieldB),pow(fieldA,fieldB),pow(fieldB,fieldA)) // if fieldA > fieldB then raise fieldA by fieldB, else raise fieldB by fieldA.

predict

The predict function predicts the value of dependent variables based on regression models or functions.

The predict function can predict values based on the output of the following functions: spline, loess, regress, olsRegress.

predict(regressModel, number) // predict using the output of the <<regress>> function and single numeric predictor. This will return a single numeric prediction.

predict(regressModel, numericArray) // predict using the output of the <<regress>> function and a numeric array of predictors. This will return a numeric array of predictions.

predict(splineFunc, number) // predict using the output of the <<spline>> function and single numeric predictor. This will return a single numeric prediction.

predict(splineFunc, numericArray) // predict using the output of the <<spline>> function and a numeric array of predictors. This will return a numeric array of predictions.

predict(olsRegressModel, numericArray) // predict using the output of the <<olsRegress>> function and a numeric array containing one multi-variate predictor. This will return a single numeric prediction.

predict(olsRegressModel, matrix) // predict using the output of the <<olsRegress>> function and a matrix containing rows of multi-variate predictor arrays. This will return a numeric array of predictions.

primes

The primes function returns an array of prime numbers starting from a specified number.

primes(100, 2000) // returns 100 primes starting from 2000

probability

The probability function returns the probability of a random variable within a probability distribution.

The probability function computes the probability between random variable ranges for both continuous and discrete probability distributions.

The probability function can compute probabilities for a specific random variable for discrete probability distributions only.

The supported continuous distribution functions are: normalDistribution, logNormalDistribution, betaDistribution, gammaDistribution, empiricalDistribution, triangularDistribution, weibullDistribution, uniformDistribution, constantDistribution

The supported discreet distributions are: poissonDistribution, binomialDistribution, enumeratedDistribution, zipFDistribution, geometricDistribution, uniformIntegerDistribution

probability(poissonDistribution(10), 7) // Returns the probability of a random sample of 7 in a poisson distribution with a mean of 10.

probability(normalDistribution(10, 2), 7.5, 8.5) // Returns the probability between the range of 7.5 to 8.5 for a normal distribution with a mean of 10 and standard deviation of 2.

rank

The rank performs a rank transformation on a numeric array.

rank(numericArray)

raw

The raw function will return whatever raw value is the parameter. This is useful for cases where you want to use a string as part of another evaluator.

raw(foo) // "foo"
raw(count(*)) // "count(*)"
raw(45) // 45
raw(true) // "true" (note: this returns the string "true" and not the boolean true)
eq(raw(fieldA), fieldA) // true if the value of fieldA equals the string "fieldA"

regress

The regress function performs a simple regression of two numeric arrays.

The result of this expression is also used by the predict function.

regress(numericArray1, numericArray2)

rev

The rev function reverses the order of a numeric array.

rev(numericArray)

round

The round function returns the closest whole number to the argument.

round(100.4)
round(fieldA)
if(gt(fieldA,fieldB),sqrt(fieldA),sqrt(fieldB)) // if fieldA > fieldB then return the round of fieldA, else return the round of fieldB

rowAt

The rowAt function returns the row of a matrix at a specific index as a numeric array.

rowAt(matrix, 10)

rowCount

The rowCount function returns the number of rows in a matrix.

rowCount(matrix)

sample

The sample function can be used to draw random samples from a probability distribution or Markov Chain.

sample(poissonDistribution(5)) // Returns a single random sample from a poissonDistribution with mean of 5.
sample(poissonDistribution(5), 1000) // Returns 1000 random samples from poissonDistribution with a mean of 5.
sample(markovChain(transitionMatrix), 1000) // Returns 1000 random samples from a Markov Chain.

scalarAdd

The scalarAdd function adds a scalar value to every value in a numeric array or matrix. When working with numeric arrays, scalarAdd returns a new array with the new values. When working with a matrix, scalarAdd returns a new matrix with new values.

scalarAdd(number, numericArray) // Adds the number to each element in the number in the array.
scalarAdd(number, matrix) // Adds the number to each value in a matrix

scalarDivide

The scalarDivide function divides each number in numeric array or matrix by a scalar value. When working with numeric arrays, scalarDivide returns a new array with the new values. When working with a matrix, scalarDivide returns a new matrix with new values.

scalarDivide(number, numericArray) // Divides each element in the numeric array by the number.
scalarDivide(number, matrix) // Divides each element in the matrix by the number.

scalarMultiply

The scalarMultiply function multiplies each element in a numeric array or matrix by a scalar value. When working with numeric arrays, scalarMultiply returns a new array with the new values. When working with a matrix, scalarMultiply returns a new matrix with new values.

scalarMultiply(number, numericArray) // Multiplies each element in the numeric array by the number.
scalarMultiply(number, matrix) // Multiplies each element in the matrix by the number.

scalarSubtract

The scalarSubtract function subtracts a scalar value from every value in a numeric array or matrix. When working with numeric arrays, scalarSubtract returns a new array with the new values. When working with a matrix, scalarSubtract returns a new matrix with new values.

scalarSubtract(number, numericArray) // Subtracts the number from each element in the number in the array.
scalarSubtract(number, matrix) // Subtracts the number from each value in a matrix

scale

The scale function multiplies all the elements of an array by a number.

scale(number, numericArray)

sequence

The sequence function returns an array of numbers based on its parameters.

sequence(100, 0, 1) // Returns a sequence of length 100, starting from 0 with a stride of 1.

setAttributes

The setAttributes function sets an attributes map of a matrix.

setAttributes(matrix, map)

setColumnLabels

The setColumnLabels function sets the columns labels of a matrix.

setRowLabels

The setRowLabels function sets the row labels of a matrix.

setValue

The setValue function sets a new value for a Tuple entry.

sin

The sin function returns the trigonometric sine of a number.

sin(100.4)  // returns the sine of 100.4
sine(fieldA) // returns the sine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the sine of fieldA, else return the sine of fieldB

spline

The spline function performs a cubic spline interpolation (https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation) of a curve given a set of x,y coordinates. The return value of the spline function is an interpolation function which can be used to predict values along the curve and generate a derivative of the curve.

spline(yValues) // This creates the xValues automatically and fits a spline through the data points.
spline(xValues, yValues) // This will fit a spline through the data points.

sqrt

The sqrt function returns the trigonometric square root of a number.

sqrt(100.4)  // returns the square root of 100.4
sqrt(fieldA) // returns the square root for fieldA.
if(gt(fieldA,fieldB),sqrt(fieldA),sqrt(fieldB)) // if fieldA > fieldB then return the sqrt of fieldA, else return the sqrt of fieldB

standardize

The standardize function standardizes a numeric array so that values within the array have a mean of 0 and standard deviation of 1.

standardize(numericArray)

sub

The sub function will take 2 or more numeric values and subtract them, from left to right. The sub function will fail to execute if any of the values are non-numeric. If a null value is found then null will be returned as the result.

sub(1,2,3,4) // 1 - 2 - 3 - 4
sub(1,fieldA) // 1 - value of fieldA
sub(fieldA,1.4) // value of fieldA - 1.4
sub(fieldA,fieldB,fieldC) // value of fieldA - value of fieldB - value of fieldC
sub(fieldA,div(fieldA,fieldB)) // value of fieldA - (value of fieldA / value of fieldB)
if(gt(fieldA,fieldB),sub(fieldA,fieldB),sub(fieldB,fieldA)) // if fieldA > fieldB then fieldA - fieldB, else fieldB - field

sumDifference

The sumDifference function calculates the sum of the differences following an element-by-element subtraction between two numeric arrays.

sumDifference(numericArray, numericArray)

sumColumns

The sumColumns function sums the columns in a matrix and returns a numeric array with the result.

sumColumns(matrix)

sumRows

The sumRows function sums the rows in a matrix and returns a numeric array with the result.

sumRows(matrix)

sumSq

The sumSq function returns the sum-of-squares of the values in a numeric array.

sumSq(numericArray)

transpose

The transpose function transposes a matrix .

transpose(matrix)

triangularDistribution

The triangularDistribution function returns a triangular probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

triangularDistribution(10, 15, 20) // A triangular distribution with a low value of 10, most likely value of 15 and high value of 20.

uniformDistribution

The uniformDistribution function returns a continuous uniform probability distribution based on its parameters. See the uniformIntegerDistribution to work with discrete uniform distributions. This function is part of the probability distribution framework and is designed to work with the sample and cumulativeProbability functions.

uniformDistribution(0.0, 100.0)

uniformIntegerDistribution

The uniformIntegerDistribution function returns a discrete uniform probability distribution based on its parameters. See the uniformDistribution to work with continuous uniform distributions. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

uniformDistribution(1, 6)

unitize

The unitize function scales numeric arrays to a magnitude of 1, often called unit vectors. The unitize function can operate on both numeric arrays and matrices.

When operating on a matrix the unitize function unitizes each row of the matrix.

unitize(numericArray) // Unitize a numeric array
unitize(matrix) // Unitize each row in a matrix

weibullDistribution

The weibullDistribution function returns a Weibull probability distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, kolmogorovSmirnov and cumulativeProbability functions.

weibullDistribution(.5, 10)

zipFDistribution

The zipFDistribution function returns a ZipF distribution based on its parameters. This function is part of the probability distribution framework and is designed to work with the sample, probability and cumulativeProbability functions.

zipFDistribution(5000, 1.0)