API for core - Incanter 1.4.1 (legacy)

by David Edgar Liebke

Full namespace name: incanter.core

Overview

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 Parallel Colt
(http://sites.google.com/site/piotrwendykier/software/parallelcolt)
an extension of the Colt numerics library
(http://acs.lbl.gov/~hoschek/colt/).

Types



Dataset

record

    Fields: [column-names rows]
Protocols:
Interfaces: clojure.lang.IHashEq, clojure.lang.IKeywordLookup, clojure.lang.ILookup, clojure.lang.IObj, clojure.lang.IPersistentMap, java.io.Serializable, java.util.Map

Public Variables and Functions



$

function
Usage: ($ 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])))

    
    
    Source
  


$=

macro
Usage: ($= & 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))

    
    
    Source
  


$data

dynamic var

    
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.

    
    
    Source
  


$fn

macro
Usage: ($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)))

    
    
    Source
  


$group-by

function
Usage: ($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]))

    
    
    Source
  


$join

function
Usage: ($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)))

    
    
    Source
  


$map

function
Usage: ($map fun col-keys data)
       ($map fun col-keys)
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)

  (map (fn [s d] (/ s d)) ($ :speed cars) ($ :speed 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])))

    
    
    Source
  


$order

function
Usage: ($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)))


    
    
    Source
  


$rollup

function
Usage: ($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)))

    
    
    Source
  


$where

function
Usage: ($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}})))))

    
    
    Source
  


->Dataset

function
Usage: (->Dataset column-names rows)
Positional factory function for class incanter.core.Dataset.

    
    
    Source
  


abs

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

    
    
    Source
  


acos

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

    
    
    Source
  


asin

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

    
    
    Source
  


atan

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

    
    
    Source
  


atan2

function
Usage: (atan2 & args)
Returns the atan2 of the elements in the given matrices, sequences or numbers.
Equivalent to R's atan2 function.

    
    
    Source
  


beta

function
Usage: (beta a b)
Equivalent to R's beta function.

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

    
    
    Source
  


bind-columns

function
Usage: (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])

    
    
    Source
  


bind-rows

function
Usage: (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])

    
    
    Source
  


block-diag

function
Usage: (block-diag blocks)
Blocks should be a sequence of matrices.

    
    
    Source
  


block-matrix

function
Usage: (block-matrix blocks)
Blocks should be a nested sequence of matrices. Each element of the sequence should be a block row.

    
    
    Source
  


categorical-var

function
Usage: (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])

    
    
    Source
  


choose

function
Usage: (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) ; => 2,598,960

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

    
    
    Source
  


col-names

function
Usage: (col-names data)
       (col-names data colnames)
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)

  (def renamed-data (col-names data [:x1 :x2]))
  (col-names renamed-data)


 

    
    
    Source
  


condition

function
Usage: (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
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleSingularValueDecompositionDC.html

    
    
    Source
  


conj-cols

function
Usage: (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}))

    
    
    Source
  


conj-rows

function
Usage: (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))

    
    
    Source
  


copy

function
Usage: (copy mat)
Returns a copy of the given matrix.

    
    
    Source
  


cos

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

    
    
    Source
  


cumulative-sum

function
Usage: (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))

    
    
    Source
  


data-table

function
Usage: (data-table data)
Creates a javax.swing.JTable given an Incanter dataset.

    
    
    Source
  


dataset

function
Usage: (dataset column-names & data)
 Returns a map of type incanter.core.dataset constructed from the given column-names and
data. The data is either a sequence of sequences or a sequence of hash-maps.

    
    
    Source
  


dataset?

function
Usage: (dataset? obj)
 Determines if obj is of type incanter.core.Dataset.

    
    
    Source
  


decomp-cholesky

function
Usage: (decomp-cholesky mat)
 Returns the Cholesky decomposition of the given matrix. Equivalent to R's
chol function.

Returns:
  a matrix of the triangular factor (note: the result from
  cern.colt.matrix.linalg.DenseDoubleCholeskyDecomposition is transposed so
  that it matches the result return from R's chol function.



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.
(decomp-cholesky (correlation iris))



References:
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleCholeskyDecomposition.html
  http://en.wikipedia.org/wiki/Cholesky_decomposition

    
    
    Source
  


decomp-eigenvalue

function
Usage: (decomp-eigenvalue mat)
 Returns the Eigenvalue Decomposition of the given matrix. Equivalent to R's eig function.

Returns:
  a map containing:
    :values -- vector of eigenvalues
    :vectors -- the matrix of eigenvectors


Examples:

(use 'incanter.core)
(def foo (matrix (range 9) 3))
(decomp-eigenvalue foo)


References:
  http://en.wikipedia.org/wiki/Eigenvalue_decomposition
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleEigenvalueDecomposition.html

    
    
    Source
  


decomp-lu

function
Usage: (decomp-lu mat)
 Returns the LU decomposition of the given matrix.


Examples:

(use 'incanter.core)
(def foo (matrix (range 9) 3))
(decomp-lu foo)


Returns:
  a map containing:
    :L -- the lower triangular factor
    :U -- the upper triangular factor

References:
  http://en.wikipedia.org/wiki/LU_decomposition
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleLUDecomposition.html

    
    
    Source
  


decomp-qr

function
Usage: (decomp-qr mat & {:keys [type], :or {type :full}})
 Returns the QR decomposition of the given matrix. Equivalent to R's qr function.

Optional parameters:
  :type -- one of :full, :compact.  default is :full
    if :full, returns the full QR decomposition
    if :compact, returns the compact (economy) QR decomposition

Returns:
  a map containing:
    :Q -- orthogonal factors
    :R -- the upper triangular factors

Examples:

(use 'incanter.core)
(def foo (matrix (range 9) 3))
(decomp-qr foo)
(decomp-qr foo :type :full)
(decomp-qr foo :type :compact)

References:
  http://en.wikipedia.org/wiki/QR_decomposition
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DenseDoubleQRDecomposition.html

    
    
    Source
  


decomp-svd

function
Usage: (decomp-svd mat & {:keys [type], :or {type :full}})
 Returns the Singular Value Decomposition (SVD) of the given matrix. Equivalent to
R's svd function.

Optional parameters:
  :type -- one of :full, :compact, or :values.  default is :full
    if :full, returns the full SVD
    if :compact, returns the compact SVD
    if :values, only the singular values are calculated

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))
(decomp-foo foo)
(decomp-foo foo :type :full)
(decomp-foo foo :type :compact)
(decomp-foo foo :type :values)


References:
  http://en.wikipedia.org/wiki/Singular_value_decomposition
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleSingularValueDecompositionDC.html

    
    
    Source
  


deshape

function
Usage: (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))

    
    
    Source
  


det

function
Usage: (det mat)
 Returns the determinant of the given matrix. Equivalent
to R's det function.

References:
  http://en.wikipedia.org/wiki/LU_decomposition
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleLUDecomposition.html

    
    
    Source
  


diag

function
Usage: (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])

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

    
    
    Source
  


diagonal-blocks

function
Usage: (diagonal-blocks matrix partitions)
Partitions should be a sequence of [start,size] pairs.

    
    
    Source
  


dim

function
Usage: (dim mat)
 Returns a vector with the number of rows and columns of the given matrix. 

    
    
    Source
  


div

function
Usage: (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]

    
    
    Source
  


exp

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

    
    
    Source
  


factorial

function
Usage: (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

    
    
    Source
  


gamma

function
Usage: (gamma x)
Equivalent to R's gamma function.

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

    
    
    Source
  


get-categories

function
Usage: (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))

    
    
    Source
  


grid-apply

function
Usage: (grid-apply f x-min x-max y-min y-max)
 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.

    
    
    Source
  


group-on

function
Usage: (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))

    
    
    Source
  


half-vectorize

function
Usage: (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)

    
    
    Source
  


head

function
Usage: (head len mat)
       (head mat)
Returns the head of the dataset. 10 or full dataset by default.

    
    
    Source
  


identity-matrix

function
Usage: (identity-matrix n)
   Returns an n-by-n identity matrix.

Examples:
  (identity-matrix 4)

    
    
    Source
  


incomplete-beta

function
Usage: (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

    
    
    Source
  


kronecker

function
Usage: (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)

    
    
    Source
  


length

function
Usage: (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.

    
    
    Source
  


log

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

    
    
    Source
  


log10

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

    
    
    Source
  


log2

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

    
    
    Source
  


make-unique

function
Usage: (make-unique coll)
       (make-unique coll seen)
Take a sequence of keywords and make them unique by possibly
altering later ones.

    
    
    Source
  


map->Dataset

function
Usage: (map->Dataset m#)
Factory function for class incanter.core.Dataset, taking a map of keywords to field values.

    
    
    Source
  


matrix

function
Usage: (matrix data)
       (matrix data ncol)
       (matrix init-val rows cols)
Returns an instance of an incanter.Matrix, which is an extension of
cern.colt.matrix.tdouble.impl.DenseColDoubleMatrix2D that implements the Clojure
interface clojure.lang.ISeq. Therefore Clojure sequence operations can
be applied to matrices. A matrix consists of a sequence of rows, where
each row is a one-dimensional row matrix. One-dimensional matrices are
in turn, sequences of numbers. 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 9x1 column vector

  (first A) ; produces a row matrix [1 2 3]
  (rest A) ; produces a sub matrix [[4 5 6] [7 8 9]]
  (first (first A)) ; produces 1.0
  (rest (first A)) ; produces a row matrix [2 3]

  ; 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

  ; you can filter the rows using Clojure's filter function
  (filter #(> (nth % 1) 4) A) ; returns the rows where the second column is greater than 4.

References:
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/DoubleMatrix2D.html

    
    
    Source
  


matrix-map

function
Usage: (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)

    
    
    Source
  


matrix?

function
Usage: (matrix? obj)
 Test if obj is 'derived' incanter.Matrix.

    
    
    Source
  


minus

function
Usage: (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])

    
    
    Source
  


mmult

function
Usage: (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
    http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/DoubleMatrix2D.html


    
    
    Source
  


mult

function
Usage: (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])

    
    
    Source
  


plus

function
Usage: (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])

    
    
    Source
  


pow

function
Usage: (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.

    
    
    Source
  


prod

function
Usage: (prod x)
Returns the product of the given sequence.

    
    
    Source
  


query-dataset

function
Usage: (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))))

    
    
    Source
  


query-to-pred

function
Usage: (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})

    
    
    Source
  


quit

function
Usage: (quit)
 Exits the Clojure shell.

    
    
    Source
  


rank

function
Usage: (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
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/decomposition/DoubleSingularValueDecompositionDC.html

    
    
    Source
  


regularized-beta

function
Usage: (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

    
    
    Source
  


save

multimethod
No usage documentation available
 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.

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

    
    
    Source
  


sel

multimethod
No usage documentation available
Returns an element or subset of the given matrix, or dataset.

Argument:
  a matrix object or dataset.

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 (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 #(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])

    
    
    Source
  


separate-blocks

function
Usage: (separate-blocks matrix partitions)
Partitions should be a sequence of [start,size] pairs.

    
    
    Source
  


set-data

multimethod
No usage documentation available

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

    
    
    Source
  


sin

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

    
    
    Source
  


solve

function
Usage: (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

    
    
    Source
  


solve-quadratic

function
Usage: (solve-quadratic a b c)
Returns a vector with the solution to x from the quadratic
equation, a*x^2 + b*x + c.

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

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

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

    
    
    Source
  


sq

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

    
    
    Source
  


sqrt

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

    
    
    Source
  


sum

function
Usage: (sum x)
Returns the sum of the given sequence.

    
    
    Source
  


sum-of-squares

function
Usage: (sum-of-squares x)
Returns the sum-of-squares of the given sequence.

    
    
    Source
  


symmetric-matrix

function
Usage: (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))

    
    
    Source
  


tan

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

    
    
    Source
  


to-dataset

function
Usage: (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}])

    
    
    Source
  


to-labels

function
Usage: (to-labels coll cat-var)

    

    
    
    Source
  


to-levels

function
Usage: (to-levels coll & options)

    

    
    
    Source
  


to-list

multimethod
No usage documentation available
 Returns a list-of-lists if the given matrix is two-dimensional
and a flat list if the matrix is one-dimensional.

    
    
    Source
  


to-map

multimethod
No usage documentation available
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))

    
    
    Source
  


to-matrix

function
Usage: (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.

    
    
    Source
  


to-vect

function
Usage: (to-vect mat)
 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. 

    
    
    Source
  


trace

function
Usage: (trace mat)
 Returns the trace of the given matrix.

References:
  http://en.wikipedia.org/wiki/Matrix_trace
  http://incanter.org/docs/parallelcolt/api/cern/colt/matrix/tdouble/algo/DenseDoubleAlgebra.html

    
    
    Source
  


trans

function
Usage: (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)

    
    
    Source
  


transform-col

function
Usage: (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.

    
    
    Source
  


vectorize

function
Usage: (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)

    
    
    Source
  


view

multimethod
No usage documentation available
 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")

    
    
    Source
  


with-data

macro
Usage: (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}})))))

    
    
    Source
  
Logo & site design by Tom Hickey.
Clojure auto-documentation system by Tom Faulhaber.