tablecloth.api.api-template — scicloj/tablecloth 7.000-beta-51

Tablecloth API

->array clj

(->array ds colname)

(->array ds colname datatype)

Convert numerical column(s) to java array

add-column clj

(add-column ds column-name column)

(add-column ds column-name column size-strategy)

Add or update (modify) column under column-name.

column can be sequence of values or generator function (which gets ds as input).

• ds - a dataset
• column-name - if it's existing column name, column will be replaced
• column - can be column (from other dataset), sequence, single value or function (taking a dataset). Too big columns are always trimmed. Too small are cycled or extended with missing values (according to size-strategy argument)
• size-strategy (optional) - when new column is shorter than dataset row count, following strategies are applied:
  • :cycle - repeat data
  • :na - append missing values
  • :strict - (default) throws an exception when sizes mismatch

add-columns clj

(add-columns ds columns-map)

(add-columns ds columns-map size-strategy)

Add or updade (modify) columns defined in columns-map (mapping: name -> column)

add-or-replace-column clj

(add-or-replace-column ds column-name column)

(add-or-replace-column ds column-name column size-strategy)

add-or-replace-columns clj

(add-or-replace-columns ds columns-map)

(add-or-replace-columns ds columns-map size-strategy)

aggregate clj

(aggregate ds aggregator)

(aggregate ds
           aggregator
           {:keys [default-column-name-prefix ungroup? parallel?]
            :or {default-column-name-prefix "summary" ungroup? true}
            :as options})

Aggregate dataset by providing:

• aggregation function
• map with column names and functions
• sequence of aggregation functions

Aggregation functions can return:

• single value
• seq of values
• map of values with column names

aggregate-columns clj

(aggregate-columns ds columns-aggregators)

(aggregate-columns ds columns-selector column-aggregators)

(aggregate-columns ds columns-selector column-aggregators options)

Aggregates each column separately

anti-join clj

(anti-join ds-left ds-right columns-selector)

(anti-join ds-left ds-right columns-selector options)

append clj

(append ds & datasets)

Concats columns of several datasets

array-column->columns clj

(array-column->columns ds src-column)

(array-column->columns ds src-column opts)

Converts a column of type java array into several columns, one for each element of the array of all rows. The source column is dropped afterwards. The function assumes that arrays in all rows have same type and length and are numeric.

ds Datset to operate on. src-column The (array) column to convert opts can contain: prefix newly created column will get prefix before column number

as-regular-dataset clj

(as-regular-dataset ds)

Remove grouping tag

asof-join clj

(asof-join ds-left ds-right columns-selector)

(asof-join ds-left ds-right columns-selector options)

bind clj

(bind ds & datasets)

by-rank clj

(by-rank ds columns-selector rank-predicate)

(by-rank ds
         columns-selector
         rank-predicate
         {:keys [desc? ties] :or {desc? true ties :dense} :as options})

Select rows using rank on a column, ties are resolved using :dense method.

See R docs. Rank uses 0 based indexing.

Possible :ties strategies: :average, :first, :last, :random, :min, :max, :dense. :dense is the same as in data.table::frank from R

:desc? set to true (default) order descending before calculating rank

clone clj

(clone item)

Clone an object. Can clone anything convertible to a reader.

column clj

(column dataset colname)

column-count clj

(column-count dataset)

column-names clj

(column-names ds)

(column-names ds columns-selector)

(column-names ds columns-selector meta-field)

Returns column names, given a selector. Columns-selector can be one of the following:

• :all keyword - selects all columns
• column name - for single column
• sequence of column names - for collection of columns
• regex - to apply pattern on column names or datatype
• filter predicate - to filter column names or datatype
• type namespaced keyword for specific datatype or group of datatypes

Column name can be anything.

column-names function returns names according to columns-selector and optional meta-field. meta-field is one of the following:

• :name (default) - to operate on column names
• :datatype - to operated on column types
• :all - if you want to process all metadata

Datatype groups are:

• :type/numerical - any numerical type
• :type/float - floating point number (:float32 and :float64)
• :type/integer - any integer
• :type/datetime - any datetime type

If qualified keyword starts with :!type, complement set is used.

columns clj

(columns ds)

(columns ds result-type)

Returns columns of dataset. Result type can be any of:

• :as-map
• :as-double-arrays
• :as-seqs

columns->array-column clj

(columns->array-column ds column-selector new-column)

Converts several columns to a single column of type array. The src columns are dropped afterwards.

ds Dataset to operate on. column-selector anything supported by select-columns new-column new column to create

complete clj

(complete ds columns-selector & r)

TidyR complete.

Fills a dataset with all possible combinations of selected columns. When a given combination doesn't exist, missing values are created.

concat clj

(concat dataset & datasets)

Joins rows from other datasets

concat-copying clj

(concat-copying dataset & datasets)

Joins rows from other datasets via a copy of data

convert-types clj

(convert-types ds coltype-map-or-columns-selector)

(convert-types ds columns-selector new-types)

Convert type of the column to the other type.

cross-join clj

(cross-join ds-left ds-right)

(cross-join ds-left ds-right columns-selector)

(cross-join ds-left
            ds-right
            columns-selector
            {:keys [unique?] :or {unique? false} :as options})

Cross product from selected columns

crosstab clj

(crosstab ds row-selector col-selector)

(crosstab ds row-selector col-selector options)

Cross tabulation of two sets of columns.

Creates grouped dataset by [row-selector, col-selector] pairs and calls aggregation on each group.

Options:

• pivot? - create pivot table or just flat structure (default: true)
• replace-missing? - replace missing values? (default: true)
• missing-value - a missing value (default: 0)
• aggregator - aggregating function (default: row-count)
• marginal-rows, marginal-cols - adds row and/or cols, it's a sum if true. Can be a custom fn.

dataset clj

(dataset)

(dataset data)

(dataset data
         {:keys [single-value-column-name column-names layout dataset-name
                 stack-trace? error-column?]
          :or {single-value-column-name :$value
               layout :as-rows
               stack-trace? false
               error-column? true}
          :as options})

Create dataset.

Dataset can be created from:

• map of values and/or sequences
• sequence of maps
• sequence of columns
• file or url
• array of arrays
• single value

Single value is set only when it's not possible to find a path for given data. If tech.ml.dataset throws an exception, it's won;t be printed. To print a stack trace, set stack-trace? option to true.

dataset->str clj

(dataset->str ds)

(dataset->str ds options)

Convert a dataset to a string. Prints a single line header and then calls dataset-data->str.

For options documentation see dataset-data->str.

dataset-name clj

(dataset-name dataset)

dataset? clj

(dataset? ds)

Is ds a dataset type?

difference clj

(difference ds-left ds-right)

(difference ds-left ds-right options)

drop clj

(drop ds columns-selector rows-selector)

Drop columns and rows.

drop-columns clj

(drop-columns ds)

(drop-columns ds columns-selector)

(drop-columns ds columns-selector meta-field)

Drop columns by (returns dataset):

• name
• sequence of names
• map of names with new names (rename)
• function which filter names (via column metadata)

drop-missing clj

(drop-missing ds)

(drop-missing ds columns-selector)

Drop rows with missing values

columns-selector selects columns to look at missing values

drop-rows clj

(drop-rows ds)

(drop-rows ds rows-selector)

(drop-rows ds
           rows-selector
           {:keys [select-keys pre result-type parallel?] :as options})

Drop rows using:

• row id
• seq of row ids
• seq of true/false
• fn with predicate

empty-ds? clj

(empty-ds? ds)

expand clj

(expand ds columns-selector & r)

TidyR expand.

Creates all possible combinations of selected columns.

fill-range-replace clj

(fill-range-replace ds colname max-span)

(fill-range-replace ds colname max-span missing-strategy)

(fill-range-replace ds colname max-span missing-strategy missing-value)

Fill missing up with lacking values. Accepts

• dataset
• column name
• expected step (max-span, milliseconds in case of datetime column)
• (optional) missing-strategy - how to replace missing, default :down (set to nil if none)
• (optional) missing-value - optional value for replace missing

first clj

(first ds)

First row

fold-by clj

(fold-by ds columns-selector)

(fold-by ds columns-selector folding-function)

Group-by and pack columns into vector - the output data set has a row for each unique combination of the provided columns while each remaining column has its valu(es) collected into a vector, similar to how clojure.core/group-by works. See https://scicloj.github.io/tablecloth/index.html#Fold-by

full-join clj

(full-join ds-left ds-right columns-selector)

(full-join ds-left ds-right columns-selector options)

Join keeping all rows

get-entry clj

(get-entry ds column row)

Returns a single value from given column and row

group-by clj

(group-by ds grouping-selector)

(group-by ds
          grouping-selector
          {:keys [select-keys result-type]
           :or {result-type :as-dataset select-keys :all}
           :as options})

Group dataset by:

• column name
• list of columns
• map of keys and row indexes
• function getting map of values

Options are:

• select-keys - when grouping is done by function, you can limit fields to a select-keys seq.
• result-type - return results as dataset (:as-dataset, default) or as map of datasets (:as-map) or as map of row indexes (:as-indexes) or as sequence of (sub)datasets
• other parameters which are passed to dataset fn

When dataset is returned, meta contains :grouped? set to true. Columns in dataset:

• name - group name
• group-id - id of the group (int)
• data - group as dataset

grouped? clj

(grouped? ds)

Is dataset represents grouped dataset (result of group-by)?

groups->map clj

(groups->map ds)

Convert grouped dataset to the map of groups

groups->seq clj

(groups->seq ds)

Convert grouped dataset to seq of the groups

has-column? clj

(has-column? dataset column-name)

head clj

(head ds)

(head ds n)

First n rows (default 5)

info clj

(info ds)

(info ds result-type)

Returns a statistcial information about the columns of a dataset. result-type can be :descriptive or :columns

inner-join clj

(inner-join ds-left ds-right columns-selector)

(inner-join ds-left ds-right columns-selector options)

intersect clj

(intersect ds-left ds-right)

(intersect ds-left ds-right options)

join-columns clj

(join-columns ds target-column columns-selector)

(join-columns ds
              target-column
              columns-selector
              {:keys [separator missing-subst drop-columns? result-type
                      parallel?]
               :or {separator "-" drop-columns? true result-type :string}
               :as _conf})

Join clumns of dataset. Accepts: dataset column selector (as in select-columns) options :separator (default -) :drop-columns? - whether to drop source columns or not (default true) :result-type :map - packs data into map :seq - packs data into sequence :string - join strings with separator (default) or custom function which gets row as a vector :missing-subst - substitution for missing value

last clj

(last ds)

Last row

left-join clj

(left-join ds-left ds-right columns-selector)

(left-join ds-left ds-right columns-selector options)

let-dataset clj macro

(let-dataset bindings)

(let-dataset bindings options)

map-columns clj

(map-columns ds column-name map-fn)

(map-columns ds column-name columns-selector map-fn)

(map-columns ds column-name new-type columns-selector map-fn)

Map over rows using a map function. The arity should match the columns selected.

map-rows clj

(map-rows ds map-fn)

(map-rows ds map-fn options)

Map a function across the rows of the dataset producing a new dataset that is merged back into the original potentially replacing existing columns.

mark-as-group clj

(mark-as-group ds)

Add grouping tag

order-by clj

(order-by ds columns-or-fn)

(order-by ds columns-or-fn comparators)

(order-by ds columns-or-fn comparators {:keys [parallel?] :as options})

Order dataset by:

• column name
• columns (as sequence of names)
• key-fn
• sequence of columns / key-fn Additionally you can ask the order by:
• :asc
• :desc
• custom comparator function

pivot->longer clj

(pivot->longer ds)

(pivot->longer ds columns-selector)

(pivot->longer ds
               columns-selector
               {:keys [target-columns value-column-name splitter drop-missing?
                       datatypes coerce-to-number?]
                :or {target-columns :$column
                     value-column-name :$value
                     drop-missing? true
                     coerce-to-number? true}
                :as options})

tidyr pivot_longer api

pivot->wider clj

(pivot->wider ds columns-selector value-columns)

(pivot->wider
  ds
  columns-selector
  value-columns
  {:keys [fold-fn concat-columns-with concat-value-with drop-missing?]
   :or {concat-columns-with "_" concat-value-with "-" drop-missing? true}
   :as options})

Converts columns to rows. Arguments:

• dataset

• columns selector

• options: :target-columns - names of the columns created or columns pattern (see below) (default: :$column) :value-column-name - name of the column for values (default: :$value) :splitter - string, regular expression or function which splits source column names into data :drop-missing? - remove rows with missing? (default: true) :datatypes - map of target columns data types :coerce-to-number - try to convert extracted values to numbers if possible (default: true)

• target-columns - can be:

  • column name - source columns names are put there as a data
  • column names as seqence - source columns names after split are put separately into :target-columns as data
  • pattern - is a sequence of names, where some of the names are nil. nil is replaced by a name taken from splitter and such column is used for values.

print-dataset clj

(print-dataset ds)

(print-dataset ds options)

Prints dataset into console. For options see tech.v3.dataset.print/dataset-data->str

process-group-data clj

(process-group-data ds f)

(process-group-data ds f parallel?)

Internal: The passed-in function is applied on all groups

rand-nth clj

(rand-nth ds)

(rand-nth ds {:keys [seed] :as options})

Returns single random row

random clj

(random ds)

(random ds n)

(random ds n {:keys [repeat? seed] :or {repeat? true} :as options})

Returns (n) random rows with repetition

read-nippy clj

(read-nippy filename)

rename-columns clj

(rename-columns ds columns-mapping)

(rename-columns ds columns-selector columns-map-fn)

Rename columns with provided old -> new name map

reorder-columns clj

(reorder-columns ds columns-selector & columns-selectors)

Reorder columns using column selector(s). When column names are incomplete, the missing will be attached at the end.

replace-missing clj

(replace-missing ds)

(replace-missing ds strategy)

(replace-missing ds columns-selector strategy)

(replace-missing ds columns-selector strategy value)

Replaces missing values. Accepts

• dataset
• column selector, default: :all
• strategy, default: :nearest
• value (optional)
• single value
• sequence of values (cycled)
• function, applied on column(s) with stripped missings

Strategies are:

:value - replace with given value :up - copy values up :down - copy values down :updown - copy values up and then down for missing values at the end :downup - copy values down and then up for missing values at the beginning :mid or :nearest - copy values around known values :midpoint - use average value from previous and next non-missing :lerp - trying to lineary approximate values, works for numbers and datetime, otherwise applies :nearest. For numbers always results in float datatype.

right-join clj

(right-join ds-left ds-right columns-selector)

(right-join ds-left ds-right columns-selector options)

row-count clj

(row-count dataset-or-col)

rows clj

(rows ds)

(rows ds result-type)

Returns rows of dataset. Result type can be any of:

• :as-maps
• :as-double-arrays
• :as-seqs

select clj

(select ds columns-selector rows-selector)

Select columns and rows.

select-columns clj

(select-columns ds)

(select-columns ds columns-selector)

(select-columns ds columns-selector meta-field)

Select columns by (returns dataset):

• name
• sequence of names
• map of names with new names (rename)
• function which filter names (via column metadata)

select-missing clj

(select-missing ds)

(select-missing ds columns-selector)

Select rows with missing values

columns-selector selects columns to look at missing values

select-rows clj

(select-rows ds)

(select-rows ds rows-selector)

(select-rows ds
             rows-selector
             {:keys [select-keys pre result-type parallel?] :as options})

Select rows using:

• row id
• seq of row ids
• seq of true/false
• fn with predicate

semi-join clj

(semi-join ds-left ds-right columns-selector)

(semi-join ds-left ds-right columns-selector options)

separate-column clj

(separate-column ds column)

(separate-column ds column separator)

(separate-column ds column target-columns separator)

(separate-column ds
                 column
                 target-columns
                 separator
                 {:keys [missing-subst drop-column? parallel?]
                  :or {missing-subst ""}
                  :as _conf})

set-dataset-name clj

(set-dataset-name dataset ds-name)

shape clj

(shape ds)

Returns shape of the dataset [rows, cols]

shuffle clj

(shuffle ds)

(shuffle ds {:keys [seed] :as options})

Shuffle dataset (with seed)

split clj

(split ds)

(split ds split-type)

(split ds
       split-type
       {:keys [seed parallel? shuffle?] :or {shuffle? true} :as options})

Split given dataset into 2 or more (holdout) splits

As the result two new columns are added:

• :$split-name - with subgroup name
• :$split-id - fold id/repetition id

split-type can be one of the following:

• :kfold - k-fold strategy, :k defines number of folds (defaults to 5), produces k splits
• :bootstrap - :ratio defines ratio of observations put into result (defaults to 1.0), produces 1 split
• :holdout - split into two parts with given ratio (defaults to 2/3), produces 1 split
• :loo - leave one out, produces the same number of splits as number of observations

:holdout can accept also probabilites or ratios and can split to more than 2 subdatasets

Additionally you can provide:

• :seed - for random number generator
• :repeats - repeat procedure :repeats times
• :partition-selector - same as in group-by for stratified splitting to reflect dataset structure in splits.
• :split-names names of subdatasets different than default, ie. [:train :test :split-2 ...]
• :split-col-name - a column where name of split is stored, either :train or :test values (default: :$split-name)
• :split-id-col-name - a column where id of the train/test pair is stored (default: :$split-id)
• :ratio - specify a list of split ratios for :holdout. Need to have same size then :split-names (example: [0.2 0.2 0.6])

Rows are shuffled before splitting.

In case of grouped dataset each group is processed separately.

See more

split->seq clj

(split->seq ds)

(split->seq ds split-type)

(split->seq ds
            split-type
            {:keys [split-col-name split-id-col-name]
             :or {split-col-name :$split-name split-id-col-name :$split-id}
             :as options})

Returns split as a sequence of train/test datasets or map of sequences (grouped dataset)

tail clj

(tail ds)

(tail ds n)

Last n rows (default 5)

ungroup clj

(ungroup ds)

(ungroup ds
         {:keys [order? add-group-as-column add-group-id-as-column separate?
                 dataset-name parallel?]
          :or {separate? true}
          :as options})

Concat groups into dataset.

When add-group-as-column or add-group-id-as-column is set to true or name(s), columns with group name(s) or group id is added to the result.

Before joining the groups groups can be sorted by group name.

union clj

(union ds & datasets)

unique-by clj

(unique-by ds)

(unique-by ds columns-selector)

(unique-by
  ds
  columns-selector
  {:keys [strategy select-keys parallel?] :or {strategy :first} :as options})

Remove rows which contains the same data column-selector Select columns for uniqueness strategy There are 4 strategies defined to handle duplicates

:first - select first row (default) :last - select last row :random - select random row any function - apply function to a columns which are subject of uniqueness

unmark-group clj

(unmark-group ds)

Remove grouping tag

unroll clj

(unroll ds columns-selector)

(unroll ds columns-selector options)

Unfolds sequences stored inside a column(s), turning it into multiple columns. Opposite of fold-by. Add each of the provided columns to the set that defines the "uniqe key" of each row. Thus there will be a new row for each value inside the target column(s)' value sequence. If you want instead to split the content of the columns into a set of new columns, look at separate-column. See https://scicloj.github.io/tablecloth/index.html#Unroll

update-columns clj

(update-columns ds columns-map)

(update-columns ds columns-selector update-functions)

without-grouping-> clj macro

(without-grouping-> ds & r)

write! clj

(write! dataset output-path)

(write! dataset output-path options)

Write a dataset out to a file. Supported forms are:

(ds/write! test-ds "test.csv")
(ds/write! test-ds "test.tsv")
(ds/write! test-ds "test.tsv.gz")
(ds/write! test-ds "test.nippy")
(ds/write! test-ds out-stream)

Options:

• :max-chars-per-column - csv,tsv specific, defaults to 65536 - values longer than this will cause an exception during serialization.
• :max-num-columns - csv,tsv specific, defaults to 8192 - If the dataset has more than this number of columns an exception will be thrown during serialization.
• :quoted-columns - csv specific - sequence of columns names that you would like to always have quoted.
• :file-type - Manually specify the file type. This is usually inferred from the filename but if you pass in an output stream then you will need to specify the file type.
• :headers? - if csv headers are written, defaults to true.

write-csv! clj deprecated

write-nippy! clj

(write-nippy! ds filename)