Plan Documentation

Array Plans (0.9.2)

Plans to Get an Array

Custom

Summery

Make a custom array

Description

Make an array value-by-value. The output array is computed as the result of the text expression x.

Expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^) and modulus (%)
Numerical operations: sign, abs, ceil, floor, trunc, round, erf, sinc
Exponentiation operations: exp, pow, sqrt, logistic, logit
Combinatorial operations: fac, ncr, npr
Logarithmic operations: exp, ln (natural logarithm), log (base-10 logarithm), log10
Trigonometric functions: sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, acot, asec, acsc
Hyperbolic functions: sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch
Conditional operations: clamp, clean, disc, replace, replaceri, replacerx
Constants: pi, e

Example

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

Fill

Summery

Fill an array with values

Description

Fill an array of size n with values in array a. If enough values are not available in a, the last value is repeated.

Example

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

Expression

Summery

Fill an array using an expression

Description

Make an array of size n using expression f(i) for each i.

Expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^) and modulus (%)
Numerical operations: sign, abs, ceil, floor, trunc, round, erf, sinc
Exponentiation operations: exp, pow, sqrt, logistic, logit
Combinatorial operations: fac, ncr, npr
Logarithmic operations: exp, ln (natural logarithm), log (base-10 logarithm), log10
Trigonometric functions: sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, acot, asec, acsc
Hyperbolic functions: sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch
Conditional operations: clamp, clean, disc, replace, replaceri, replacerx
Constants: pi, 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

Summery

Fill an array with a polynomial expansion

Description

Make an array of size n with polynomial expansion a[0]+a[1]×i+a[2]×i²+... for each i.

Example

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

Trigonometric Expansion

Summery

Fill an array with a trigonometric expansion

Description

Make an array of size n with trigonometric expansion a[0]+a[1]×sin(a[2]×i+a[3])+... for each i.

n = {3};

k = {1}

⇒

{0.438988, 1.37627, 15.1283}

Cauchy Randomized

Summery

Randomize an array with Cauchy distribution

Description

Make an array of size n with Cauchy distribution with parameters x₀ and γ.

Example

Example

n = {3};

λ = {1};

k = {1}

⇒

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}	⇒	{...}

x = {1,2,3};

m = {2};

n = {3}

⇒

{1,1,2,2,3,3,1,1,2,2,3,3,1,1,2,2,3,3}

Reverse

Summery

Reverse array

Description

Reverse the order of values in array x.

Example

x = {1,2,3}

⇒

{3,2,1}

Shift towards Start

Summery

Shift values toward start

Description

Shift and cycle each value in array x toward start by n spots.

Example

x = {1,2,3};

n = {1}

⇒

{2,3,1}

Shift towards End

Summery

Shift values toward end

Description

Shift and cycle each value in array x toward end by n spots.

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}

Copy the First Value

Summery

Copy first value of array

Description

Copy the first value in array x.

Example

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

⇒

{1}

Copy the Last Value

Summery

Copy last value of array

Description

Copy the last value in array x.

Example

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

⇒

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

⇒

{1,2}

Optimizer - Iteration Counter

Summery

Produce the iteration counter of an optimizer plan

Description

Partition optimizer array x to generate the number of iterations since the beginning of optimization.
An optimizer array is organized as {next | counter | ... | size | is_done}. Next is the input for next iteration or the optimized input if optimization is concluded, counter is the number of iterations since the beginning of optimization, size is the input size, and is_done is the termination flag.

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

from = {1,3.2};

to = {1,10}

⇒

{2,3}

Keep Ranges of Values

Summery

Keep ranges of values

Description

Keep only values in ranges [from[k], to[k]] for each k.

Example

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

from = {1,3.2};

to = {1,10}

⇒

Keep Extremes (by Value)

Summery

Keep peaks and valleys

Description

Keep only peaks (values greater than neighboring values) and valleys (values less than 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 (by Value)

Summery

Hysteresis filter by value

Description

Remove values where deviation from neighboring values is less then a.

Example

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

a = {0.5}

⇒

{1,2,3}

Remove Small Variations (by Ratio)

Summery

Hysteresis filter by ratio

Description

Remove values where deviation from neighboring values is less then a times their value.

Example

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

a = {0.1}

⇒

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 From Moving Average (by σ-Ratio)

Summery

Remove spikes by distance from baseline relative to standard deviation

Description

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}

Plans to Reorganize Across Arrays

Nth Array

Summery

Copy an array

Description

Copy values of the nth array.

Example

x₀ = {1,2,3};

x₁ = {4,5};

n = {1}

⇒

{4,5}

First Non-Empty Array

Summery

Copy the first non-empty array

Description

Copy values of the first non-empty array between x₀,x₁,... . This plan does not cascade refresh requests to its parameters x₀,x₁,... .

Example

x₀ = {};

x₁ = {};

x₂ = {7,6,8};

x₃ = {1,2}

⇒

{7,6,8}

Values From Arrays

Summery

Copy from arrays

Description

Copy the k-th value of the n[k]th array for each k. If n[k] is not available, the last value in n is considered. If the k-th value is not available in the n[k]th array, a[k], or the last value in a when not available, is considered.

Example

x₀ = {1,2,3};	x₁ = {4,5};	n = {1};	a = {-1}	⇒	{4,5,-1}
x₀ = {1,2,3};	x₁ = {4,5};	n = {1,0,0};	a = {0}	⇒	{4,2,3}
x₀ = {1,2,3};	x₁ = {4,5};	n = {1,0,1};	a = {-1.-2}	⇒	{4,2,-2}

⇒

{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}

Shuffle and Repeat

Summery

Shuffle arrays and replicate

Description

Combine arrays by shuffling m repeats of each array and replicating the result n times as ((x₀[0],x₁[0],...)×m,(x₀[1],x₁[1],...)×m,...)×n.

Example

Example

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

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

from = {1,3.2};

to = {1,10}

⇒

{5,4}

Keep Ranges of Values (Based on Another Array)

Summery

Conditionally keep ranges of values

Description

Keep source values only when their corresponding reference values are in ranges [from[k], to[k]] for each k.

Example

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

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

from = {1,3.2};

to = {1,10}

⇒

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

minimum = {-1};

maximum = {1}

⇒

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

Scale Uniformly

Summery

Uniformly change as polynomial

Description

Uniformly (but not necessarily linearly) scale values so that a[k] is moved to b[k] for each k. This scaling interpolates x[k] values on a Lagrange polynomial from values in array a to the corresponding values in 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}

General Expression

Summery

Compute general-form expression

Description

Compute general-form expression f = {f[0],f[1],...} where f[i] is a function of i,x,x0,x1,xp1,xn1,... . The output array is computed as f[i] for each i < n or the last function in f when no corresponding f[i] is available. i is the index starting from 0 and x is the value of array x at that index. Fixed references are represented by x0=x[0], x1=x[1], and so on, and relative references by xp1=x[i-1], xn1=x[i+1], and so on. Out-of-range values are replaced with 0. If n is not provided, it is replaced with the count of values in x.

Expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^) and modulus (%)
Numerical operations: sign, abs, ceil, floor, trunc, round, erf, sinc
Exponentiation operations: exp, pow, sqrt, logistic, logit
Combinatorial operations: fac, ncr, npr
Logarithmic operations: exp, ln (natural logarithm), log (base-10 logarithm), log10
Trigonometric functions: sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, acot, asec, acsc
Hyperbolic functions: sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch
Conditional operations: clamp, clean, disc, replace, replaceri, replacerx
Constants: pi, 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}

Normalize (P-Norm)

Summery

Normalize to unit p-norm

Description

Normalize x to unit p-norm by dividing each x[k] by p-norm of x (p≥1).

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 onto Hyperplane

Summery

Project onto hyperplane

Description

Project x onto the hyperplane constructed with a as a[0]×x[0]+a[1]×x[1]+...+a[n-1]×x[n-1]=a[n]. Coefficients are replaced with 0 if there are not enough values available in a.

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 onto Line

Summery

Project onto line

Description

Project x onto the line constructed with 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}

x = {0,0.1,-1}

⇒

{0.5,0.524979,0.268941}

Logit

Summery

Compute logit function

Description

Compute the inverse logistic function of x[k] as log(x[k]/(1-x[k])) for each k.

Example

x = {0,0.1,-1}

Description

Compute changes in values as x[k]-x[k-1] for each k > 0, and 0 for k = 0.

Example

x = {1,2,4,10,10,4}

⇒

{0,1,2,6,0,-6}

Difference Ratio

Summery

Compute relative changes in values

Description

Compute relative changes in values as (x[k]-x[k-1])/x[k-1] for each k > 0, and 1 for k = 0.

Example

x = {1,2,4,10,10,4}

⇒

{1,1,1,1.5,0,-0.6}

Polynomial Expression

Summery

Compute polynomial expression

Description

Compute the polynomial expression defined as a[0]+a[1]×x[k]+a[2]×x[k]²+... for each k.

Example

x = {1,2,3,4};	a = {2,1}	⇒	{3,4,5,6}
x = {1,2,3,4};	a = {0,1,1}	⇒	{2,6,12,20}

Trigonometric Expression

Summery

Compute trigonometric expression

Description

Compute the trigonometric expression defined as a[0]+a[1]×sin(a[2]×x[k]+a[3])+a[4]×sin(a[5]×x[k]+a[6])+... for each k.

Example

x = {0,pi/2,pi,2*pi};	a = {2,1,1}	⇒	{2,3,2,2}
x = {0,pi/2,pi,2*pi};	a = {0,1,1,pi/2}	⇒	{1,ε,-1,1}

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

a = {2,1,-1}

⇒

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

Exponential-Weighted Mean

Summery

Compute exponential mean

Description

Compute exponential mean or exponential moving average, EMA, defined as EMA[k] = αx[k] + (1-α)EMA[k-1], for each k. α is the smoothing factor.

Example

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

α = {0.9}

⇒

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}

Smooth Large Deviations From Moving Average (by σ-Ratio)

Summery

Smooth spikes by distance from baseline relative to standard deviation

Description

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

Summery

Apply low-pass Butterworth filter

Description

Apply digital second-order low-pass Butterworth filter n times with timestep T and cutoff frequency fc. Every other repeat is applied backwards. Filter warping is applied following SAE J211. Set n=2 to generate 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

Summery

Apply high-pass Butterworth filter

Description

Apply digital second-order high-pass Butterworth filter n times with timestep T and cutoff frequency fc. Every other repeat is applied backwards. Filter warping is applied following 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

Summery

Apply general first-order filter

Description

Apply digital first-order filter, H(s)=(b0s+b1)/(a0s+a1), n times. T is the step size and f0 is the warping frequency where digital and analog filters agree. Every other repeat is applied backwards.

Example

x = {1,1,1,0,0,0};	T = {1};	f0 = {0.1};	a0 = {1};	a1 = {1};	b0 = {0};	b1 = {1};	n = {1}	⇒	{1,1,1,0.659141,0.209793,0.0667734}
x = {1,1,1,0,0,0};	T = {1};	f0 = {0.1};	a0 = {1};	a1 = {1};	b0 = {0};	b1 = {1};	n = {2}	⇒	{0.966722,0.895446,0.671506,0.332953,0.115523,0.0667734}

Second-Order Filter

Summery

Apply general second-order filter

Description

Apply digital second-order filter, H(s)=(b0s²+b1s+b2)/(a0s²+a1s+a2), n times. T is the step size and f0 is the warping frequency where digital and analog filters agree. Every other repeat is applied backwards.

Example

x = {1,1,1,0,0,0};	T = {1};	f0 = {0.1};	a0 = {1};	a1 = {sqrt(2)};	a2 = {1};	b0 = {0};	b1 = {0};	b2 = {1};	n = {1}	⇒	{1,1,1,0.866207,0.500544,0.13459}
x = {1,1,1,0,0,0};	T = {1};	f0 = {0.1};	a0 = {1};	a1 = {sqrt(2)};	a2 = {1};	b0 = {0};	b1 = {0};	b2 = {1};	n = {2}	⇒	{1.01777,0.896842,0.651823,0.366291,0.183552,0.13459}

Check Equality

Summery

Check equality of values

Description

Generate pass flag, p[k], when values up to the k-th value in x are equal to one another, and fail flag, f[k], otherwise. When a corresponding flag is not available, the last pass or fail flags are considered.

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 Ascending Order

Summery

Check ascending order of values

Description

Generate pass flag, p[k], when values up to the k-th value in x are in ascending order, and fail flag, f[k], otherwise. When a corresponding flag is not available, the last pass or fail flags are considered.

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 Descending Order

Summery

Check descending order of values

Description

Generate pass flag, p[k], when values up to the k-th value in x are in descending order, and fail flag, f[k], otherwise. When a corresponding flag is not available, the last pass or fail flags are considered.

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}

SA Optimizer

Summery

Optimize using Simulated Annealing (SA) algorithm

Description

Minimize x[0] using Simulated Annealing algorithm with exponential cooling schedule. x depends on an input with size n. The input array for next iteration is extracted using an Optimizer - Iteration Input plan.
In plan parameters, maxIters is the maximum number of allowed iterations, initT is the Initial temperature, initMoves is the number of initial iterations without changing temperature, moveCtrlSweep is the sweeps per feedback move control, tol is the tolerance to consider system frozen, maxTolSweep is the maximum sweeps below tolerance to consider system frozen, maxMoveCoef is the maximum move size, initMoveCoef is the initial move size, gain is the proportional control in feedback move control, and λ is the exponential cooling speed.

Example

Example

x = {1};

n = {4}

⇒

...

{-5,-2,8,3}

Simple Expression

Summery

Compute simple expression at the same index

Description

Compute simple expression f(i,x₀,x₁,...,x₂₀) for each i. The output array is as large as the largest x_i and the out-of-range values are replaced with 0.

Expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^) and modulus (%)
Numerical operations: sign, abs, ceil, floor, trunc, round, erf, sinc
Exponentiation operations: exp, pow, sqrt, logistic, logit
Combinatorial operations: fac, ncr, npr
Logarithmic operations: exp, ln (natural logarithm), log (base-10 logarithm), log10
Trigonometric functions: sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, acot, asec, acsc
Hyperbolic functions: sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch
Conditional operations: clamp, clean, disc, replace, replaceri, replacerx
Constants: pi, e

Example

f = {1+i+x0-2*x1+x2*(x3^2)};

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

x₁ = {1,2,3};

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

x₃ = {0,2,0};

⇒

{0,-11,-2,3}

Advanced Expression

Summery

Compute general-form expression at the same index

Description

Compute general-form expression f = {f[0],f[1],...} where f[i] is a function of i,x,y,z,u,v,w,x0,xp1,xn1,yp1,yn1,... . The output array is computed as f[i] for each i or the last function in f when no corresponding f[i] is available. i is the index starting from 0 and x,y,z,u,v,w are the values of arrays x,y,z,u,v,w at the same index across arrays. Fixed references are represented by x0=x[0], x1=x[1], and so on, and relative references by xp1=x[i-1], xn1=x[i+1], and so on. The output array is as large as the largest x_i and the out-of-range values are replaced with 0.

Expression parser supports the following:

Arithmetic operations: addition (+), subtraction/negation (-), multiplication (*), division (/), exponentiation (^) and modulus (%)
Numerical operations: sign, abs, ceil, floor, trunc, round, erf, sinc
Exponentiation operations: exp, pow, sqrt, logistic, logit
Combinatorial operations: fac, ncr, npr
Logarithmic operations: exp, ln (natural logarithm), log (base-10 logarithm), log10
Trigonometric functions: sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, acot, asec, acsc
Hyperbolic functions: sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch
Conditional operations: clamp, clean, disc, replace, replaceri, replacerx
Constants: pi, 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

Summery

Compute cross product of two arrays

Description

Compute vector cross product of arrays x and y as {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,-1.4,3};

x0 = {1,2,-1,-2};

y0 = {1,2,0,-3}

⇒

{1,0,nan}

Interpolate Linearly

Summery

Interpolate linearly between nearest neighbors

Description

Interpolate values in x linearly between their nearest neighbors. Each x[k] is mapped onto a line between two nearest x0 values as x-coordinates and their corresponding y0 values as y-coordinates. Out-of-range values are mapped to nan.

Example

x = {1,-1.4,3};

x0 = {1,2,-1,-2};

y0 = {1,2,0,-3}

⇒

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

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

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

⇒

{2,3,2,1}

Count of Non-Finites Across

Summery

Count non-finite values at the same index

Description

Count the number of non-finite values across arrays. The result at index i is the number of i-th values in arrays x_k that are not finite. Non-finite values are +/-inf and nan.

Example

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

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

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

⇒

{1,0,1,0}

Correlation Coefficient

Summery

Compute correlation coefficient

Description

Compute Pearson product-moment correlation coefficient between arrays x and y, defined as Sum((x[i]-μx)(y[i]-μy))/√{Sum((x[i]-μx)²)Sum((y[i]-μy)²)}, between start and k-th values (inclusive), or in a window of size w preceding the k-th values (inclusive) when w is specified, for each k. μx and μy are the averages of these values in x and y. When the sizes of x and y are different, the extra values are ignored.

Example

x = {1,2,-1,-2};	y = {1,2,0,-3};	w = {}	⇒	{0,1,0.981981,0.92967}
x = {1,2,-1,-2};	y = {1,2,0,-3};	w = {3}	⇒	{0,1,0.981981,0.922613}

a = {2,1,-1};

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

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

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

x₃ = {2,6,-1}

⇒

{4.5,7.5,-4,-2}

Exponential-Weighted Mean Across

Summery

Compute exponential mean at the same index

Description

Compute exponential mean or the last value in the exponential moving average across arrays, EMA[k,Nk-1], defined as EMA[k,i] = αx_i[k] + (1-α)EMA[k,i-1], for each k. α is the smoothing factor and Nk is the number of available values at the same index, k, across arrays.

Example

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}

Array Index of Percentile Across

Summery

Find array index of k-th percentile at the same index

Description

Find array index of k-th percentile across arrays defined as array index of a value equal to the lowest value at or below which k percentage (k=1.0 for 100%) of available values at each index fall.

Example

k = {0.7};

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

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

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

x₃ = {2,6,-1}

⇒

{3,2,1,2}

Sum Across

Summery

Compute sum at the same index

Description

Compute sum of available values at each index across arrays.

Example

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

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

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

x₃ = {2,6,-1}

⇒

{8,9,-10,-2}

Sum of Powers Across

Summery

Compute sum of powers at the same index

Description

Compute sum of powers of available values at each index across arrays defined as Sum(x_i[k]^p).

Example

p = {2};

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

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

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

x₃ = {2,6,-1}

⇒

{30,45,52,4}

Product Across

Summery

Compute product at the same index

Description

Compute product (multiplication) of available values at each index across arrays.

Example

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

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

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

x₃ = {2,6,-1}

⇒

{0,0,7,-2}

Integral Across

Summery

Compute integral (trapezoidal rule) at the same index

Description

Compute integral with trapezoidal rule across arrays defined as {Sum(x_i[k])-0.5x₀[k]-0.5x_Nk-1[k]}×dx for each k. Nk is the number of available values at the same index, k, across arrays.

Example

dx = {4};

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

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

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

x₃ = {2,6,-1}

⇒

{26,24,-36,0}

Norm Across

Summery

Compute p-norm at the same index

Description

Compute p-norm of available values at each index across arrays.

Example

p = {2};	x₀ = {1,0,-1};	x₁ = {0,0,-1};	x₂ = {5,3,-7,-2};	x₃ = {2,6,-1}	⇒	{5.47723,6.7082,7.2111,2}
p = {1};	x₀ = {1,0,-1};	x₁ = {0,0,-1};	x₂ = {5,3,-7,-2};	x₃ = {2,6,-1}	⇒	{8,9,10,2}

stepSize = {0.01};	maxIters = {100000};	tol = {1e-5};
xy₀ = {1,1};	xy₁ = {2};	xy₂ = {0,0};	xy₃ = {0};	xy₄ = {1,-1};	xy₅ = {0};	⇒	{1,1,0}

Note: Depending on the randomized initial value, the outcome may be slightly different.

x = {1,0,-1,0,1/0,2}

⇒

{5}

Count of Non-Finites

Summery

Count non-finite values in array

Description

Count the number of non-finite values. The result is the number of non-finite values in x. Non-finite values are +/-inf and nan.

Example

x = {1,0,-1,0,1/0,2}

⇒

{1}

Binning by Occurrence (Histogram)

Summery

Count occurrences in bins to prepare a histogram

Description

Count the number of values that belong to bins listed in a. The result at index i is the number of values that fall in range [a[i]-δn[i],a[i]+δp[i]]. When unavailable, the last values in δn and δp are considered.

Example

x = {1.2,-2.6,3.3,0.7,-2.1};	a = {-3,-2,-1,0,1,2,3};	δn = {0.5};	δp = {0.5}	⇒	{1,1,0,0,2,0,1}
x = {1.2,-2.6,3.3,0.7,-2.1};	a = {-2,-1,0,1,2};	δn = {0.5};	δp = {0.5}	⇒	{1,0,0,2,0}
x = {1.2,-2.6,3.3,0.7,-2.1};	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}	⇒	{2,0,0,2,1}

Binning by Positive Crossing

Summery

Count positive level crossings

Description

Count positive level crossings with levels listed in a. The result at index i is the number of indices k where x[k]≤a[i] and x[k+1]>a[i].

Example

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

a = {-1,0,1}

⇒

{1,1,1}

Binning by Negative Crossing

Summery

Count negative level crossings

Description

Count negative level crossings with levels listed in a. The result at index i is the number of indices k where x[k]≥a[i] and x[k+1]<a[i].

Example

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

a = {2,1,-1}

⇒

{0.5}

Exponential-Weighted Mean

Summery

Compute exponential mean in array

Description

Compute exponential mean or the last value in the exponential moving average, EMA[N-1], defined as EMA[k] = αx[k] + (1-α)EMA[k-1], for array x. N is the size of the array and α is the smoothing factor.

Example

Example

x = {1,-1,1,-2,-3};	p = {2}	⇒	{3.2}
x = {1,-1,1,-2,-3};	p = {-1}	⇒	{0.0333333}

Central Moment

Summery

Compute central moment in array

Description

Compute central moment, defined as Sum((x[i]-μ)^p)/N, for array x. μ is the average and N is the size of the array.

Example

x = {1,-1,1,-2,-3};	p = {2}	⇒	{2.56}
x = {1,-1,1,-2,-3};	p = {-1}	⇒	{-1.03535}

Standardized Moment

Summery

Compute standardized moment in array

Description

Compute standardized moment, defined as Sum((x[i]-μ)^p)/(σ^pN), for array x. μ is the average, σ is the population standard deviation, and N is the size of the array.

Example

x = {1,-1,1,-2,-3};	p = {2}	⇒	{1}
x = {1,-1,1,-2,-3};	p = {-1}	⇒	{-1.65657}

{0.5}

Index of Percentile

Summery

Find index of k-th percentile in array

Description

Find index of k-th percentile defined as index of a value equal to the lowest value at or below which k percentage (k=1.0 for 100%) of values in array x fall.

Example

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

k = {0.7}

⇒

{1}

Sum

Summery

Compute sum in array

Description

Compute sum of values for array x.

Example

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

⇒

{-4.5}

Sum of Powers

Summery

Compute sum of powers in array

Description

Compute sum of powers of values, defined as Sum(x[i]^p), for array x.

Example

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

p = {2}

⇒

{15.25}

Product

Summery

Compute product in array

Description

Compute product (multiplication) of values for array x.

Example

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

⇒

{-3}

Integral

Summery

Compute integral (trapezoidal rule) in array

Description

Compute integral with trapezoidal rule, defined as {Sum(x[i])-0.5x[0]-0.5x[N-1]}×dx, for array x. N is the size of the array.

Example

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

dx = {4}

⇒

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

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

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

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

⇒

{8}

Total Count of Non-Finites

Summery

Count non-finite values in arrays

Description

Count the number of non-finite values in arrays. The result is the number of values in arrays x_k that are not finite. Non-finite values are +/-inf and nan.

Example

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

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

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

⇒

{2}

Total Binning by Occurrence (Histogram)

Summery

Count occurrences in bins to prepare a histogram for arrays

Description

Count the number of values in arrays x₀,x₁,... that belong to bins listed in a. The result at index i is the number of values that fall in range [a[i]-δn[i],a[i]+δp[i]]. When unavailable, the last values in δn and δp are considered.

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}

⇒

{1}

Total Exponential-Weighted Mean

Summery

Compute exponential mean of values in arrays

Summery

Compute moment of values in arrays

Description

Compute moment the flat array of arrays {x₀,x₁,...}.

Example

p = {2};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{3.2}
p = {-1};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{0.0333333}

Total Central Moment

Summery

Compute central moment of values in arrays

Description

Compute central moment of the flat array of arrays {x₀,x₁,...}.

Example

p = {2};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{2.56}
p = {-1};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{-1.03535}

Total Standardized Moment

Summery

Compute standardized moment of values in arrays

Description

Compute standardized moment of the flat array of arrays {x₀,x₁,...}.

Example

p = {2};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{1}
p = {-1};	x₀ = {1,-1};	x₁ = {1};	x₂ = {-2,-3}	⇒	{-1.65657}

{0.5}

Array Index Total Percentile

Summery

Find array index of k-th percentile of values in arrays

Description

Find array index of k-th percentile in the flat array of arrays {x₀,x₁,...}.

Example

k = {0.7};

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

{0}

Total Sum

Summery

Compute sum of values in arrays

Description

Compute sum of the flat array of arrays {x₀,x₁,...}.

Example

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

{-4.5}

Total Sum of Powers

Summery

Compute sum of powers of values in arrays

Description

Compute sum of powers of the flat array of arrays {x₀,x₁,...}.

Example

p = {2};

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

{15.25}

Total Product

Summery

Compute product of values in arrays

Description

Compute product of the flat array of arrays {x₀,x₁,...}.

Example

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

{-3}

Total Integral

Summery

Compute integral (trapezoidal rule) of values in arrays

Description

Compute integral with trapezoidal rule of the flat array of arrays {x₀,x₁,...}.

Example

dx = {4};

x₀ = {1,0.5};

x₁ = {-1};

x₂ = {-2,-3}

⇒

x = {3,4,5};

y = {-1,0,1}

⇒

{0.2}

Script in Text

Summery

Execute JavaScript function of arrays from text script

Description

Run JavaScript function under function name from a script text. Input arrays x₀,x₁,... are passed to function name in order.

Example

function name = {main};	script = {function main(){ return [3, test()]; } function test(){ return 7; }}				⇒	{3,7}
function name = {"main2"};	script = {function main2(a,b,c){ let d = b[1]*c[1]; return [1, a.length, d]; }};	x₀ = {1,2,3,4};	x₁ = {2,3};	x₂ = {1,-2}	⇒	{1,4,-6}

Script in File

Summery

Execute JavaScript function of arrays from file script

Description

Run JavaScript function under function name from a file with file name. Input arrays x₀,x₁,... are passed to function name in order.

Example

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

Plans to Post an Array

Export to Text File Along Rows

Summery

Export arrays to text file along rows

Description

Export arrays x₀,x₁,... to a text file at file name along rows with values separated by delimiter. If append is nonempty, the array values are appended to the end of the file. Floating-point format is set by 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

Summery

Export arrays to text file along columns

Description

Export arrays x₀,x₁,... to a text file at file name along columns with columns separated by delimiter. If append is nonempty, the array values are appended to the end of the file. To make arrays similar in size, extra zeros are added to the end of arrays when needed. Floating-point format is set by 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};

x₂ = {1,-2}

Export To Binary File

Summery

Export an array to binary file

Description

Export array x to a binary file at file name. If append is nonempty, the array values are appended to the end of the file.

Example

file name = {tests\arrays.bin};

append = {};

x = {1,2,3,pi}

Pass to Script in Text

Summery

Pass arrays to JavaScript function from text script

Description

Run JavaScript function under function name from a script text asynchronously. Input arrays x₀,x₁,... are passed to function name in order.

Example

function name = {main};	script = {function main(){ return [3, test()]; } function test(){ return 7; }}
function name = {"main2"};	script = {function main2(a,b,c){ let d = b[1]*c[1]; return [1, a.length, d]; }};	x₀ = {1,2,3,4};	x₁ = {2,3};	x₂ = {1,-2}

Pass to Script in File

Summery

Pass arrays to JavaScript function from file script

Description

Run JavaScript function under function name from a file at file name asynchronously. Input arrays x₀,x₁,... are passed to function name 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}