tablecloth.column.api.operators — scicloj/tablecloth 7.062

* clj

(* x y)

(* x y & args)

+ clj

(+ x)

(+ x y)

(+ x y & args)

- clj

(- x)

(- x y)

(- x y & args)

/ clj

(/ x)

(/ x y)

(/ x y & args)

< clj

(< x y)

(< x y z)

<= clj

(<= x y)

(<= x y z)

> clj

(> x y)

(> x y z)

>= clj

(>= x y)

(>= x y z)

abs clj

(abs x)

(abs x options)

acos clj

(acos x)

(acos x options)

and clj

(and x y)

asin clj

(asin x)

(asin x options)

atan clj

(atan x)

(atan x options)

atan2 clj

(atan2 x y)

(atan2 x y & args)

bit-and clj

(bit-and x y)

(bit-and x y & args)

bit-and-not clj

(bit-and-not x y)

(bit-and-not x y & args)

bit-clear clj

(bit-clear x y)

(bit-clear x y & args)

bit-flip clj

(bit-flip x y)

(bit-flip x y & args)

bit-not clj

(bit-not x)

(bit-not x options)

bit-or clj

(bit-or x y)

(bit-or x y & args)

bit-set clj

(bit-set x y)

(bit-set x y & args)

bit-shift-left clj

(bit-shift-left x y)

(bit-shift-left x y & args)

bit-shift-right clj

(bit-shift-right x y)

(bit-shift-right x y & args)

bit-xor clj

(bit-xor x y)

(bit-xor x y & args)

cbrt clj

(cbrt x)

(cbrt x options)

ceil clj

(ceil x)

(ceil x options)

cos clj

(cos x)

(cos x options)

cosh clj

(cosh x)

(cosh x options)

cummax clj

(cummax x)

(cummax x options)

Cumulative running max; returns result in double space.

Options:

• :nan-strategy - one of :keep, :remove, :exception. Defaults to :remove.

cummin clj

(cummin x)

(cummin x options)

Cumulative running min; returns result in double space.

Options:

• :nan-strategy - one of :keep, :remove, :exception. Defaults to :remove.

cumprod clj

(cumprod x)

(cumprod x options)

Cumulative running product; returns result in double space.

Options:

• :nan-strategy - one of :keep, :remove, :exception. Defaults to :remove.

cumsum clj

(cumsum x)

(cumsum x options)

Cumulative running summation; returns result in double space.

Options:

• :nan-strategy - one of :keep, :remove, :exception. Defaults to :remove.

descriptive-statistics clj

(descriptive-statistics x)

(descriptive-statistics x stats-names)

(descriptive-statistics x stats-names options)

(descriptive-statistics x stats-names stats-data options)

Calculate a set of descriptive statistics on a single reader.

Available stats: #{:min :quartile-1 :sum :mean :mode :median :quartile-3 :max :variance :standard-deviation :skew :n-elems :kurtosis}

options

• :nan-strategy - defaults to :remove, one of [:keep :remove :exception]. The fastest option is :keep but this may result in your results having NaN's in them. You can also pass in a double predicate to filter custom double values.

distance clj

(distance x y)

distance-squared clj

(distance-squared x y)

dot-product clj

(dot-product x y)

eq clj

(eq x y)

equals clj

(equals x y & args)

even? clj

(even? x)

(even? x options)

exp clj

(exp x)

(exp x options)

expm1 clj

(expm1 x)

(expm1 x options)

fill-range clj

(fill-range x max-span)

Given a reader of numeric data and a max span amount, produce a new reader where the difference between any two consecutive elements is less than or equal to the max span amount. Also return a bitmap of the added indexes. Uses linear interpolation to fill in areas, operates in double space. Returns {:result :missing}

finite? clj

(finite? x)

(finite? x options)

floor clj

(floor x)

(floor x options)

get-significand clj

(get-significand x)

(get-significand x options)

hypot clj

(hypot x y)

(hypot x y & args)

identity clj

(identity x)

(identity x options)

ieee-remainder clj

(ieee-remainder x y)

(ieee-remainder x y & args)

infinite? clj

(infinite? x)

(infinite? x options)

kendalls-correlation clj

(kendalls-correlation x y)

(kendalls-correlation x y options)

kurtosis clj

(kurtosis x)

(kurtosis x options)

log clj

(log x)

(log x options)

log10 clj

(log10 x)

(log10 x options)

log1p clj

(log1p x)

(log1p x options)

logistic clj

(logistic x)

(logistic x options)

magnitude clj

(magnitude x)

magnitude-squared clj

(magnitude-squared x)

mathematical-integer? clj

(mathematical-integer? x)

(mathematical-integer? x options)

max clj

(max x)

(max x y)

(max x y & args)

mean clj

(mean x)

(mean x options)

double mean of x

mean-fast clj

(mean-fast x)

Take the mean of the x. This operation doesn't know anything about nan hence it is a bit faster than the base mean fn.

median clj

(median x)

(median x options)

min clj

(min x)

(min x y)

(min x y & args)

nan? clj

(nan? x)

(nan? x options)

neg? clj

(neg? x)

(neg? x options)

next-down clj

(next-down x)

(next-down x options)

next-up clj

(next-up x)

(next-up x options)

normalize clj

(normalize x)

not clj

(not x)

(not x options)

not-eq clj

(not-eq x y)

odd? clj

(odd? x)

(odd? x options)

or clj

(or x y)

pearsons-correlation clj

(pearsons-correlation x y)

(pearsons-correlation x y options)

percentiles clj

(percentiles x percentages)

(percentiles x percentages options)

Create a reader of percentile values, one for each percentage passed in. Estimation types are in the set of #{:r1,r2...legacy} and are described here: https://commons.apache.org/proper/commons-math/javadocs/api-3.3/index.html.

nan-strategy can be one of [:keep :remove :exception] and defaults to :exception.

pos? clj

(pos? x)

(pos? x options)

pow clj

(pow x y)

(pow x y & args)

quartile-1 clj

(quartile-1 x)

(quartile-1 x options)

quartile-3 clj

(quartile-3 x)

(quartile-3 x options)

quartiles clj

(quartiles x)

(quartiles x options)

return [min, 25 50 75 max] of item

quot clj

(quot x y)

(quot x y & args)

reduce-* clj

(reduce-* x)

reduce-+ clj

(reduce-+ x)

reduce-max clj

(reduce-max x)

reduce-min clj

(reduce-min x)

rem clj

(rem x y)

(rem x y & args)

rint clj

(rint x)

(rint x options)

round clj

(round x)

(round x options)

Vectorized implementation of Math/round. Operates in double space but returns a long or long reader.

shift clj

(shift x n)

Shift by n and fill in with the first element for n>0 or last element for n<0.

Examples:

user> (dfn/shift (range 10) 2)
[0 0 0 1 2 3 4 5 6 7]
user> (dfn/shift (range 10) -2)
[2 3 4 5 6 7 8 9 9 9]

signum clj

(signum x)

(signum x options)

sin clj

(sin x)

(sin x options)

sinh clj

(sinh x)

(sinh x options)

skew clj

(skew x)

(skew x options)

spearmans-correlation clj

(spearmans-correlation x y)

(spearmans-correlation x y options)

sq clj

(sq x)

(sq x options)

sqrt clj

(sqrt x)

(sqrt x options)

standard-deviation clj

(standard-deviation x)

(standard-deviation x options)

sum clj

(sum x)

(sum x options)

Double sum of data using Kahan compensated summation.

sum-fast clj

(sum-fast x)

Find the sum of the data. This operation is neither nan-aware nor does it implement kahans compensation although via parallelization it implements pairwise summation compensation. For a more but slightly slower but far more correct sum operator, use sum.

tan clj

(tan x)

(tan x options)

tanh clj

(tanh x)

(tanh x options)

to-degrees clj

(to-degrees x)

(to-degrees x options)

to-radians clj

(to-radians x)

(to-radians x options)

ulp clj

(ulp x)

(ulp x options)

unsigned-bit-shift-right clj

(unsigned-bit-shift-right x y)

(unsigned-bit-shift-right x y & args)

variance clj

(variance x)

(variance x options)

zero? clj

(zero? x)

(zero? x options)