Plan Documentation

Array Plans (Paternova™ v.0.9.9)

An array is an ordered list of floating-point numbers. The following functions, or "plans," can be used to create, modify, calculate, read, write, and otherwise manipulate arrays in Paternova.

Get an Array

These plans create an array using the information provided by the user.

Custom Array

Plan to generate a custom array.

Description

This plan generates an array based on the specified array x. The array parameter can be specified either as an array expression or as a reference to the output array in another cell. For example, B1 specifies a relative reference to the array in cell B1; $B$1 specifies an absolute reference to the array in that cell; and B$1 or $B1 specify mixed references, where only the row or the column is absolute. When an array expression is provided, this plan computes the output array by evaluating the array expression x value by value, with array values separated by commas.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

x = {10}	⇒	{10}
x = {3*2-7,pi}	⇒	{-1,3.14159}
x = $B1	⇒	B1

Fill Array

Plan to generate a filled array.

Description

This plan fills an array of length n with the values in the array a. If there are not enough values available in a, its last value is used to fill the remainder of the output array.

Example

n = {2};	a = {3}	⇒	{3,3}
n = {4};	a = {1,3,5}	⇒	{1,3,5,5}

Generating Expressions

Plan to generate values with expression.

Description

This plan generates an array of length n by evaluating the expression f(i) at each index i.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

n = {6};	f = {i+1}	⇒	{1,2,3,4,5,6}
n = {3};	f = {2*i-3}	⇒	{-3,-1,1}
n = {4};	f = {i^2}	⇒	{0,1,4,9}

Polynomial Expansion

Plan to generate values with polynomial expansion.

Description

This plan generates an array of length n by evaluating the polynomial expansion: a[0]+a[1]×i+a[2]×i²+... at each index i.

Example

n = {3};	a = {0,1}	⇒	{0,1,2}
n = {3};	a = {1,2,3}	⇒	{1,6,17}

Fourier Expansion

Plan to generate values with Fourier expansion.

Description

This plan generates an array of length n by evaluating the sine-cosine Fourier expansion: a[0]+a[1]×cos(2πi/p)+b[1]×sin(2πi/p)+a[2]×cos(2πi×2/p)+... at each index i. In this expansion, p is the period, and b[0] is omitted.

Example

Example

n = {3};

k = {1}

⇒

{0.438988, 1.37627, 15.1283}

Randomized - Cauchy

Plan to randomize values with Cauchy distribution.

Description

This plan generates an array of n random numbers with a Cauchy distribution, using the parameters x₀ and γ.

Example

Example

n = {3};

k = {1};

λ = {1}

⇒

This plan extracts an array from a JSON file with the given file name, where the values collected in the output array are identified by the specified key.

Example

file name = {tests\stock_query_IBM.json};

key = {4. close}

⇒

{...}

Extract From JSON on Network

Plan to extract an array from a JSON on network.

Description

This plan requests and extracts an array from a JSON file at a network address, where the values collected in the output array are identified by the specified key.

Example

address = {https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=IBM&apikey=demo};

key = {4. close}

⇒

{...}

Convert Matrix Along Rows

Plan to generate an array from matrix rows.

Description

This plan generates an array from the real parts of the rows in the matrix x. When the parameter rows is specified, only the elements in those rows are used to produce the output array; otherwise, all matrix elements are listed along the rows. More specialized plans for generating an array from a matrix are available under Matrix Plans/Highlight a Matrix/Array Converters.

Example

x = {1,2,3;4,5,6};	rows = {}	⇒	{1,2,3,4,5,6}
x = {1,2,3;4,5,6};	rows = {1,0,1}	⇒	{4,5,6,1,2,3,4,5,6}
x = {1,2*sqrt(-1);4,5};	rows = {}	⇒	{1,0,4,5}

Convert Matrix Along Columns

Plan to generate an array from matrix columns.

Description

This plan generates an array from the real parts of the columns in the matrix x. When the parameter columns is specified, only the elements in those columns are used to produce the output array; otherwise, all matrix elements are listed along the columns. More specialized plans for generating an array from a matrix are available under Matrix Plans/Highlight a Matrix/Array Converters.

Example

x = {1,2,3;4,5,6};	columns = {}	⇒	{1,4,2,5,3,6}
x = {1,2,3;4,5,6};	columns = {1,0,1}	⇒	{2,5,1,4,2,5}
x = {1,2*sqrt(-1);4,5};	columns = {}	⇒	{1,4,0,5}

Convert Text

Plan to generate an array from a text.

Description

This plan generates an array from the text x. The value tokens in x are separated by the specified delimiter. Alternatively, when the ltag and rtag parameters are specified, value tokens are detected when they are enclosed by ltag on the left and rtag on the right. Each value token is evaluated to generate a value for the output array.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

x = {1;2;3;4};	delimiter = {;};	ltag = {};	rtag = {}	⇒	{1,2,3,4}
x = {1<2>3<4>};	delimiter = {};	ltag = {<};	rtag = {>}	⇒	{2,4}

Convert Text List

Plan to generate an array from a text list.

Description

This plan generates an array from the text list x. Each text item in the specified text list is evaluated to generate a value for the output array.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

x = {"1",2,3,"4"}	⇒	{1,2,3,4}
x = {1,2-3,sqrt(4),3-5}	⇒	{1,-1,2,-2}

Alpha Vantage - Stock and Security Prices

Plan to import historical prices from Alpha Vantage API.

Description

This plan imports historical prices for a stock or cryptocurrency symbol from the Alpha Vantage API. Requests are made using the specified function and are authenticated with an api key. Some functions may require specifying an exchange market or a time interval. Values assigned to a token (e.g., close for the closing price, open for the opening price, etc.) are collected in the output array. If not_adjusted is empty, the response will be adjusted for historical split and dividend events. If no_extended_hours is empty, the response will include the extended (pre- and post-market) trading hours (4:00 a.m. to 8:00 p.m. EST for the US market). If is_full is empty, the response will include only the most recent data.

Notes:

To acquire an api key, go to https://www.alphavantage.co/support.
To learn more about the API parameters, visit https://www.alphavantage.co/documentation.
This plan requests data from Alpha Vantage's servers by sharing the plan parameters. The Alpha Vantage privacy policy is available at https://www.alphavantage.co/privacy.
You may need to increase the network timeout (Preferences > Network Timeout) to allow enough time for the API response to arrive.
A corresponding plan to generate the complete API response is available under Text Plans/Get/3rd-Party Importers - Raw Response.

Example

function = {TIME_SERIES_DAILY};	symbol = {IBM};	token = {close};	market = {};	interval = {};	api key = {demo}	⇒	{...}
function = {CRYPTO_INTRADAY};	symbol = {ETH};	token = {high};	market = {USD};	interval = {5min};	api key = {demo}	⇒	{...}

Rearrange an Array

These plans produce an array by rearranging another array.

Copy Array

Plan to copy an array.

Description

This plan copies all the values in the array x.

Example

x = {1,2,3}	⇒	{1,2,3}
x = {1-1,2+pi}	⇒	{0,5.14159}

Replicate Array

Plan to replicate an array.

Description

This plan replicates the array x by duplicating each value m times, and then repeating the resulting array n times, producing {x[0](m times), x[1](m times),...}(n times).

Example

x = {1,2,3};

m = {2};

n = {3}

⇒

This plan shifts and cycles each value in a copy of array x toward the beginning by n positions.

Example

x = {1,2,3};

n = {1}

⇒

{2,3,1}

Shift Values Toward End

Plan to shift values toward the end.

Description

This plan shifts and cycles each value in a copy of array x toward the end by n positions.

Example

Example

x = {1,2,3}	⇒	{1,3,2}
x = {1,3,2}	⇒	{2,1,3}
x = {2,1,3}	⇒	{2,3,1}
x = {2,3,1}	⇒	{3,1,2}
x = {3,1,2}	⇒	{3,2,1}
x = {3,2,1}	⇒	{1,2,3}

Permute Values into Previous Permutation

Plan to permute values into the previous permutation.

Description

This plan arranges the values in a copy of array x to form the previous permutation. The set of all permutations of the array x is ordered lexicographically with respect to the less-than predicate.

Example

x = {1,2,3}	⇒	{3,2,1}
x = {3,2,1}	⇒	{3,1,2}
x = {3,1,2}	⇒	{2,3,1}
x = {2,3,1}	⇒	{2,1,3}
x = {2,1,3}	⇒	{1,3,2}
x = {1,3,2}	⇒	{1,2,3}

First Value

Plan to copy the first value.

Description

This plan copies the first value in the array x.

Example

x = {1,2,3,4,5}

⇒

{1}

Last Value

Plan to copy the last value.

Description

This plan copies the last value in the array x.

Example

x = {1,2,3,4,5}

⇒

{5}

Copy Values From Start

Plan to copy values at indices counted from the beginning.

Description

This plan copies the values at the indices specified by n from the array x to produce the output array. The result at index i is a copy of the n[i]-th value in the array x, counted from the beginning.

Example

x = {1,2,3,4,5};	n = {2}	⇒	{3}
x = {1,2,3,4,5};	n = {2,0,1,2,1,3}	⇒	{3,1,2,3,2,4}

Copy Values From End

Plan to copy values at indices counted from the end.

Description

This plan copies the values at the reverse indices specified by n from the array x to produce the output array. The result at index i is a copy of the n[i]-th value in the array x, counted from the end. Reverse indices traverse the array in reverse order.

Example

x = {1,2,3,4,5};	n = {2}	⇒	{3}
x = {1,2,3,4,5};	n = {2,0,1,2,1,3}	⇒	{3,5,4,3,4,2}

Remove Values From Start

Plan to remove values at indices counted from the beginning.

Description

This plan removes, from a copy of array x, the values at the indices specified by n[k] for each k.

Example

x = {1,2,3,4,5};	n = {2}	⇒	{1,2,4,5}
x = {1,2,3,4,5};	n = {2,0,1,2,1,3}	⇒	{5}

Remove Values From End

Plan to remove values at indices counted from the end.

Description

This plan removes, from a copy of array x, the values at the reverse indices specified by n[k] for each k. Reverse indices traverse the array in reverse order.

Example

x = {1,2,3,4,5};	n = {2}	⇒	{1,2,4,5}
x = {1,2,3,4,5};	n = {2,0,1,2,1,3}	⇒	{1}

Keep Ranges From Start

Plan to keep values in index ranges counted from the beginning.

Description

This plan retains, in a copy of array x, only the values at indices that fall within any of the ranges [a[k], b[k]).

Example

x = {1,2,3,4,5,6};	a = {1,3};	b = {1,4}	⇒	{4}
x = {1,2,3,4,5,6};	a = {0,3};	b = {2,7}	⇒	{1,2,4,5,6}

Keep Ranges From End

Plan to keep values in index ranges counted from the end.

Description

This plan retains, in a copy of array x, only the values at reverse indices that fall within any of the ranges [a[k], b[k]). Reverse indices traverse the array in reverse order.

Example

x = {1,2,3,4,5,6};	a = {1,3};	b = {1,4}	⇒	{3}
x = {1,2,3,4,5,6};	a = {0,3};	b = {2,7}	⇒	{1,2,3,5,6}

Remove Ranges From Start

Plan to remove values in index ranges counted from the beginning.

Description

This plan removes, from a copy of array x, the values at indices that fall within any of the ranges [a[k], b[k]).

Example

x = {1,2,3,4,5,6};	a = {1,3};	b = {1,4}	⇒	{1,2,3,5,6}
x = {1,2,3,4,5,6};	a = {0,3};	b = {2,7}	⇒	{3}

Remove Ranges From End

Plan to remove values in index ranges counted from the end.

Description

This plan removes, from a copy of array x, the values at reverse indices that fall within any of the ranges [a[k], b[k]). Reverse indices traverse the array in reverse order.

Example

x = {1,2,3,4,5,6};	a = {1,3};	b = {1,4}	⇒	{1,2,4,5,6}
x = {1,2,3,4,5,6};	a = {0,3};	b = {2,7}	⇒	{4}

⇒

{1,4}

Remove Values

Plan to remove values.

Description

This plan removes, from a copy of array x, any values that are equal to any of the values in the array a.

Example

x = {1,2,3,4,5,6};

a = {4,3.2,1}

⇒

Keep Extreme Values

Plan to keep peaks and valleys.

Description

This plan retains, in a copy of array x, only the peaks (values greater than their neighboring values) and valleys (values less than their neighboring values).

Example

x = {1,2,3,3,2,1}	⇒	{1,3,1}
x = {1,2,3,3,2,1,2,2,3,3}	⇒	{1,3,1,3}

Remove Small Variations - Value

Plan to apply a hysteresis filter based on value.

Description

This plan removes, from a copy of array x, any values whose deviation from the previous neighboring value is less than a.

Example

x = {1,2,2.2,3};

a = {0.5}

⇒

{1,2,3}

Remove Small Variations - Ratio

Plan to apply a hysteresis filter based on ratio.

Description

This plan removes, from a copy of array x, any values whose deviation from the previous neighboring value is less than a times their own value.

Example

x = {1,2,2.2,3};

a = {0.1}

⇒

{1,2,3}

Remove Large Variations - Value

Plan to remove spikes based on their value.

Description

This plan removes, from a copy of array x, any peaks (values greater than their neighboring values) or valleys (values less than their neighboring values) whose deviation from both neighboring values is greater than a.

Example

x = {1,2,3,10,3,2,1};	a = {5}	⇒	{1,2,3,3,2,1}
x = {1,2,3,10,3,2,1};	a = {9}	⇒	{1,2,3,10,3,2,1}

Remove Large Variations - Ratio

Plan to remove spikes based on their ratio.

Description

Example

x = {1,2,3,10,3,2,1};	a = {2}	⇒	{1,2,3,3,2,1}
x = {1,2,3,10,3,2,1};	a = {3}	⇒	{1,2,3,10,3,2,1}

Remove Large Deviations - Value

Plan to remove values based on their distance to average.

Description

This plan removes, from a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {4}	⇒	{1,2,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {5}	⇒	{1,2,3,10,3,2,1}

Remove Large Deviations - Ratio

Plan to remove values based on their distance to average relative to average.

Description

This plan removes, from a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a times the moving average.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {0.5}	⇒	{1,2,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {1}	⇒	{1,2,3,10,3,2,1}

Remove Large Deviations - σ-Ratio

Plan to remove values based on their distance to average relative to standard deviation.

Description

This plan removes, from a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a times the moving standard deviation.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {0.7}	⇒	{1,2,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {1}	⇒	{1,2,3,10,3,2,1}

Rearrange Multiple Arrays

These plans produce an array by rearranging multiple arrays.

Nth Array

Plan to copy the nth array.

Description

This plan copies the nth array.

Example

n = {1};

x₀ = {1,2,3};

x₁ = {4,5}

⇒

{4,5}

Conditional Copy

Plan to conditionally copy an array.

Description

This plan copies the array x if array z is not empty; otherwise, it copies the array y. Note that refresh requests are not propagated to the parameters x, y, and z.

Example

x = {1,2,3};	y = {7,6,8};	z = {1,2}	⇒	{1,2,3}
x = {1,2,3};	y = {7,6,8};	z = {}	⇒	{7,6,8}

⇒

{1,2,3,1,2,3,4,5,4,5, 1,2,3,1,2,3,4,5,4,5, 1,2,3,1,2,3,4,5,4,5}

Interleave and Repeat

Plan to interleave and replicate arrays.

Description

This plan produces the output array by interleaving m copies of the given arrays and then replicating the resulting array n times. The output is structured as follows: {(x₀[0],x₁[0],...)(m times),(x₀[1],x₁[1],...)(m times),...}(n times).

Example

m = {2};

n = {3};

x₀ = {1,2,3};

x₁ = {4,5}

⇒

source = {6,5,4,3,2,1};

reference = {1,2,3,4,5,6};

a = {4,3.2,1}

⇒

{6,3}

Conditionally Remove Values

Plan to remove when corresponding values match given values.

Description

This plan removes, from a copy of array source, any values whose corresponding reference value is equal to any value in the array a. The reference value for source[i] is defined as the value at index i in the specified reference array.

Example

source = {6,5,4,3,2,1};

reference = {1,2,3,4,5,6};

a = {4,3.2,1}

⇒

source = {8,7,6,5,4,3,2,1};

reference = {1,1,2,3,4,5,6,6}

⇒

{6,5,4,3}

Conditionally Trim Same Starting Values

Plan to trim when corresponding values from the beginning are equal to the corresponding beginning.

This plan replaces, in a copy of array x, any values whose magnitude is less than or equal to a with 0. For each index k, the copy of x[k] is replaced with 0 if its magnitude is less than or equal to a[k]. The last value in a is used when k is out of bounds.

Example

x = {0.1,0.2,1e-5,-0.4};

a = {1e-3}

⇒

x = {1,2,3,4,5,6};

minimum = {-1};

maximum = {1}

⇒

{-1,-0.6,-0.2,0.2,0.6,1}

Scale Values Uniformly

Plan to uniformly change values.

Description

This plan uniformly, though not necessarily linearly, scales all values in a copy of array x such that a[k] is mapped to b[k] for each index k. This scaling interpolates each x[k] using a Lagrange polynomial derived from mapping the values in the array a to the corresponding values in the array b.

Example

x = {1,2,3,4,5,6};	a = {1,6};	b = {-1,1}	⇒	{-1,-0.6,-0.2,0.2,0.6,1}
x = {1,2,3,4,5,6};	a = {1,2,6};	b = {-1,0,1}	⇒	{-1,0,0.7,1.1,1.2,1}

Modifying Expressions

Plan to compute values with expressions.

Description

This plan sets the values in an output array of length n by evaluating the expressions in f = {f[0],f[1],...}, where f[i] is a function of i, x, x0, x1, xp1, xn1, and so on. The output array is computed as f[i] for each index i<n, or as the last function in f if there is no corresponding f[i] available. In these expressions, i is the index starting from 0, and x is the value of the array x at that index. Fixed references are represented as x0=x[0], x1=x[1], and so on; relative references are represented as xp1=x[i-1], xn1=x[i+1], and so forth. Out-of-range values are replaced with 0. If the parameter n is not specified, it is set to the length of the array x.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

x = {1,2,3,4};	f = {i*x};	n = {}	⇒	{0,2,6,12}
x = {1,2,3,4};	f = {x2,x1-x};	n = {}	⇒	{3,0,-1,-2}
x = {1,2,3,4};	f = {2*x-xp1-xn1};	n = {}	⇒	{0,0,0,5}
x = {1,2,3,4};	f = {2*x-xp1-xn1+i};	n = {6}	⇒	{0,1,2,8,0,5}

This plan normalizes a copy of array x to have a unit p-norm by dividing each value by the p-norm of the array x. The norm parameter p can be any real number ≥1 or inf.

Example

x = {0,1,0,1};	p = {2}	⇒	{0,0.707107,0,0.707107}
x = {0,1,0,-1};	p = {1}	⇒	{0,0.5,0,-0.5}

Project Array to Hyperplane

Plan to project onto a hyperplane as point.

Description

This plan finds the projection of the point specified by the array x onto the hyperplane in N-dimensional space defined by the equation a[0]x[0]+a[1]x[1]+...+a[N-1]x[N-1] = a[N]. The plane coefficients are given in the array a. The right-hand side of the plane equation is set to 0 when a[N] is out of range.

Example

x = {0,0,0};	a = {1,1,1,1}	⇒	{0.333333,0.333333,0.333333}
x = {2,5};	a = {1,0}	⇒	{0,5}

Project Array to Line

Plan to project onto a line as point.

Description

This plan finds the projection of the point specified by the array x onto the line defined by the points a and b.

Example

x = {1,0,0};	a = {0,1,0};	b = {0,0,1}	⇒	{0,0.5,0.5}
x = {2,5};	a = {0,-1};	b = {0,1}	⇒	{0,5}

Value Addition

Plan to add given values to array values.

Description

This plan computes x[k]+a[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{0,1,2,3}
x = {1,2,3,4};	a = {1,2,3}	⇒	{2,4,6,7}

Value Subtraction - Minuend

Plan to subtract given values from array values.

Description

This plan computes x[k]-a[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{2,3,4,5}
x = {1,2,3,4};	a = {1,2,3}	⇒	{0,0,0,1}

Value Subtraction - Subtracted

Plan to subtract array values from given values.

Description

This plan computes a[k]-x[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{-2,-3,-4,-5}
x = {1,2,3,4};	a = {1,2,3}	⇒	{0,0,0,-1}

Value Multiplication

Plan to multiply array values by given values.

Description

This plan computes x[k]×a[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{-1,-2,-3,-4}
x = {1,2,3,4};	a = {1,2,3}	⇒	{1,4,9,12}

Value Division - Numerator

Plan to divide array values by given values.

Description

This plan computes x[k]/a[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{-1,-2,-3,-4}
x = {1,2,3,4};	a = {1,2,3}	⇒	{1,1,1,1.33333}

Value Division - Denominator

Plan to divide given values by array values.

Description

This plan computes a[k]/x[k] for each index k to produce the output array. The last value in a is used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1}	⇒	{-1,-0.5,-0.333333,-0.25}
x = {1,2,3,4};	a = {1,2,3}	⇒	{1,1,1,0.75}

Value Square

Plan to compute the square of each value.

Description

This plan computes the square of x[k] for each index k to produce the output array.

Example

x = {1,4,0.25,-1}

⇒

{1,16,0.0625,1}

Value Square Root

Plan to compute the square root of each value.

Description

This plan computes the square root of x[k] for each index k to produce the output array.

Example

x = {1,4,0.25,-1}

⇒

{1,2,0.5,nan}

Value Exponentiation - Base

Plan to raise array values to the power of given values.

Description

This plan computes c[k]×x[k]^a[k] for each index k to produce the output array. The last values in a and c are used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1};	c = {1}	⇒	{1,0.5,0.3333333,0.25}
x = {1,2,3,4};	a = {1,2,3};	c = {1,0,2}	⇒	{1,0,54,128}

Value Exponentiation - Exponent

Plan to raise given values to the power of array values.

Description

This plan computes c[k]×a[k]^x[k] for each index k to produce the output array. The last values in a and c are used when k is out of bounds.

Example

x = {1,2,3,4};	a = {-1};	c = {1}	⇒	{-1,1,-1,1}
x = {1,2,3,4};	a = {1,2,3};	c = {1,0,2}	⇒	{1,0,54,162}

Value Exponential Function

Plan to compute the exponential function of each value.

Description

This plan computes the exponential function of x[k] as c[k]×e^a[k]x[k] for each index k to produce the output array. The last values in a and c are used when k is out of bounds.

Example

x = {0,1,2};	a = {1};	c = {1}	⇒	{1,2.71828,7.38906}
x = {0,1,2};	a = {1,2};	c = {1}	⇒	{1,7.38906, 54.5982}

Value Logarithm

Plan to compute the logarithm of each value.

Description

This plan computes the natural logarithm of x[k] as c[k]×log(x[k]+a[k]) for each index k to produce the output array. The last values in a and c are used when k is out of bounds.

Example

x = {0,1,2};	a = {0};	c = {1}	⇒	{-inf,0,0.693147}
x = {0,1,2};	a = {1,2};	c = {0,1}	⇒	{0,1.09861,1.38629}

Value Logistic Function

Plan to compute the logistic function of each value.

Description

This plan computes the logistic function of x[k] as 1/(1+e^-x[k]) for each index k to produce the output array.

Example

x = {0,0.1,-1}

⇒

{0.5,0.524979,0.268941}

Value Logit Function

Plan to compute the logit function of each value.

Description

This plan computes the inverse logistic (logit) function of x[k] as log(x[k] / (1-x[k])) for each index k to produce the output array.

Example

x = {0,0.1,-1}

⇒

{-inf,-2.19722,nan}

Value Sine

Plan to compute the sine of each value.

Description

This plan computes the sine of x[k] as c[k]×sin(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{0,0.841471,0,-1}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{0,-0.909297,0,0}

Value Cosine

Plan to compute the cosine of each value.

Description

This plan computes the cosine of x[k] as c[k]×cos(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{1,0.540302,-1,0}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{1,0.416147,-1,1}

Value Tangent

Plan to compute the tangent of each value.

Description

This plan computes the tangent of x[k] as c[k]×tan(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{0,1.55741,0,-inf}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{0,2.18504,0,0}

Value Cotangent

Plan to compute the cotangent of each value.

Description

This plan computes the cotangent of x[k] as c[k]×cot(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{inf,0.642093,-inf,0}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{inf,0.457658,inf,-inf}

Value Secant

Plan to compute the secant of each value.

Description

This plan computes the secant of x[k] as c[k]×sec(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{1,1.85082.0,-1,inf}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{1,2.403,-1,1}

Value Cosecant

Plan to compute the cosecant of each value.

Description

This plan computes the cosecant of x[k] as c[k]×csc(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,1,pi,-pi/2};	a = {1};	b = {0};	c = {1}	⇒	{inf,1.1884,inf,-1}
x = {0,1,pi,-pi/2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{inf,-1.09975,inf,inf}

Value Inverse Sine

Plan to compute the inverse sine of each value.

Description

This plan computes the inverse sine of x[k] as c[k]×sin^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{0,-1.5708,0.523599,nan}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{0,nan,-1.5708,nan}

Value Inverse Cosine

Plan to compute the inverse cosine of each value.

Description

This plan computes the inverse cosine of x[k] as c[k]×cos^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{1.5708,3.14159,1.0472,nan}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{1.5708,nan,0,nan}

Value Inverse Tangent

Plan to compute the inverse tangent of each value.

Description

This plan computes the inverse tangent of x[k] as c[k]×tan^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{0,-0.785398,0.463648,1.10715}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{0,1.10715,-0.785398,-1.32582}

Value Inverse Cotangent

Plan to compute the inverse cotangent of each value.

Description

This plan computes the inverse cotangent of x[k] as c[k]×cot^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{1.5708,-0.785398,1.10715,0.463648}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{1.5708,0.463648,-0.785398,-0.244979}

Value Inverse Secant

Plan to compute the inverse secant of each value.

Description

This plan computes the inverse secant of x[k] as c[k]×sec^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{nan,3.14159,nan,1.0472}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{nan,-2.0944,0,-1.31812}

Value Inverse Cosecant

Plan to compute the inverse cosecant of each value.

Description

This plan computes the inverse cosecant of x[k] as c[k]×csc^-1(a[k]×x[k]+b[k]) for each index k to produce the output array. The last values in a, b, and c are used when k is out of bounds.

Example

x = {0,-1,0.5,2};	a = {1};	b = {0};	c = {1}	⇒	{nan,-1.5708,nan,0.523599}
x = {0,-1,0.5,2};	a = {1,2};	b = {0};	c = {1,-1}	⇒	{nan,0.523599,-1.5708,-0.25268}

x = {1,3,-2,7,0,4};

a = {2,1,-1}

⇒

{1,2.33333,-1,4.5,4.5,0.5}

Sliding Exponentially Weighted Mean in Array

Plan to compute exponentially weighted means.

Description

This plan computes the sliding exponentially weighted mean, or exponential moving average (EMA), defined as

EMA[k] = αx[k] + (1-α)EMA[k-1],

for each index k, to produce the output array. Here, α is the smoothing factor.

Example

x = {1,3,-2,7,0,4};

α = {0.9}

⇒

x = {1,2,3,10,3,2,1};	a = {5}	⇒	{1,2,3,3,3,2,1}
x = {1,2,3,10,3,2,1};	a = {9}	⇒	{1,2,3,10,3,2,1}

Flatten Based on Ratio

Plan to flatten spikes based on their ratio.

Description

Example

x = {1,2,3,10,3,2,1};	a = {2}	⇒	{1,2,3,3,3,2,1}
x = {1,2,3,10,3,2,1};	a = {3}	⇒	{1,2,3,10,3,2,1}

Flatten Based on Residual

Plan to flatten values based on their residual.

Description

This plan flattens, in a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {4}	⇒	{1,2,3,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {5}	⇒	{1,2,3,10,3,2,1}

Flatten Based on Residual Ratio

Plan to flatten values based on their residual ratio.

Description

This plan flattens, in a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a times the moving average.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {0.5}	⇒	{1,2,3,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {1}	⇒	{1,2,3,10,3,2,1}

Flatten Based on Z-Score

Plan to flatten values based on their standard score.

Description

This plan flattens, in a copy of array x, any values whose deviation from the moving average (with window size w) is greater than a times the moving standard deviation.

Example

x = {1,2,3,10,3,2,1};	w = {3};	a = {0.7}	⇒	{1,2,3,3,3,2,1}
x = {1,2,3,10,3,2,1};	w = {3};	a = {1}	⇒	{1,2,3,10,3,2,1}

Low-Pass Butterworth Filter

Plan to apply a low-pass Butterworth filter.

Description

This plan applies a digital second-order low-pass Butterworth filter n times, with a timestep T and a cutoff frequency fc, to the array x to produce the output array. Every other application of the filter is performed in reverse. Filter warping is implemented according to SAE J211. Setting n=2 generates a CFC filer (SAE J211).

Example

x = {1,1,1,0,0,0};	T = {1};	fc = {0.1};	n = {1}	⇒	{1,1,1,0.780769,0.273928,-0.0619892}
x = {1,1,1,0,0,0};	T = {1};	fc = {0.1};	n = {2}	⇒	{1.05312,0.995235,0.710816,0.293026,0.0116545,-0.0619892}

High-Pass Butterworth Filter

Plan to apply a high-pass Butterworth filter.

Description

This plan applies a digital second-order high-pass Butterworth filter n times, with a timestep T and a cutoff frequency fc, to the array x to produce the output array. Every other application of the filter is performed in reverse. Filter warping is implemented according to SAE J211.

Example

x = {1,1,1,0,0,0};	T = {1};	fc = {0.1};	n = {1}	⇒	{0,0,0,-0.37518,0.258162,0.151362}
x = {1,1,1,0,0,0};	T = {1};	fc = {0.1};	n = {2}	⇒	{-0.0546581,-0.000829026,0.288099,-0.265189,0.0400693,0}

First-Order Filter

Plan to apply a digital first-order filter.

Description

This plan applies a digital first-order filter, defined as

H(s) = (b₀s+b₁) / (a₀s+a₁),

to the array x a total of n times to produce the output array. T is the step size and f₀ is the warping frequency at which the digital and analog filters agree. Every other application of the filter is performed in reverse.

Example

x = {1,1,1,0,0,0};	T = {1};	f₀ = {0.1};	a₀ = {1};	a₁ = {1};	b₀ = {0};	b₁ = {1};	n = {1}	⇒	{1,1,1,0.659141,0.209793,0.0667734}
x = {1,1,1,0,0,0};	T = {1};	f₀ = {0.1};	a₀ = {1};	a₁ = {1};	b₀ = {0};	b₁ = {1};	n = {2}	⇒	{0.966722,0.895446,0.671506,0.332953,0.115523,0.0667734}

Second-Order Filter

Plan to apply a digital second-order filter.

Description

This plan applies a digital second-order filter, defined as

H(s) = (b₀s²+b₁s+b₂) / (a₀s²+a₁s+a₂),

to the array x a total of n times to produce the output array. T is the step size and f₀ is the warping frequency at which the digital and analog filters agree. Every other application of the filter is performed in reverse.

Example

x = {1,1,1,0,0,0};	T = {1};	f₀ = {0.1};	a₀ = {1};	a₁ = {sqrt(2)};	a₂ = {1};	b₀ = {0};	b₁ = {0};	b₂ = {1};	n = {1}	⇒	{1,1,1,0.866207,0.500544,0.13459}
x = {1,1,1,0,0,0};	T = {1};	f₀ = {0.1};	a₀ = {1};	a₁ = {sqrt(2)};	a₂ = {1};	b₀ = {0};	b₁ = {0};	b₂ = {1};	n = {2}	⇒	{1.01777,0.896842,0.651823,0.366291,0.183552,0.13459}

Check Values - Equality

Plan to check the equality of values.

Description

This plan sets the output array at index k to the pass flag p[k] if all values up to and including the k-th value in the array x are equal to one another; otherwise, it sets the output array at index k to the fail flag f[k]. The last values in p and f are used when k is out of bounds. When p or f is not specified, the flagged values are removed instead.

Example

x = {1,1,1,2,3,2,1};	p = {0};	f = {1}	⇒	{0,0,0,1,1,1,1}
x = {1,1,0,-1,3,2};	p = {-1,-2,-3,-4,-5};	f = {1,2,3,4,5}	⇒	{-1,-2,3,4,5,5}

Check Values - Ascending Order

Plan to check the ascending order of values.

Description

This plan sets the output array at index k to the pass flag p[k] if all values up to and including the k-th value in the array x are in ascending order; otherwise, it sets the output array at index k to the fail flag f[k]. The last values in p and f are used when k is out of bounds. When p or f is not specified, the flagged values are removed instead.

Example

x = {1,1,1,2,3,2,1};	p = {0};	f = {1}	⇒	{0,0,0,0,0,1,1}
x = {1,1,0,-1,3,2};	p = {-1,-2,-3,-4,-5};	f = {1,2,3,4,5}	⇒	{-1,-2,3,4,5,5}

Check Values - Descending Order

Plan to check the descending order of values.

Description

This plan sets the output array at index k to the pass flag p[k] if all values up to and including the k-th value in the array x are in descending order; otherwise, it sets the output array at index k to the fail flag f[k]. The last values in p and f are used when k is out of bounds. When p or f is not specified, the flagged values are removed instead.

Example

x = {1,1,1,2,3,2,1};	p = {0};	f = {1}	⇒	{0,0,0,1,1,1,1}
x = {1,1,0,-1,3,2};	p = {-1,-2,-3,-4,-5};	f = {1,2,3,4,5}	⇒	{-1,-2,-3,-4,5,5}

This plan replaces, in a copy of array source, any values whose corresponding reference value has a magnitude less than or equal to a with 0. For each index k, the copy of source[k] is replaced with 0 if the magnitude of reference[k] is less than or equal to a[k]. The last value in a is used when k is out of bounds.

Example

source = {6,5,4,3,2};

reference = {0.1,0.2,1e-5,-0.4};

a = {1e-3}

⇒

{6,5,0,3,2}

Linear Expression Across Arrays

Plan to compute the linear combinations of values across arrays.

Description

This plan linearly combines values across multiple arrays, defined as

a[0]+a[1]×x₀[k]+a[2]×x₁[k]+...,

for each index k to produce the output array. The output array is as large as the largest x_i array. Out-of-range values in these arrays are replaced with their last available values.

Example

a = {1,-1,1,-1};	x₀ = {1,0,-1};	x₁ = {0,0,-1};	x₂ = {5,3,-7,-2}	⇒	{-5,-2,8,3}
a = {1,-1,1,-1};	x₀ = {1,0,-1};	x₁ = {2};	x₂ = {3}	⇒	{-1,0,1}

Simple Expression Across Arrays

Plan to compute values with an expression of values across arrays.

Description

This plan evaluates the expression f(i,x0,x1,...,x20) for each index i to produce the values of the output array. In this expression, i is the index, starting from 0. x0 is the value of the array x₀ at index i, x1 is the value of the array x₁ at the same position, and so on. This plan can process up to 21 arrays, using an expression of the values at the same position across the arrays. The output array is as large as the largest x_i array. Out-of-range values in these arrays are replaced with their last available values.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

f = {1+i+x0-2x1+x2(x3^2)};	x₀ = {1,-1,1,-1};	x₁ = {1,2,3};	x₂ = {-1,-2,-3};	x₃ = {0,2,0}	⇒	{0,-11,-2,-3}
f = {1+i+x0-2*x1+x2};	x₀ = {1,-1,1,-1};	x₁ = {3}	x₂ = {6}		⇒	{2,1,4,3}

Expressions Across Arrays

Plan to compute values with expressions of values across arrays.

Description

This plan evaluates the expressions in f = {f[0],f[1],...} to produce the values of the output array. Here, f[i] is a function of i, x, y, z, u, v, w, x0, xp1, xn1, yp1, yn1, and so on. The output array is computed as f[i] for each index i, or as the last available function in f if there is no corresponding f[i]. In these expressions, i is the index, starting from 0. x, y, z, u, v, and w are the values of the arrays x, y, z, u, v, and w, respectively, at the same index across the arrays. Fixed references are represented as x0=x[0], x1=x[1], and so on; relative references are represented as xp1=x[i-1], xn1=x[i+1], and so forth. The output array is as large as the largest x_i array. Out-of-range values are replaced with 0.

The expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^), and modulus (%).
Basic operations: abs, ceil, floor, trunc, and round.
Error and gamma functions: erf, erfc, and gamma.
Exponentiation functions: exp, pow, and sqrt.
Combinatorial functions: fac, ncr, and npr.
Logarithmic functions: exp, ln (natural logarithm), log (base-10 logarithm), and log10.
Trigonometric functions: sin, cos, tan, asin, acos, atan, and atan2.
Hyperbolic functions: sinh, cosh, tanh, asinh, acosh, and atanh.
Constants: pi and e.

Example

f = {i+x-y};	x = {1,2,3,4};	y = {1,-1,1}	⇒	{0,4,4,7}
f = {x2+y2,x1-x-y1};	x = {1,2,3,4};	y = {1,-1,1}	⇒	{4,1,0,-1}
f = {2x-xp1-xn1+yp1yn1};	x = {1,2,3,4};	y = {1,-1,1}	⇒	{0,1,0,5}

Cross Product

Plan to compute the cross product of two arrays.

Description

This plan computes the vector cross product of two given arrays, x and y, as follows: {x[1]×y[2]-x[2]×y[1],x[2]×y[0]-x[0]×y[2],x[0]×y[1]-x[1]×y[0]}.

Example

x = {1,0,-1};

y = {0,0,-1}

⇒

x₀ = {1,0,-inf};

x₁ = {0,0,-1};

x₂ = {5/0,0,-7,2}

⇒

{4.5,7.5,-4,-2}

Exponentially Weighted Mean Across Arrays

Plan to compute exponentially weighted means across arrays.

Description

This plan computes the exponentially weighted mean, or the final value of the exponential moving average, EMA[k,Nk-1], across multiple arrays to produce the output array. The exponential moving average is calculated as

EMA[k,i] = αx_i[k] + (1-α)EMA[k,i-1]

over the values at index k in the arrays x₀, x₁, etc. Here, α is the smoothing factor and Nk is the number of available values across the arrays at index k.

Example

α = {0.9};

x₀ = {1,0,-1};

x₁ = {0,0,-1};

x₂ = {5,3,-7,-2};

x₃ = {2,6,-1}

⇒

Example

k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1};	x₂ = {5,3,-7,-2};	x₃ = {2,6,-1}	⇒	{2,3,-1,-2}
k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1,2};	x₂ = {1,2,0};	x₃ = {0,2,-1}	⇒	{1,2,-1,2}

Array Index of Percentile Across Arrays

Plan to find the array indices of percentiles across arrays.

Description

This plan finds the array index of the first occurrence of the k-th percentile at each index across multiple arrays to produce the output array.

Example

k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1};	x₂ = {5,3,-7,-2};	x₃ = {2,6,-1}	⇒	{3,2,0,2}
k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1,2};	x₂ = {1,2,0};	x₃ = {0,2,-1}	⇒	{0,2,0,1}

{26,24,-36,0}

Sum of Powers Across Arrays

Plan to compute the sums of powers across arrays.

Description

This plan computes the sum of the powers across multiple arrays, defined as

Sum(x_i[k]^p),

over the values at index k in the arrays x₀, x₁, etc. to produce the output array.

Example

p = {2};

x₀ = {1,0,-1};

x₁ = {0,0,-1};

x₂ = {5,3,-7,-2};

x₃ = {2,6,-1}

⇒

x = {0.9,0,-1.1,0,1.1};

a = {-1,0,1}

⇒

{1,1,1}

Binning by Negative Crossing

Plan to count negative level crossings.

Description

This plan counts negative level crossings in the array x at levels given in the array a. The result at index i is the number of indices j where x[j]≥a[i] and x[j+1]<a[i].

Example

x = {0.9,0,-1.1,0,1.1};

a = {-1,0,1}

⇒

{0.5}

Exponentially Weighted Mean

Plan to compute the exponentially weighted mean.

Description

This plan computes the exponentially weighted mean, or the final value of the exponential moving average, EMA[N-1], defined as

EMA[k] = αx[k] + (1-α)EMA[k-1],

for the array x. Here, N is the length of the array, and α is the smoothing factor.

Example

x = {1,3,-2,7,0,4};

α = {0.9}

⇒

Percentile

Plan to find the percentile.

Description

This plan finds the k-th percentile, defined as the smallest value at or below which k percent (k=1.0 for 100%) of the values fall, in the array x.

Example

x = {1,0.5,-1,-2,-3};	k = {0.7}	⇒	{0.5}
x = {1,0,0,1,2,2,2,2};	k = {0.7}	⇒	{2}

Index of Percentile

Plan to find the index of percentile.

Description

This plan finds the index of the first occurrence of the k-th percentile in the array x.

Example

x = {1,0.5,-1,-2,-3};	k = {0.7}	⇒	{1}
x = {1,0,0,1,2,2,2,2};	k = {0.7}	⇒	{4}

{-14}

Sum of Powers

Plan to compute the sum of powers.

Description

This plan computes the sum of the powers of the values, defined as

Sum(x[i]^p),

for the array x.

Example

x = {1,0.5,-1,-2,-3};

p = {2}

⇒

This plan counts the number of arrays x_k that contain at least one finite value. The result is the count of arrays among x₀, x₁, etc. that have at least one finite value. Non-finite values are inf, -inf, and nan.

Example

x₀ = {1,0,-inf};

x₁ = {0,0,-1};

x₂ = {5/0,0,-7,2};

x₃ = {}

⇒

{3}

Count of Arrays with All Finite Values

Plan to count arrays containing only finite values.

Description

This plan counts the number of arrays x_k that contain only finite values. The result is the count of arrays among x₀, x₁, etc. that have only finite values. Non-finite values are inf, -inf, and nan.

Example

x₀ = {1,0,-inf};

x₁ = {0,0,-1};

x₂ = {5/0,0,-7,2};

x₃ = {}

⇒

{2}

Total Binning by Value - Histogram

Plan to count occurrences of values in histogram bins in multiple arrays.

Description

This plan counts the number of values in the arrays x_k that belong to the bins defined by the values in the array a. The result at index i is the number of values in x_k, for any k, that fall within the range [a[i]-δn[i], a[i]+δp[i]]. The last values in δn and δp are used when i is out of bounds.

Example

a = {-3,-2,-1,0,1,2,3};	δn = {0.5};	δp = {0.5};	x₀ = {1.2,-2.6};	x₁ = {3.3};	x₂ = {0.7,-2.1}	⇒	{1,1,0,0,2,0,1}
a = {-2,-1,0,1,2};	δn = {0.5};	δp = {0.5};	x₀ = {1.2,-2.6};	x₁ = {3.3};	x₂ = {0.7,-2.1}	⇒	{1,0,0,2,0}
a = {-2,-1,0,1,2};	δn = {10,0.5,0.5,0.5,0.5};	δp = {0.5,0.5,0.5,0.5,10};	x₀ = {1.2,-2.6};	x₁ = {3.3};	x₂ = {0.7,-2.1}	⇒	{2,0,0,2,1}

Total Binning by Positive Crossing

Plan to count positive level crossings in multiple arrays.

Description

This plan counts positive level crossings in the arrays x_k at levels given in the array a. The result at index i is the number of indices j where x_k[j]≤a[i] and x_k[j+1]>a[i] for any k.

Example

a = {-1,0,1};

x₀ = {0.9,0,-1.1,0,1.1};

x₁ = {-2,2}

⇒

{2,2,2}

Total Binning by Negative Crossing

Plan to count negative level crossings in multiple arrays.

Description

This plan counts negative level crossings in the arrays x_k at levels given in the array a. The result at index i is the number of indices j where x_k[j]≥a[i] and x_k[j+1]<a[i] for any k.

Example

a = {-1,0,1};

x₀ = {0.9,0,-1.1,0,1.1};

x₁ = {-2,2}

⇒

⇒

{1}

Total Exponentially Weighted Mean

Plan to compute the exponentially weighted mean in multiple arrays.

Description

This plan computes the exponentially weighted mean, or the final value of the exponential moving average, of the values in the flattened array formed by concatenating the arrays x₀, x₁, and so on. Here, α specifies the smoothing factor.

Example

α = {0.9};

x₀ = {1,0,-1};

x₁ = {0,0,-1};

x₂ = {5,3,-7,-2};

x₃ = {2,6,-1}

⇒

x₀ = {1,0};

x₁ = {1};

x₂ = {-2,-3}

⇒

Total Percentile

Plan to find the percentile in multiple arrays.

Description

This plan finds the k-th percentile of the values in the flattened array formed by concatenating the arrays x₀, x₁, and so on.

Example

k = {0.7};	x₀ = {1,0.5};	x₁ = {-1};	x₂ = {-2,-3}		⇒	{0.5}
k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1,2};	x₂ = {1,2,0};	x₃ = {0,2,-1}	⇒	{1}

Array Index of Total Percentile

Plan to find the array index of percentile in multiple arrays.

Description

This plan finds the array index of the first occurrence of the k-th percentile of the values in the flattened array formed by concatenating the arrays x₀, x₁, and so on.

Example

k = {0.7};	x₀ = {1,0.5};	x₁ = {-1};	x₂ = {-2,-3}		⇒	{0}
k = {0.7};	x₀ = {1,0,-1};	x₁ = {0,0,-1,2};	x₂ = {1,2,0};	x₃ = {0,2,-1}	⇒	{0}

{-14}

Total Sum of Powers

Plan to compute the sum of powers in multiple arrays.

Description

This plan computes the sum of the powers of the values in the flattened array formed by concatenating the arrays x₀, x₁, and so on.

Example

p = {2};

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

x = {3,4,5};

y = {-1,0,1}

⇒

This plan exports the arrays x₀, x₁, etc. to a text file with the given file name, writing each array in a separate row. The exported values are separated by the specified delimiter, which may include escape sequences. If the append parameter is not empty, the arrays are appended to the end of the file. When specified, the format of the floating-point numbers is controlled by the width and precision parameters.

Example

file name = {tests\rows.txt};

append = {};

delimiter = {; };

width = {};

precision = {};

x₀ = {1,2,3,pi};

x₁ = {2,3};

x₂ = {1,-2}

Export to Text File Along Columns

Plan to export arrays to a text file column by column.

Description

This plan exports the arrays x₀, x₁, etc. to a text file with the given file name, writing each array in a separate column. The exported values are separated by the specified delimiter, which may include escape sequences. If the append parameter is not empty, the arrays are appended to the end of the file. To ensure that the exported arrays are similar in length, zeros may be added at the end. When specified, the format of the floating-point numbers is controlled by the width and precision parameters.

Example

file name = {tests\columns.txt};

append = {1};

delimiter = {, };

width = {8};

precision = {3};

x₀ = {1,2,3,pi};

x₁ = {2,3};

This plan asynchronously executes a JavaScript function with the specified function name, as described in the file with the given file name. The input arrays x₀, x₁, etc. are passed to this function in order.

Example

function name = {main};	file name = {tests\test.js}
function name = {"main2"};	file name = {tests\test.js};	x₀ = {1,2,3,4};	x₁ = {2,3};	x₂ = {1,-2}