incanter.core — incanter/incanter-core 1.9.3

This is the core numerics library for Incanter. It provides functions for vector- and matrix-based mathematical operations and the core data manipulation functions for Incanter.

This library is built on core.matrix (https://github.com/mikera/core.matrix) and Parallel Colt (http://sites.google.com/site/piotrwendykier/software/parallelcolt) an extension of the Colt numerics library (http://acs.lbl.gov/~hoschek/colt/).

$ clj

($ cols)

($ arg1 arg2)

($ rows cols data)

An alias to (sel (second args) :cols (first args)). If given only a single argument, it will use the $data binding for the first argument, which is set with the with-data macro.

Examples: (use '(incanter core stats charts datasets))

(def cars (get-dataset :cars)) ($ :speed cars)

(with-data cars (def lm (linear-model ($ :dist) ($ :speed))) (doto (scatter-plot ($ :speed) ($ :dist)) view (add-lines ($ :speed) (:fitted lm))))

;; standardize speed and dist and append the standardized variables to the original dataset (with-data (get-dataset :cars) (view (conj-cols $data (sweep (sweep ($ :speed)) :stat sd :fun div) (sweep (sweep ($ :dist)) :stat sd :fun div))))

(with-data (get-dataset :iris) (view $data) (view ($ [:Sepal.Length :Sepal.Width :Species])) (view ($ [:not :Petal.Width :Petal.Length])) (view ($ 0 [:not :Petal.Width :Petal.Length])))

(use 'incanter.core) (def mat (matrix (range 9) 3)) (view mat) ($ 2 2 mat) ($ [0 2] 2 mat) ($ :all 1 mat) ($ 1 mat) ($ [:not 1] mat) ($ 0 :all mat) ($ [0 2] [0 2] mat) ($ [:not 1] [:not 1] mat) ($ [:not 1] :all mat) ($ [0 2] [:not 1] mat) ($ [0 2] [:not 1 2] mat) ($ [0 2] [:not (range 2)] mat) ($ [:not (range 2)] [0 2] mat)

(with-data mat ($ 0 0)) (with-data mat ($ [0 2] 2 mat)) (with-data mat ($ :all 1)) (with-data mat ($ [0 2] [0 2])) (with-data mat ($ [:not 1] :all)) (with-data mat ($ [0 2] [:not 1]))

(use 'incanter.datasets) (view (get-dataset :cars)) ($ (range 5) 0 (get-dataset :cars)) ($ (range 5) :all (get-dataset :cars)) ($ :all (range 2) (get-dataset :cars))

($ (range 5) :dist (get-dataset :cars)) ($ [:not (range 5)] 0 (get-dataset :cars)) ($ [:not 0 1 2 3 4] 0 (get-dataset :cars)) (with-data (get-dataset :cars) ($ 0 :dist))

(with-data (get-dataset :hair-eye-color) (view $data) (view ($ [:not :gender])))

$= clj/s macro

($= & equation)

Formula macro translates from infix to prefix

Examples:

(use 'incanter.core) ($= 7 + 8) ($= [1 2 3] + [4 5 6]) ($= [1 2 3] + (sin [4 5 6])) ($= [1 2 3] <*> (trans [1 2 3])) ($= [1 2 3] * [1 2 3]) ($= [1 2 3] <x> [1 2 3]) ($= 9 * 8 ** 3) ($= (sin Math/PI) * 10)

($= 10 + 20 * (4 - 5) / 6)

($= 20 * (4 - 5) / 6)

(let [x 10 y -5] ($= x + y / -10))

($= 3 ** 3)

($= [1 2 3] * [1 2 3]) ($= [1 2 3] / (sq [1 2 3]) + [5 6 7])

($= (sqrt 5 * 5 + 3 * 3)) ($= (sq [1 2 3] + [1 2 3])) ($= ((5 + 4) * 5)) ($= ((5 + 4 * (3 - 4)) / (5 + 8) * 6)) ($= [1 2 3] + 5) ($= (matrix [[1 2] [4 5]]) + 6) ($= (trans [[1 2] [4 5]]) + 6)

($= (trans [[1 2] [4 5]]) <*> (matrix [[1 2] [4 5]]))

(use '(incanter core charts)) (defn f [x] ($= x ** 2 + 3 * x + 5)) (f 5) (view (function-plot f -10 10)) (view (function-plot #($= % ** 2 + 3 * % + 5) -10 10)) (view (function-plot (fn [x] ($= x ** 2 + 3 * x + 5)) -10 10)) (let [x (range -10 10 0.1)] (view (xy-plot x ($= x ** 3 - 5 * x ** 2 + 3 * x + 5))))

($= (5 + 7)) ($= (trans [1 2 3 4]) <> [1 2 3 4]) ($= [1 2 3 4] <> (trans [1 2 3 4]))

($= [1 2 3 4] <*> (trans [1 2 3 4])) ($= [1 2 3 4] <x> (trans [1 2 3 4]))

;; kronecker product example ($= (matrix [[1 2] [3 4] [5 6]]) <x> 4) ($= (matrix [[1 2] [3 4] [5 6]]) <x> (matrix [[1 2] [3 4]])) ($= [1 2 3 4] <x> 4)

($= 3 > (5 * 2/7))

(use '(incanter core datasets charts)) (with-data (get-dataset :cars) (doto (scatter-plot :speed :dist :data ($where ($fn [speed dist] ($= dist / speed < 2)))) (add-points :speed :dist :data ($where ($fn [speed dist] ($= dist / speed >= 2)))) (add-lines ($ :speed) ($= 2 * ($ :speed))) view))

$data clj

This variable is bound to a dataset when the with-data macro is used. functions like $ and $where can use $data as a default argument.

$fn clj/s macro

($fn col-bindings body)

A simple macro used as syntactic sugar for defining predicate functions to be used in the $where function. The supplied arguments should be column names of a dataset. This macro performs map destructuring on the arguments.

For instance, ($fn [speed] (< speed 10)) => (fn [{:keys [speed]}] (< speed 10))

Examples: (use '(incanter core datasets)) (view ($where ($fn [speed dist] (or (> speed 20) (< dist 10))) (get-dataset :cars)))

(view ($where ($fn [speed dist] (< (/ dist speed) 2)) (get-dataset :cars)))

(use '(incanter core datasets charts)) (with-data (get-dataset :cars) (doto (scatter-plot :speed :dist :data ($where ($fn [speed dist] (< (/ dist speed) 2)))) (add-points :speed :dist :data ($where ($fn [speed dist] (>= (/ dist speed) 2)))) (add-lines ($ :speed) (mult 2 ($ :speed))) view))

(let [passed? ($fn [speed dist] (< (/ dist speed) 2)) failed? (complement passed?)] (with-data (get-dataset :cars) (doto (scatter-plot :speed :dist :data ($where passed?)) (add-points :speed :dist :data ($where failed?)) (add-lines ($ :speed) (mult 2 ($ :speed))) view)))

(use '(incanter core stats charts)) (let [above-sine? ($fn [col-0 col-1] (> col-1 (sin col-0))) below-sine? (complement above-sine?)] (with-data (conj-cols (sample-uniform 1000 :min -5 :max 5) (sample-uniform 1000 :min -1 :max 1)) (doto (function-plot sin -5 5) (add-points :col-0 :col-1 :data ($where above-sine?)) (add-points :col-0 :col-1 :data ($where below-sine?)) view)))

(view ($where ($fn [] (> (rand) 0.9)) (get-dataset :cars)))

(view ($where ($fn [Species] ($in Species #{"virginica" "setosa"})) (get-dataset :iris)))

$group-by clj

($group-by cols)

($group-by cols data)

Returns a map of datasets keyed by a query-map corresponding the group.

Examples:

(use '(incanter core datasets)) ($group-by :Species (get-dataset :iris))

($group-by [:hair :eye] (get-dataset :hair-eye-color))

(with-data (get-dataset :hair-eye-color) ($group-by [:hair :eye]))

$join clj

($join [left-keys right-keys] left-data)

($join [left-keys right-keys] left-data right-data)

Returns a dataset created by right-joining two datasets. The join is based on one or more columns in the datasets. If used within the body of the with-data macro, the second dataset is optional, defaulting the the dataset bound to $data.

Examples: (use '(incanter core stats datasets charts)) (def iris (get-dataset :iris))

(def lookup (dataset [:species :species-key] [["setosa" :setosa] ["versicolor" :versicolor] ["virginica" :virginica]])) (view ($join [:species :Species] lookup iris))

(def hair-eye-color (get-dataset :hair-eye-color)) (def lookup2 (conj-cols ($ [:hair :eye :gender] hair-eye-color) (range (nrow hair-eye-color)))) (view ($join [[:col-0 :col-1 :col-2] [:hair :eye :gender]] lookup2 hair-eye-color))

(with-data hair-eye-color (view ($join [[:col-0 :col-1 :col-2] [:hair :eye :gender]] lookup2)))

(def lookup3 (dataset [:gender :hair :hair-gender] [["male" "black" :male-black] ["male" "brown" :male-brown] ["male" "red" :male-red] ["male" "blond" :male-blond] ["female" "black" :female-black] ["female" "brown" :female-brown] ["female" "red" :female-red] ["female" "blond" :female-blond]]))

(view ($join [[:gender :hair] [:gender :hair]] lookup3 hair-eye-color))

(use 'incanter.charts) (with-data (->> (get-dataset :hair-eye-color) ($where {:hair {:in #{"brown" "blond"}}}) ($rollup :sum :count [:hair :gender]) ($join [[:gender :hair] [:gender :hair]] lookup3) ($order :count :desc)) (view $data) (view (bar-chart :hair :count :group-by :gender :legend true)))

$map clj

($map fun col-keys)

($map fun col-keys data)

This function returns a sequence resulting from mapping the given function over the value(s) for the given column key(s) of the given dataset. Like other '$*' functions, it will use $data as the default dataset if none is provided, where $data is set using the with-data macro.

Examples:

(use '(incanter core datasets)) (def cars (get-dataset :cars))

($map (fn [s] (/ s)) :speed cars) ($map (fn [s d] (/ s d)) [:speed :dist] cars)

(with-data (get-dataset :cars) (view ($map (fn [s] (/ s)) :speed)) (view ($map (fn [s d] (/ s d)) [:speed :dist])))

;; calculate the speed to dist ratio and append as new column to dataset (with-data (get-dataset :cars) (conj-cols $data ($map (fn [s d] (/ s d)) [:speed :dist])))

$order clj

($order cols order)

($order cols order data)

Sorts a dataset by the given columns in either ascending (:asc) or descending (:desc) order. If used within a the body of the with-data macro, the data argument is optional, defaulting to the dataset bound to the variable $data.

Examples:

(use '(incanter core charts datasets)) (def iris (get-datset :iris)) (view ($order :Sepal.Length :asc iris)) (view ($order [:Sepal.Width :Sepal.Length] :desc iris))

(with-data (get-dataset :iris) (view ($order [:Petal.Length :Sepal.Length] :desc)))

$rollup clj

($rollup summary-fun col-name group-by)

($rollup summary-fun col-name group-by data)

Returns a dataset that uses the given summary function (or function identifier keyword) to rollup the given column based on a set of group-by columns. The summary function should accept a single sequence of values and return a single summary value. Alternatively, you can provide a keyword identifier of a set of built-in functions including:

:max -- the maximum value of the data in each group :min -- the minimum value of the data in each group :sum -- the sum of the data in each group :count -- the number of elements in each group :mean -- the mean of the data in each group

Like the other '$' dataset functions, $rollup will use the dataset bound to $data (see the with-data macro) if a dataset is not provided as an argument.

Examples:

(use '(incanter core datasets))

(def iris (get-dataset :iris)) ($rollup :mean :Sepal.Length :Species iris) ($rollup :count :Sepal.Length :Species iris) ($rollup :max :Sepal.Length :Species iris) ($rollup :min :Sepal.Length :Species iris)

;; The following is an example using a custom function, but since all the ;; iris measurements are positive, the built-in mean function could have ;; been used instead.

(use 'incanter.stats) ($rollup #(mean (abs %)) :Sepal.Width :Species iris)

($rollup sd :Sepal.Length :Species iris) ($rollup variance :Sepal.Length :Species iris) ($rollup median :Sepal.Length :Species iris)

(def hair-eye-color (get-dataset :hair-eye-color)) ($rollup :mean :count [:hair :eye] hair-eye-color)

(use 'incanter.charts) (with-data ($rollup :mean :Sepal.Length :Species iris) (view (bar-chart :Species :Sepal.Length)))

;; the following examples use the built-in data set called hair-eye-color.

(with-data ($rollup :mean :count [:hair :eye] hair-eye-color) (view (bar-chart :hair :count :group-by :eye :legend true)))

(with-data (->> (get-dataset :hair-eye-color) ($where {:hair {:in #{"brown" "blond"}}}) ($rollup :sum :count [:hair :eye]) ($order :count :desc)) (view $data) (view (bar-chart :hair :count :group-by :eye :legend true)))

$where clj

($where query-map)

($where query-map data)

An alias to (query-dataset (second args) (first args)). If given only a single argument, it will use the $data binding for the first argument, which is set with the with-data macro.

Examples:

(use '(incanter core datasets))

(def cars (get-dataset :cars)) ($where {:speed 10} cars)

;; use the with-data macro and the one arg version of $where (with-data cars (view ($where {:speed {:$gt -10 :$lt 10}})) (view ($where {:dist {:$in #{10 12 16}}})) (view ($where {:dist {:$nin #{10 12 16}}})))

;; create a dataset where :speed greater than 10 or less than -10 (with-data (get-dataset :cars) (view (-> ($where {:speed {:$gt 20}}) (conj-rows ($where {:speed {:$lt 10}})))))

abs clj

(abs A)

Returns the absolute value of the elements in the given matrix, sequence or number. Equivalent to R's abs function.

acos clj

(acos A)

Returns the arc cosine of the elements in the given matrix, sequence or number. Equivalent to R's acos function.

add-column clj

(add-column column-name values)

(add-column column-name values data)

Adds a column, with given values, to a dataset.

add-derived-column clj

(add-derived-column column-name from-columns f)

(add-derived-column column-name from-columns f data)

This function adds a column to a dataset that is a function of existing columns. If no dataset is provided, $data (bound by the with-data macro) will be used. f should be a function of the from-columns, with arguments in that order.

Examples: (use '(incanter core datasets)) (def cars (get-dataset :cars))

(add-derived-column :dist-over-speed [:dist :speed] (fn [d s] (/ d s)) cars)

(with-data (get-dataset :cars) (view (add-derived-column :speed**-1 [:speed] #(/ 1.0 %))))

aggregate clj

(aggregate fields group-by & {:keys [dataset rollup-fun] :or {rollup-fun :sum}})

Performs the aggregation of the data in given dataset using the specified rollup function. The fields parameter defines column(s) on which the rollup will happen, and group-by specifies the column(s) for joining the results. The fields & group-by parameters could be single values or collections. The dataset is provided by the :dataset parameter, if it's not provided, then the $data is used. The rollup function is provided by :rollup-fun parameter, if it's not provided, then the :sum is used.

(aggregate [:uptake :conc] :Type :dataset (get-dataset :co2)) (aggregate [:uptake :conc] [:Type] :dataset (get-dataset :co2) :rollup-fun :min)

asin clj

(asin A)

Returns the arc sine of the elements in the given matrix, sequence or number. Equivalent to R's asin function.

atan clj

(atan A)

Returns the arc tangent of the elements in the given matrix, sequence or number. Equivalent to R's atan function.

atan2 clj

(atan2 & args)

Returns the atan2 of the elements in the given matrices, sequences or numbers. Equivalent to R's atan2 function.

beta clj

(beta a b)

Equivalent to R's beta function.

References: http://incanter.org/docs/parallelcolt/api/cern/jet/stat/tdouble/Gamma.html

bind-columns clj

(bind-columns & args)

Returns the matrix resulting from concatenating the given matrices and/or sequences by their columns. Equivalent to R's cbind.

Examples: (def A (matrix [[1 2 3] [4 5 6] [7 8 9]]))

(def B (matrix [10 11 12]))

(bind-columns A B)

(bind-columns [1 2 3 4] [5 6 7 8])

bind-rows clj

(bind-rows & args)

Returns the matrix resulting from concatenating the given matrices and/or sequences by their rows. Equivalent to R's rbind.

Examples: (def A (matrix [[1 2 3] [4 5 6] [7 8 9]]))

(def B (matrix [[10 11 12] [13 14 15]]))

(bind-rows A B)

(bind-rows [1 2 3 4] [5 6 7 8])

categorical-var clj

(categorical-var & {:keys [data ordered? labels levels] :or {ordered? false}})

Returns a categorical variable based on the values in the given collection. Equivalent to R's factor function.

Options: :data (default nil) factors will be extracted from the given data. :ordered? (default false) indicates that the variable is ordinal. :labels (default (sort (into #{} data))) :levels (range (count labels))

Examples: (categorical-var :data [:a :a :c :b :a :c :c]) (categorical-var :labels [:a :b :c]) (categorical-var :labels [:a :b :c] :levels [10 20 30]) (categorical-var :levels [1 2 3])

choose clj

(choose n k)

Returns number of k-combinations (each of size k) from a set S with n elements (size n), which is the binomial coefficient (also known as the 'choose function') [wikipedia] choose = n!/(k!(n - k)!)

Equivalent to R's choose function.

Examples: (choose 25 6) ; => 177,100

References: http://incanter.org/docs/parallelcolt/api/cern/jet/math/tdouble/DoubleArithmetic.html http://en.wikipedia.org/wiki/Combination

col-names clj deprecated

(col-names data)

If given a dataset, it returns its column names. If given a dataset and a sequence of column names, it returns a dataset with the given column names.

Examples: (use '(incanter core datasets)) (def data (get-dataset :cars)) (col-names data)

Deprecated. Please use clojure.core.matrix.dataset/column-names instead.

condition clj

(condition mat)

Returns the two norm condition number, which is max(S) / min(S), where S is the diagonal matrix of singular values from an SVD decomposition.

Examples: (use 'incanter.core) (def foo (matrix (range 9) 3)) (condition foo)

References: http://en.wikipedia.org/wiki/Condition_number

conj-cols clj

(conj-cols & args)

Returns a dataset created by merging the given datasets and/or collections. There must be the same number of rows in each dataset and/or collections. Column names may be changed in order to prevent naming conflicts in the conjed dataset.

Examples: (use '(incanter core datasets)) (def cars (get-dataset :cars)) (def x (sel cars :cols 0)) (view (conj-cols cars cars)) (view (conj-cols cars x)) (view (conj-cols (range (nrow cars)) cars)) (view (conj-cols (range 10) (range 10))) (view (conj-cols {:a 1 :b 2} {:c 1 :d 2}))

conj-rows clj deprecated

(conj-rows & args)

Returns a dataset created by combining the rows of the given datasets and/or collections.

Examples:

(use '(incanter core datasets)) (def cars (get-dataset :cars)) (view (conj-rows (to-dataset (range 5)) (to-dataset (range 5 10)))) (view (conj-rows cars cars)) (view (conj-rows [[1 2] [3 4]] [[5 6] [7 8]])) (view (conj-rows [{:a 1 :b 2} {:a 3 :b 4}] [[5 6] [7 8]])) (view (conj-rows (to-dataset [{:a 1 :b 2} {:a 3 :b 4}]) [[5 6] [7 8]])) (conj-rows (range 5) (range 5 10))

Deprecated. Please use clojure.core.matrix/conj-rows instead.

copy clj deprecated

(copy mat)

Deprecated. Please use clojure.core.matrix/clone instead.

cos clj

(cos A)

Returns the cosine of the elements in the given matrix, sequence or number. Equivalent to R's cos function.

cumulative-sum clj

(cumulative-sum coll)

Returns a sequence of cumulative sum for the given collection. For instance The first value equals the first value of the argument, the second value is the sum of the first two arguments, the third is the sum of the first three arguments, etc.

Examples: (use 'incanter.core) (cumulative-sum (range 100))

data-table clj multimethod

Creates javax.swing.JTable from dataset or matrix.

JTable column names for datasets will be the datset's column names. For matrices, an optional argument :column-names can be used to set the resulting column names. Otherweise incrementing indices are used (0,1,2,..).

Example:

(data-table (clojure.core.matrix/matrix [[1 2 3][4 5 6]]) :column-names ["first col" "second col" "third col"])

dataset clj

(dataset m)

(dataset column-names m)

Returns a record of type clojure.core.matrix.impl.dataset.DataSet. Creates dataset from: column names and seq of rows column names and seq of row maps map of columns with associated list of values. matrix - its columns will be used as dataset columns and incrementing Long values starting from 0, i.e. 0, 1, 2, etc will be used as column names. seq of maps

Deprecated. Please use clojure.core.matrix.dataset/dataset instead.

dataset? clj deprecated

(dataset? obj)

Determines if obj is of type clojure.core.matrix.impl.dataset.Dataset.

Deprecated. Please use clojure.core.matrix.dataset/dataset? instead.

decomp-cholesky clj deprecated

(decomp-cholesky mat)

(decomp-cholesky mat options)

Returns the Cholesky decomposition of the given matrix. Equivalent to R's chol function.

Returns: a map containing two matrices with the keys [:L :L*] such that

Such that: M = L.L*

Where

• M must be a hermitian, positive definite matrix
• L is a lower triangular matrix
• L* is the conjugate transpose of L

If :return parameter is specified in options map, it returns only specified keys.

Examples: (use '(incanter core stats charts datasets)) ;; load the iris dataset (def iris (to-matrix (get-dataset :iris))) ;; take the Cholesky decomposition of the correlation matrix of the iris data. (let [{:keys [L L*]} (decomp-cholesky (correlation iris))]) (let [{:keys [L*]} (decomp-cholesky (correlation iris {:return [:L*]}))])

References: http://en.wikipedia.org/wiki/Cholesky_decomposition

Deprecated. Please use clojure.core.matrix.linear/cholesky instead.

decomp-eigenvalue clj deprecated

(decomp-eigenvalue mat)

(decomp-eigenvalue mat options)

Returns a map containing matrices for each of the the keys [:Q :rA :iA] such that:

M = Q.A.Q-1

Where:

• Q is a matrix where each column is the ith normalised eigenvector of M
• rA is a vector whose elements are the real numbers of eigenvalues.
• iA is a vector whose elements are the imaginary units of eigenvalues.
• Q⁻-1 is the inverse of Q

If :return parameter is specified in options map, it returns only specified keys. if :symmetric parameter is true in options map, symmetric eigenvalue decomposition will be performed.

Examples:

(use 'incanter.core) (def foo (matrix (range 9) 3)) (let [{:keys [Q rA iA]} (decomp-eigenvalue M)]) (let [{:keys [Q rA iA]} (decomp-eigenvalue M {:symmetric true})]) (let [{:keys [Q rA]} (decomp-eigenvalue M {:return [:Q :rA]})])

References: http://en.wikipedia.org/wiki/Eigenvalue_decomposition

Deprecated. Please use clojure.core.matrix.linear/eigen instead.

decomp-lu clj deprecated

(decomp-lu mat)

(decomp-lu mat options)

Computes the LU(P) decomposition of a matrix with partial row pivoting. Returns a map containing the keys [:L :U :P], such that:

 P.A = L.U

Where

• L is a lower triangular matrix
• U is an upper triangular matrix
• P is a permutation matrix

Examples:

(use 'incanter.core) (def foo (matrix (range 9) 3)) (let [{:keys [L U P]} (decomp-lu A)])

References: http://en.wikipedia.org/wiki/LU_decomposition http://mikiobraun.github.io/jblas/javadoc/org/jblas/Decompose.LUDecomposition.html

Deprecated. Please use clojure.core.matrix.linear/lu instead.

decomp-qr clj deprecated

(decomp-qr mat)

(decomp-qr mat options)

Returns the QR decomposition of the given matrix. Equivalent to R's qr function. Returns a map containing matrices with the keys [:Q :R] such that:

  M = Q.R

Where: - Q is an orthogonal matrix - R is an upper triangular matrix (= right triangular matrix)

If :return parameter is specified in options map, it returns only specified keys. If :compact parameter is specified in options map, compact versions of matrices are returned.

Examples:

(use 'incanter.core) (def foo (matrix (range 9) 3)) (let [{:keys [Q R]} (qr M)]) (let [{:keys [R]} (qr M {:return [:R]})])

References: http://en.wikipedia.org/wiki/QR_decomposition

Deprecated. Please use clojure.core.matrix.linear/qr instead.

decomp-svd clj deprecated

(decomp-svd mat)

(decomp-svd mat options)

Returns the Singular Value Decomposition (SVD) of the given matrix. Equivalent to R's svd function.

If :return parameter is specified in options map, it returns only specified keys. By default returns a map containing: :S -- the diagonal matrix of singular values S (the diagonal in vector form) :U -- the left singular vectors U :V* -- the right singular vectors V

Examples:

(use 'incanter.core) (def foo (matrix (range 9) 3)) (let [{:keys [U S V*]} (decomp-svd foo)] ....) (let [{:keys [S]} (decomp-svd foo {:return [:S]})] ....)

References: http://en.wikipedia.org/wiki/Singular_value_decomposition

Deprecated. Please use clojure.core.matrix.linear/svd instead.

deshape clj

(deshape & {:keys [data remove-na group-by merge] :or {remove-na true}})

Returns a dataset where the columns identified by :merge are collapsed into two columns called :variable and :value. The values in these columns are grouped by the columns identified by :group-by.

Examples:

(use '(incanter core charts datasets)) (with-data (->> (deshape :merge [:Ahmadinejad :Rezai :Karrubi :Mousavi] :group-by :Region :data (get-dataset :iran-election)) ($order :value :desc)) (view $data) (view (bar-chart :variable :value :group-by :Region :legend true))

(view (bar-chart :Region :value :group-by :variable
                 :legend true :vertical false))

(view (bar-chart :Region :value :legend true :vertical false
                 :data ($order :value :desc ($rollup :sum :value :Region)))))



(def data (to-dataset [{:subject "John Smith" :time 1 :age 33 :weight 90 :height 1.87}
                       {:subject "Mary Smith" :time 1 :height 1.54}]))
(view data)
(view (deshape :group-by [:subject :time] :merge [:age :weight :height] :data data))
(view (deshape :merge [:age :weight :height] :data data))
(view (deshape :group-by [:subject :time] :data data))

(view (deshape :merge [:age :weight :height] :remove-na false :data data))

det clj deprecated

(det mat)

Returns the determinant of the given matrix. Equivalent to R's det function.

References: http://en.wikipedia.org/wiki/LU_decomposition

Deprecated. Please use clojure.core.matrix/det instead.

diag clj deprecated

(diag m)

If given a matrix, diag returns a sequence of its diagonal elements. If given a sequence, it returns a matrix with the sequence's elements on its diagonal. Equivalent to R's diag function.

Examples: (diag [1 2 3 4]) ; produces diagonal matrix

(def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (diag A) ;; returns elements on main diagonal

Deprecated. Please use clojure.core.matrix/main-diagonal for getting elements on main diagonal and clojure.core.matrix/diagonal-matrix for creating diagonal matrix instead.

dim clj deprecated

(dim mat)

Returns a vector with the number of rows and columns of the given matrix.

Deprecated. Please use clojure.core.matrix/dimensionality instead.

dispatch clj

(dispatch obj)

Dispatch function for multimethods

div clj deprecated

(div & args)

Performs element-by-element division on multiple matrices, sequences and/or numbers. Equivalent to R's / operator. Examples:

(def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (div A A A) (div A 2) (div 2 A) (div [1 2 3] [1 2 3]) (div [1 2 3] 2) (div 2 [1 2 3])

(div [1 2 3]) ; returns [1 1/2 13]

Deprecated. Please use clojure.core.matrix/div or clojure.core.matrix.operators// instead.

exp clj

(exp A)

Returns the exponential of the elements in the given matrix, sequence or number. Equivalent to R's exp function.

factorial clj

(factorial k)

Returns the factorial of k (k must be a positive integer). Equivalent to R's factorial function.

Examples: (factorial 6)

References: http://incanter.org/docs/parallelcolt/api/cern/jet/math/tdouble/DoubleArithmetic.html http://en.wikipedia.org/wiki/Factorial

fill-missing clj

(fill-missing maps)

gamma clj

(gamma x)

Equivalent to R's gamma function.

References: http://incanter.org/docs/parallelcolt/api/cern/jet/stat/tdouble/Gamma.html

get-categories clj

(get-categories cols data)

Given a dataset and one or more column keys, returns the set of categories for them.

Examples:

(use '(incanter core datasets)) (get-categories :eye (get-dataset :hair-eye-color)) (get-categories [:eye :hair] (get-dataset :hair-eye-color))

grid-apply clj

(grid-apply f x-min x-max y-min y-max)

(grid-apply f x-min x-max y-min y-max x-res y-res)

Applies the given function f, that accepts two arguments, to a grid defined by rectangle bounded x-min, y-min, x-max, y-max and returns a sequence of three sequences representing the cartesian product of x and y and z calculated by applying f to the combinations of x and y.

Defaults to a 100x100 'grid', where the x and y axes are sampled evenly accorinding to the grid. Callers may supply their own horizontal and vertical sampling resolutions via x-res and y-res. In cases where the sampling resolution is lower than the range of actual values, a sparse response surface will result.

group-on clj

(group-on mat on-cols & {:keys [cols except-cols]})

Groups the given matrix by the values in the columns indicated by the 'on-cols' argument, returning a sequence of matrices. The returned matrices are sorted by the value of the group column ONLY when there is only a single (non-vector) on-col argument.

Examples:

(use '(incanter core datasets)) (def plant-growth (to-matrix (get-dataset :plant-growth))) (group-on plant-growth 1) ;; only return the first column (group-on plant-growth 1 :cols 0) ;; don't return the second column (group-on plant-growth 1 :except-cols 1)

(def plant-growth-dummies (to-matrix (get-dataset :plant-growth) :dummies true)) (group-on plant-growth-dummies [1 2]) ;; return only the first column (group-on plant-growth-dummies [1 2] :cols 0) ;; don't return the last two columns (group-on plant-growth-dummies [1 2] :except-cols [1 2])

;; plot the plant groups (use 'incanter.charts) ;; can use destructuring if you know the number of groups ;; groups are sorted only if the group is based on a single column value (let [[ctrl trt1 trt2] (group-on plant-growth 1 :cols 0)] (doto (box-plot ctrl) (add-box-plot trt1) (add-box-plot trt2) view))

half-vectorize clj

(half-vectorize mat)

Returns the half-vectorization (i.e. vech) of the given matrix. The half-vectorization, vech(A), of a symmetric nxn matrix A is the n(n+1)/2 x 1 column vector obtained by vectorizing only the upper triangular part of A.

For instance: (= (half-vectorize (matrix [[a b] [b d]])) (matrix [a b d]))

Examples: (def A (matrix [[1 2] [2 4]])) (half-vectorize A)

References: http://en.wikipedia.org/wiki/Vectorization_(mathematics)

head clj

(head mat)

(head len mat)

Returns the head of the dataset. 10 or full dataset by default.

identity-matrix clj deprecated

(identity-matrix n)

Returns an n-by-n identity matrix.

Examples: (identity-matrix 4)

Deprecated. Please use clojure.core.matrix/identity-matrix instead.

incomplete-beta clj

(incomplete-beta x a b)

Returns the non-regularized incomplete beta value.

References: http://incanter.org/docs/parallelcolt/api/cern/jet/stat/tdouble/Gamma.html

inner-product clj deprecated

(inner-product u v)

kronecker clj

(kronecker & args)

Returns the Kronecker product of the given arguments.

Examples:

(def x (matrix (range 6) 2)) (def y (matrix (range 4) 2)) (kronecker 4 x) (kronecker x 4) (kronecker x y)

length clj deprecated

(length coll)

A version of count that works on collections, matrices, and numbers. The length of a number is one, the length of a collection is its count and the length of a matrix is the number of elements it contains (nrow*ncol). Equivalent to R's length function.

Deprecated. Please use clojure.core.matrix/ecount instead.

log clj

(log A)

Returns the natural log of the elements in the given matrix, sequence or number. Equivalent to R's log function.

log10 clj

(log10 A)

Returns the log base 10 of the elements in the given matrix, sequence or number. Equivalent to R's log10 function.

log2 clj

(log2 A)

Returns the log base 2 of the elements in the given matrix, sequence or number. Equivalent to R's log2 function.

matrix clj

(matrix data)

(matrix data ncol)

(matrix init-val rows cols)

Returns a matrix or vector, in a valid core.matrix format. You can use the slices function to access the rows.

Equivalent to R's matrix function.

Examples: (def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) ; produces a 3x3 matrix (def A2 (matrix [1 2 3 4 5 6 7 8 9] 3)) ; produces the same 3x3 matrix (def B (matrix [1 2 3 4 5 6 7 8 9])) ; produces a vector with 9 elements

; since (plus row1 row2) adds the two rows element-by-element (reduce plus A) ; produces the sums of the columns

; and since (sum row1) sums the elements of the row (map sum A) ; produces the sums of the rows

matrix-map clj deprecated

(matrix-map f m)

(matrix-map f m & ms)

Like clojure.core/map, but will work on matrices of any dimension: 1 x 1 (like e.g. a Double), 1 x n, n x 1, and n x m

Examples: (use '(incanter core)) (def mat (matrix (range 9) 3)) (matrix-map #(mod % 2) mat) (matrix-map #(mod % 2) (first mat)) (matrix-map #(mod % 2) ($ 1 0 mat)) (matrix-map #(mod % 2) [1 2 3 4]) (matrix-map #(mod % 2) 9)

Deprecated. Please use clojure.core.matrix/emap instead.

matrix? clj

(matrix? obj)

Tests if obj is core.matrix matrix

melt clj

(melt dataset pivot-key)

Melt an object into a form suitable for easy casting, like a melt function in R. Only accepts one pivot key for now. e.g.

(use '(incanter core charts datasets)) (view (with-data (melt (get-dataset :flow-meter) :Subject) (line-chart :Subject :value :group-by :variable :legend true)))

See http://www.statmethods.net/management/reshape.html for more examples.

minus clj deprecated

(minus & args)

Performs element-by-element subtraction on multiple matrices, sequences and/or numbers. If only a single argument is provided, returns the negative of the given matrix, sequence, or number. Equivalent to R's - operator.

Examples: (def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (minus A) (minus A A A) (minus A 2) (minus 2 A) (minus [1 2 3] [1 2 3]) (minus [1 2 3] 2) (minus 2 [1 2 3]) (minus [1 2 3])

Deprecated. Please use clojure.core.matrix/sub or clojure.core.matrix.operators/- instead.

mmult clj deprecated

(mmult & args)

Returns the matrix resulting from the matrix multiplication of the the given arguments. Equivalent to R's %*% operator.

Examples:

(def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (mmult A (trans A)) (mmult A (trans A) A)

References: http://en.wikipedia.org/wiki/Matrix_multiplication

Deprecated. Please use clojure.core.matrix/mmul instead.

mult clj deprecated

(mult & args)

Performs element-by-element multiplication on multiple matrices, sequences and/or numbers. Equivalent to R's * operator.

Examples:

(def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (mult A A A) (mult A 2) (mult 2 A) (mult [1 2 3] [1 2 3]) (mult [1 2 3] 2) (mult 2 [1 2 3])

Deprecated. Please use clojure.core.matrix/emul or clojure.core.matrix.operators/* instead.

ncol clj multimethod

Returns the number of columns in the given matrix. Equivalent to R's ncol function.

nrow clj multimethod

Returns the number of rows in the given matrix. Equivalent to R's nrow function.

plus clj deprecated

(plus & args)

Performs element-by-element addition on multiple matrices, sequences and/or numbers. Equivalent to R's + operator.

Examples:

(def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (plus A A A) (plus A 2) (plus 2 A) (plus [1 2 3] [1 2 3]) (plus [1 2 3] 2) (plus 2 [1 2 3])

Deprecated. Please use clojure.core.matrix/add or clojure.core.matrix.operators/+ instead.

pow clj

(pow & args)

This is an element-by-element exponent function, raising the first argument by the exponents in the remaining arguments. Equivalent to R's ^ operator.

prod clj

(prod x)

Returns the product of the given sequence.

proj clj

(proj u v)

query-dataset clj

(query-dataset data query-map)

Queries the given dataset using the query-map, returning a new dataset. The query-map uses the the dataset's column-names as keys and a simple variant of the MongoDB query language.

For instance, given a dataset with two columns, :x and :category, to query for rows where :x equals 10, use the following query-map: {:x 10}.

To indicate that :x should be between 10 and 20, use {:x {:$gt 10 :$lt 20}}.

To indicate that :category should also be either :red, :green, or :blue, use :$in {:x {:$gt 10 :$lt 20} :y {:$in #{:green :blue :red}}}

And to indicate that :category should not include :red, :green, or :blue, use :$nin {:x {:$gt 10 :$lt 20} :y {:$nin #{:green :blue :red}}}

The available query terms include :$gt, :$lt, :$gte, :$lte, :$eq, :$ne, :$in, :$nin, $fn.

A row predicate function can be used instead of a query-map. The function must accept a map, representing a row of the dataset, and return a boolean value indicating whether the row should be included in the new dataset.

Examples: (use '(incanter core datasets)) (def cars (get-dataset :cars))

(view (query-dataset cars {:speed 10})) (view (query-dataset cars {:speed {:$in #{17 14 19}}})) (view (query-dataset cars {:speed {:$lt 20 :$gt 10}})) (view (query-dataset cars {:speed {:$fn #(> (log %) 3)}}))

;; use a row predicate function instead of a query map. (view (query-dataset cars (fn [row] (> (/ (row "speed") (row "dist")) 1/2)))) (assoc data :rows (for [row (:rows data) :when (query-map row)] row))

query-to-pred clj

(query-to-pred query-map)

Given a query-map, it returns a function that accepts a hash-map and returns true if it satisfies the conditions specified in the provided query-map.

Examples:

(use 'incanter.core) (def pred (query-to-pred {:x 5 :y 7})) (pred {:x 5 :y 7 :z :d})

(def pred (query-to-pred {:x 5 :y {:$gt 5 :$lt 10}})) (pred {:x 5 :y 7 :z :d})

(def pred (query-to-pred {:z {:$in #{:a :b}}})) (pred {:x 5 :y 7 :z :d})

quit clj

(quit)

Exits the Clojure shell.

rank clj deprecated

(rank mat)

Returns the effective numerical matrix rank, which is the number of nonnegligible singular values.

Examples:

(use 'incanter.core) (def foo (matrix (range 9) 3)) (rank foo)

References: http://en.wikipedia.org/wiki/Matrix_rank

Deprecated. Please use clojure.core.matrix.linear/rank instead.

regularized-beta clj

(regularized-beta x a b)

Returns the regularized incomplete beta value. Equivalent to R's pbeta function.

References: http://incanter.org/docs/parallelcolt/api/cern/jet/stat/tdouble/Gamma.html http://en.wikipedia.org/wiki/Regularized_incomplete_beta_function http://mathworld.wolfram.com/RegularizedBetaFunction.html

rename-cols clj

(rename-cols col-map)

(rename-cols col-map data)

Rename columns based on col-map of old-col new-col-name pairs. If old-col is a number it is taken as a 0 based index for the column to replace

Example: (use '(incanter core datasets)) (rename-cols {:Sepal.Length :s.length 3 :p.width} (get-dataset :iris))

reorder-columns clj deprecated

(reorder-columns ds cols)

Produce a new dataset with the columns in the specified order. Returns nil if no valid column names are given.

Deprecated. Please use clojure.core.matrix.dataset/select-columns instead

replace-column clj

(replace-column column-name values)

(replace-column column-name values data)

Replaces a column in a dataset with new values.

safe-div clj

(safe-div x)

(safe-div x y)

(safe-div x y & more)

DivideByZero safe alternative to clojures / function, detects divide by zero and returns Infinity, -Infinity or NaN as appropriate.

save clj multimethod

Save is a multi-function that is used to write matrices, datasets and charts (in png format) to a file.

Arguments: obj -- is a matrix, dataset, or chart object filename -- the filename to create.

Matrix and dataset options: :delim (default ,) column delimiter :header (default nil) an sequence of strings to be used as header line for matrices the default value is nil, for datasets, the default is the dataset's column-names array. :append (default false) determines whether this given file should be appended to. If true, a header will not be written to the file again. If the filename is exactly "-" then out the matrix/dataset will be written to out

Chart options: :width (default 500) :height (default 400)

Matrix Examples:

(use '(incanter core io)) (def A (matrix (range 12) 3)) ; creates a 3x4 matrix (save A "A.dat") ; writes A to the file A.dat, with no header and comma delimited (save A "A.dat" :delim \tab) ; writes A to the file A.dat, with no header and tab delimited

;; writes A to the file A.dat, with a header and tab delimited (save A "A.dat" :delim , :header ["col1" "col2" "col3"])

Dataset Example:

(use '(incanter core io datasets)) ;; read the iris sample dataset, and save it to a file. (def iris (get-dataset :iris)) (save iris "iris.dat")

Chart Example:

(use '(incanter core io stats charts)) (save (histogram (sample-normal 1000)) "hist.png")

;; chart example using java.io.OutputStream instead of filename (use '(incanter core stats charts)) (import 'java.io.FileOutputStream) (def fos (FileOutputStream. "/tmp/hist.png")) (def hist (histogram (sample-normal 1000))) (save hist fos) (.close fos)

(view "file:///tmp/hist.png")

sel clj multimethod

Returns an element or subset of the given matrix, dataset, or list. If the column or row is specified as an atomic object (index or name), then the result will be returned as a list (only values from selected column or row).

Argument: a matrix object, dataset, or list.

Options: :rows (default true) returns all rows by default, can pass a row index or sequence of row indices :cols (default true) returns all columns by default, can pass a column index or sequence of column indices :except-rows (default nil) can pass a row index or sequence of row indices to exclude :except-cols (default nil) can pass a column index or sequence of column indices to exclude :filter-fn (default nil) a function can be provided to filter the rows of the matrix

Examples: (use 'incanter.datasets) (def iris (to-matrix (get-dataset :iris))) (sel iris 0 0) ; first element (sel iris :rows 0 :cols 0) ; also first element (sel iris :cols 0) ; first column of all rows (sel iris :cols [0 2]) ; first and third column of all rows (sel iris :rows (range 10) :cols (range 2)) ; first two columns of the first 10 rows (sel iris :rows (range 10)) ; all columns of the first 10 rows

;; exclude rows or columns (sel iris :except-rows (range 10)) ; all columns of all but the first 10 rows (sel iris :except-cols 1) ; all columns except the second

;; return only the first 10 even rows (sel iris :rows (range 10) :filter-fn #(even? (int (nth % 0)))) ;; select rows where distance (third column) is greater than 50 (sel iris :filter #(> (nth % 2) 4))

;; examples with datasets (use 'incanter.datasets) (def us-arrests (get-dataset :us-arrests)) (sel us-arrests :cols "State") (sel us-arrests :cols :State)

(sel us-arrests :cols ["State" "Murder"]) (sel us-arrests :cols [:State :Murder])

set-current-implementation clj

(set-current-implementation imp)

set-data clj multimethod

Examples:

(use '(incanter core charts datasets))

(def data (get-dataset :iris)) (def table (data-table data)) (view table) ;; now view only a subset of the data (set-data table ($where {:Petal.Length {:gt 6}} data))

;; use sliders to dynamically select the query values (let [data (get-dataset :iris) table (data-table data)] (view table) (sliders [species ["setosa" "virginica" "versicolor"] min-petal-length (range 0 8 0.1)] (set-data table ($where {:Species species :Petal.Length {:gt min-petal-length}} data))))

sin clj

(sin A)

Returns the sine of the elements in the given matrix, sequence or number. Equivalent to R's sin function.

solve clj deprecated

(solve A)

(solve A B)

Returns a matrix solution if A is square, least squares solution otherwise. Equivalent to R's solve function.

Examples: (solve (matrix [[2 0 0] [0 2 0] [0 0 2]]))

References: http://en.wikipedia.org/wiki/Matrix_inverse

Deprecated. Please use clojure.core.matrix/inverse for matrix inverse, clojure.core.matrix.linear/solve for solving system of linear equations and clojure.core.matrix.linear/least-squares for least-squares solution.

solve-quadratic clj

(solve-quadratic a b c)

Returns a vector with the solution to x from the quadratic equation, ax^2 + bx + c.

Arguments: a, b, c: coefficients of a qaudratic equation.

Examples: ;; -2x^2 + 7x + 15 (quadratic-formula -2 7 15) ;; x^2 + -2*x + 1 (quadratic-formula 1 -2 1)

References: http://en.wikipedia.org/wiki/Quadratic_formula

sq clj

(sq A)

Returns the square of the elements in the given matrix, sequence or number. Equivalent to R's sq function.

sqrt clj

(sqrt A)

Returns the square-root of the elements in the given matrix, sequence or number. Equivalent to R's sqrt function.

string-to-categorical clj

(string-to-categorical dataset column-idx dummies?)

sum clj deprecated

(sum x)

Returns the sum of the given sequence.

Deprecated. Please use clojure.core.matrix/esum instead.

sum-of-squares clj deprecated

(sum-of-squares x)

Returns the sum-of-squares of the given sequence.

Deprecated. Please use clojure.core.matrix/length-squared instead.

symmetric-matrix clj

(symmetric-matrix data & {:keys [lower] :or {lower true}})

Returns a symmetric matrix from the given data, which represents the lower triangular elements ordered by row. This is not the inverse of half-vectorize which returns a vector of the upper-triangular values, unless the :lower option is set to false.

Options: :lower (default true) -- lower-triangular. Set :lower to false to reverse the half-vectorize function.

Examples:

(use 'incanter.core) (symmetric-matrix [1 2 3 4 5 6 7 8 9 10])

(half-vectorize (symmetric-matrix [1 2 3 4 5 6 7 8 9 10] :lower false))

tail clj

(tail mat)

(tail len mat)

Returns the tail of the dataset. 10 or full dataset by default.

tan clj

(tan A)

Returns the tangent of the elements in the given matrix, sequence or number. Equivalent to R's tan function.

to-dataset clj

(to-dataset obj & {:keys [transpose]})

Returns a dataset containing the given values.

Examples:

(use 'incanter.core) (to-dataset 1) (to-dataset :a) (to-dataset [:a]) (to-dataset (range 10)) (to-dataset (range 10) :transpose true) (to-dataset [[1 2] [3 4] [5 6]]) (to-dataset {:a 1 :b 2 :c 3}) (to-dataset {"a" 1 "b" 2 "c" 3}) (to-dataset [{:a 1 :b 2} {:a 1 :b 2}]) (to-dataset [{"a" 1 "b" 2 "c" 3} {"a" 1 "b" 2 "c" 3}])

to-dummies clj

(to-dummies coll)

to-labels clj

(to-labels coll cat-var)

to-levels clj

(to-levels coll & options)

to-list clj multimethod

Returns a list-of-vectors if the given matrix is two-dimensional and a flat list if the matrix is one-dimensional.

to-map clj multimethod

Takes a dataset or matrix and returns a hash-map where the keys are keyword versions of the column names, for datasets, or numbers, for matrices, and the values are sequence of the column values.

Examples: (use '(incanter core datasets))

(to-map (get-dataset :cars))

(to-map (matrix (range 9) 3))

to-matrix clj

(to-matrix dataset & {:keys [dummies] :or {dummies false}})

Converts a dataset into a matrix. Equivalent to R's as.matrix function for datasets.

Options: :dummies (default false) -- if true converts non-numeric variables into sets of binary dummy variables, otherwise converts them into numeric codes.

to-vect clj

(to-vect a)

Converts an array into nested Clojure vectors.

Returns a vector-of-vectors if the given matrix is two-dimensional and a flat vector if the matrix is one-dimensional. This is a bit slower than the to-list function

to-vector clj

toeplitz clj

(toeplitz x)

Returns the Toeplitz matrix for the given vector, which form the first row of the matrix

trace clj deprecated

(trace mat)

Returns the trace of the given matrix.

References: http://en.wikipedia.org/wiki/Matrix_trace

Deprecated. Please use clojure.core.matrix/trace instead.

trans clj deprecated

(trans mat)

Returns the transpose of the given matrix. Equivalent to R's t function

Examples: (def A (matrix [[1 2 3] [4 5 6] [7 8 9]])) (trans A)

Deprecated. Please use clojure.core.matrix/transpose instead.

transform-col clj deprecated

(transform-col dataset column f & args)

Apply function f & args to the specified column of dataset and replace the column with the resulting new values.

Deprecated. Please use clojure.core.matrix.dataset/update-column instead.

vec? clj

(vec? obj)

Tests if obj is core.matrix vector

vector-length clj deprecated

(vector-length u)

vectorize clj

(vectorize mat)

Returns the vectorization (i.e. vec) of the given matrix. The vectorization of an m-by-n matrix A, denoted by vec(A) is the m*n-by-1 column vector obtain by stacking the columns of the matrix A on top of one another.

For instance: (= (vectorize (matrix [[a b] [c d]])) (matrix [a c b d]))

Examples: (def A (matrix [[1 2] [3 4]])) (vectorize A)

References: http://en.wikipedia.org/wiki/Vectorization_(mathematics)

view clj multimethod

This is a general 'view' function. When given an Incanter matrix/dataset or a Clojure numeric collection, it will display it in a Java Swing JTable. When given an Incanter chart object, it will display it in a new window. When given a URL string, it will open the location with the platform's default web browser.

When viewing charts, a :width (default 500) and :height (default 400) option can be provided.

When viewing an incanter.processing sketch, set the :exit-on-close option to true (default is false) to kill the animation processes when you close the window (this will also kill your REPL or Swank server), otherwise those processing will continue to run in the background.

Examples:

(use '(incanter core stats datasets charts))

;; view matrices (def rand-mat (matrix (sample-normal 100) 4)) (view rand-mat)

;; view numeric collections (view [1 2 3 4 5]) (view (sample-normal 100))

;; view Incanter datasets (view (get-dataset :iris))

;; convert dataset to matrix, changing Species names to numeric codes (view (to-matrix (get-dataset :iris)))

;; convert dataset to matrix, changing Species names to dummy variables (view (to-matrix (get-dataset :iris) :dummies true))

;; view a chart (view (histogram (sample-normal 1000)) :width 700 :height 700)

;; view a URL (view "http://incanter.org")

;; view a PNG file (save (histogram (sample-normal 1000)) "/tmp/norm_hist.png") (view "file:///tmp/norm_hist.png")

with-data clj/s macro

(with-data data-binding & body)

Binds the given data to $data and executes the body. Typically used with the $ and $where functions.

Examples: (use '(incanter core stats charts datasets))

(with-data (get-dataset :cars) (def lm (linear-model ($ :dist) ($ :speed))) (doto (scatter-plot ($ :speed) ($ :dist)) (add-lines ($ :speed) (:fitted lm)) view))

;; create a dataset where :speed greater than 10 or less than -10 (with-data (get-dataset :cars) (view (-> ($where {:speed {:$gt 20}}) (conj-rows ($where {:speed {:$lt 10}})))))