clojure.math.combinatorics

Formerly clojure.contrib.combinatorics.

Efficient, functional algorithms for generating lazy sequences for common combinatorial functions.

Releases and Dependency Information

Latest stable release: 0.1.4

Leiningen dependency information:

clojure [org.clojure/math.combinatorics "0.1.4"]

Maven dependency information:

xml <dependency> <groupId>org.clojure</groupId> <artifactId>math.combinatorics</artifactId> <version>0.1.4</version> </dependency>

Note: If you are using Clojure 1.2 - 1.6, you will need math.combinatorics version 0.1.3.

Example Usage

All functions return lazy sequences.

```clojure (ns example.core (:require [clojure.math.combinatorics :as combo]))

; PERMUTATIONS ; all the unique arrangements of items => (combo/permutations [1 2 3]) ([1 2 3] [1 3 2] [2 1 3] [2 3 1] [3 1 2] [3 2 1])

; Note that permutations intelligently handles duplicate items => (combo/permutations [1 1 2]) ([1 1 2] [1 2 1] [2 1 1])

; These functions are more efficient than calling count, nth, drop ; on the underlying sequence => (combo/count-permutations [1 2 3]) 6 => (combo/count-permutations [1 1 2]) 3 => (combo/nth-permutation [1 2 3] 3) [2 3 1] => (combo/nth-permutation [1 1 2 2] 5) [2 2 1 1] => (combo/drop-permutations [1 2 3] 3) ([2 3 1] [3 1 2] [3 2 1])

; For a sortable collection of items, you can find out where it is ; in the lexicographic sequence of permutations => (combo/permutation-index [\a \b \a \c \a \b]) 16 => (combo/nth-permutation [\a \a \a \b \b \c] 16) [\a \b \a \c \a \b]

; COMBINATIONS ; all the unique ways of taking t different elements from items (combo/combinations [1 2 3] 2) ;;=> ((1 2) (1 3) (2 3))

; Note that combinations intelligently handles duplicate items ; treating the input list as a representation of a 'multiset' => (combo/combinations [1 1 1 2 2] 3) ((1 1 1) (1 1 2) (1 2 2))

; These functions are more efficient than calling count and nth ; on the underlying sequence => (combo/count-combinations [1 1 1 2 2] 3) 3 => (combo/nth-combination [1 2 3 4 5] 2 5) [2 4]

; SUBSETS ; all the subsets of items => (combo/subsets [1 2 3]) (() (1) (2) (3) (1 2) (1 3) (2 3) (1 2 3))

; Note that subsets intelligently handles duplicate items ; treating the input list as a representation of a 'multiset' => (combo/subsets [1 1 2]) (() (1) (2) (1 1) (1 2) (1 1 2))

; These functions are more efficient than calling count and nth ; on the underlying sequence => (combo/count-subsets [1 1 2]) 6 => (combo/nth-subset [1 1 2] 3) [1 1]

; CARTESIAN PRODUCT ; all the ways to take one item from each passed-in sequence => (combo/cartesian-product [1 2] [3 4]) ((1 3) (1 4) (2 3) (2 4))

; SELECTIONS ; all the ways to take n (possibly the same) items from the sequence of items => (combo/selections [1 2] 3) ((1 1 1) (1 1 2) (1 2 1) (1 2 2) (2 1 1) (2 1 2) (2 2 1) (2 2 2))

; PARTITIONS ; all the partitions of items. => (combo/partitions [1 2 3]) (([1 2 3]) ([1 2] [3]) ([1 3] [2]) ([1] [2 3]) ([1] [2] [3]))

; Note that partitions intelligently handles duplicate items => (combo/partitions [1 1 2]) (([1 1 2]) ([1 1] [2]) ([1 2] [1]) ([1] [1] [2]))

; You can also specify a min and max number of partitions (combo/partitions [1 1 2 2] :min 2 :max 3) (([1 1 2] [2]) ([1 1] [2 2]) ([1 1] [2] [2]) ([1 2 2] [1]) ([1 2] [1 2]) ([1 2] [1] [2]) ([1] [1] [2 2])) ```

Refer to docstrings in the clojure.math.combinatorics namespace for additional documentation.

API Documentation

Developer Information

Changelog

License

Distributed under the Eclipse Public License, the same as Clojure.