tablecloth.column.api — scicloj/tablecloth 7.029.2

Tablecloth Column API

* 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)

column clj

(column)

(column data)

(column data options)

Create a column from a vector or sequence.

column-map clj

(column-map col map-fn)

(column-map col map-fn options)

Applies a map function map-fn to one or more columns. If col is a vector of columns, map-fn must have an arity equal to the number of columns. The datatype of the resulting column will be inferred, unless specified in the options map. Missing values can be handled by providing a :missing-fn in the options map.

options:

• :datatype - The desired datatype of the resulting column. The datatype is inferred if not provided
• :missing-fn - A function that takes a sequence of columns, and returns a set of missing index positions.

column? clj

(column? item)

Return true or false item is a column.

cos clj

(cos x)

(cos x options)

cosh clj

(cosh x)

(cosh x options)

count-missing clj

(count-missing col)

Returns the number of missing values in column col.

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)

drop-missing clj

(drop-missing col)

Remove missing values from column col.

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)

is-missing? clj

(is-missing? col idx)

Return true if this index is missing.

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)

missing clj

(missing col)

Indexes of missing values. Both iterable and reader.

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)

ones clj

(ones n-ones)

Creates a new column filled with n-ones

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)

replace-missing clj

(replace-missing col)

(replace-missing col strategy)

(replace-missing col strategy value)

Replace missing values in column col with give strategy.

Strategies may be:

• :down - Take the previous value, or use provided value.
• :up - Take the next value, or use provided value.
• :downup - Take the previous value, otherwise take the next value.
• :updown - Take the next value, otherwise take the previous value.
• :nearest - Use the nearest of next or previous values. (Strategy :mid is an alias for :nearest).
• :midpoint - Use the midpoint of averaged values between previous and next (non-missing) values.
• :abb - Impute missing value with approximate Bayesian bootstrap. See r's ABB.
• :lerp - Linearly interpolate values between previous and next nonmissing rows.
• :value - Provide a value explicitly. Value may be a function in which case it will be called on the column with missing values elided and the return will be used to as the filler.

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.

select clj

(select col selection)

Return a new column with the subset of indexes based on the provided selection. selection can be a list of indexes to select or boolean values where the index position of each true element indicates a index to select. When supplying a list of indices, duplicates are possible and will select the specified position more than once.

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)

slice clj

(slice col from)

(slice col from to)

(slice col from to step)

Returns a subset of the column defined by the inclusive from and to indexes. If to is not provided, slices to the end of the column. If from is not provided (i.e. is nil), slices from the beginning of the column. If either from or to is a negative number, it is treated as an index from the end of the column. The :start and :end keywords can be used to represent the start and end of the column, respectively.

Examples: (def column [1 2 3 4 5]) (slice column 1 3) ;=> [2 3] (slice column 2) ;=> [3 4 5] (slice column -3 -1) ;=> [3 4 5] (slice column :start 2) ;=> [1 2 3 4 5] (slice column 2 :end) ;=> [3 4 5] (slice column -2 :end) ;=> [4 5]

sort-column clj

(sort-column col)

(sort-column col order-or-comparator)

Returns a sorted version of the column col. You can supply the ordering keywords :asc or :desc or a comparator function to order-or-comparator. If no comparator function is provided, the column will be sorted in ascending order.

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)

typeof clj

(typeof col)

Returns the concrete type of the elements within the column col.

typeof? clj

(typeof? col datatype)

True|false the column's elements are of the provided type datatype. Can check both concrete types (e.g. :int32) or general types (:numerical, :textual, etc).

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)

zeros clj

(zeros n-zeros)

Create a new column filled wth n-zeros.