Prepare cljc files

Engelberg · Engelberg · commit ff5c70e41c90 · 2017-01-05T22:57:28.000-08:00
diff --git a/README.md b/README.md
@@ -9,7 +9,7 @@ sequences for common combinatorial functions.
 Releases and Dependency Information
 ========================================
 
-Latest stable release: 0.1.3
+Latest stable release: 0.1.4
 
 * [All Released Versions](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.clojure%22%20AND%20a%3A%22math.combinatorics%22)
 
@@ -18,7 +18,7 @@ Latest stable release: 0.1.3
 [Leiningen](https://github.com/technomancy/leiningen) dependency information:
 
 ```clojure
-[org.clojure/math.combinatorics "0.1.3"]
+[org.clojure/math.combinatorics "0.1.4"]
 ```
 
 [Maven](http://maven.apache.org/) dependency information:
@@ -159,9 +159,12 @@ Developer Information
 
 Changelog
 ========================================
+* Release 0.1.4 om 2017-01-06
+  * Support for clojurescript
+
 * Release 0.1.3 on 2016-06-02
   * Changed boxing to use Long/valueOf.
-  
+
 * Release 0.1.2 on 2016-05-18
   * Added explicit boxing to eliminate auto-boxing warnings.
     No change in functionality or performance from previous release.
diff --git a/src/main/clojure/clojure/math/combinatorics.cljc b/src/main/clojure/clojure/math/combinatorics.cljc
@@ -2,15 +2,15 @@
 ;;; sequences for common combinatorial functions.
 
 ;; by Mark Engelberg (mark.engelberg@gmail.com)
-;; Last updated - May 18, 2016
+;; Last updated - Jan 6, 2017
 
 (ns
   #^{:author "Mark Engelberg",
      :doc "Efficient, functional algorithms for generating lazy
 sequences for common combinatorial functions. (See the source code 
 for a longer description.)"}
   clojure.math.combinatorics
-  (:refer-clojure :exclude [update]))
+  (:refer-clojure :exclude [update]))
 
 (comment
 "  
@@ -88,17 +88,6 @@ to write our own version that considers the empty-list to be distinct"
     (apply distinct? s)
     true))
 
-(defmacro assert-with-message
-  "Clojure 1.2 didn't allow asserts with a message, so we roll our own here for backwards compatibility"
-  [x message]
-  (when *assert*
-    `(when-not ~x
-       (throw (new AssertionError (str "Assert failed: " ~message "\n" (pr-str '~x)))))))
-
-;; so this code works with both 1.2.x and 1.3.0:
-(def ^{:private true} plus (first [+' +]))
-(def ^{:private true} mult (first [*' *]))
-
 (defn- index-combinations
   [n cnt]
   (lazy-seq
@@ -310,7 +299,7 @@ In prior versions of the combinatorics library, there were two similar functions
   {:pre [(integer? n) (not (neg? n))]}
   ; (Long/valueOf (long 1)) eliminates loop auto-boxing warning, in a way compatible with Clojure 1.2
   (loop [acc (Long/valueOf (long 1)), n n] 
-    (if (zero? n) acc (recur (mult acc n) (dec n)))))
+    (if (zero? n) acc (recur (*' acc n) (dec n)))))
 
 (defn- factorial-numbers
   "Input is a non-negative base 10 integer, output is the number in the
@@ -333,9 +322,8 @@ expressed as a list of 'digits'"
   "Input should be a sorted sequential collection l of distinct items, 
 output is nth-permutation (0-based)"
   [l n]
-  (assert-with-message (< n (factorial (count l))) 
-                       (format "%s is too large. Input has only %s permutations."
-                               (str n) (str (factorial (count l)))))
+  (assert (< n (factorial (count l)))
+          (print-str n "is too large. Input has only" (factorial (count l)) "permutations."))
   (let [length (count l)
         fact-nums (factorial-numbers n)]
     (loop [indices (concat (repeat (- length (count fact-nums)) 0)
@@ -413,10 +401,9 @@ Output is a list of 'digits' in this wacky duplicate factorial number system"
 (defn- nth-permutation-duplicates
   "Input should be a sorted sequential collection l of distinct items, 
 output is nth-permutation (0-based)"
-  [l n]
-  (assert-with-message (< n (count-permutations l)) 
-                       (format "%s is too large. Input has only %s permutations."
-                               (str n) (str (count-permutations l))))
+  [l n]
+  (assert (< n (count-permutations l))
+          (print-str n "is too large. Input has only" (count-permutations l) "permutations."))
   (loop [freqs (into (sorted-map) (frequencies l)),
          indices (factorial-numbers-with-duplicates n freqs)
          perm []]
@@ -480,8 +467,8 @@ output is nth-permutation (0-based)"
     (zero? k) 1
     (= k 1) n
     (> k (quot n 2)) (recur n (- n k))
-    :else (/ (apply mult (range (inc (- n k)) (inc n)))
-             (apply mult (range 1 (inc k))))))
+    :else (/ (apply *' (range (inc (- n k)) (inc n)))
+             (apply *' (range 1 (inc k))))))
 
 (defn- ^{:dynamic true} count-combinations-from-frequencies [freqs t]
   (let [counts (vals freqs)
@@ -495,7 +482,7 @@ output is nth-permutation (0-based)"
       (= (count freqs) 1) 1
       :else
       (let [new-freqs (dec-key freqs (first (keys freqs)))]
-        (plus (count-combinations-from-frequencies new-freqs (dec t))
+        (+' (count-combinations-from-frequencies new-freqs (dec t))
               (count-combinations-from-frequencies (dissoc freqs (first (keys freqs))) t))))))
 
 (defn- count-combinations-unmemoized
@@ -516,16 +503,16 @@ so that we can memoize over a series of calls."
   (loop [n pow, y (Long/valueOf (long 1)), z base]
     (let [t (even? n), n (quot n 2)]
       (cond
-       t (recur n y (mult z z))
-       (zero? n) (mult z y)
-       :else (recur n (mult z y) (mult z z))))))
+       t (recur n y (*' z z))
+       (zero? n) (*' z y)
+       :else (recur n (*' z y) (*' z z))))))
 
 (defn- count-subsets-unmemoized
   [items]
   (cond 
     (empty? items) 1
     (all-different? items) (expt-int 2 (count items))
-    :else (apply plus (for [i (range 0 (inc (count items)))]
+    :else (apply +' (for [i (range 0 (inc (count items)))]
                         (count-combinations-unmemoized items i)))))
 
 (defn count-subsets
@@ -569,9 +556,9 @@ represented by freqs"
 (defn nth-combination
   "The nth element of the sequence of t-combinations of items"
   [items t n]
-  (assert-with-message (< n (count-combinations items t))
-                       (format "%s is too large. Input has only %s combinations."
-                               (str n) (str (count-combinations-unmemoized items t))))
+  (assert (< n (count-combinations items t))
+          (print-str n "is too large. Input has only" 
+                     (count-combinations-unmemoized items t) "combinations."))
   (if (all-different? items)
     (nth-combination-distinct items t n)
     (binding [count-combinations-from-frequencies (memoize count-combinations-from-frequencies)]
@@ -585,9 +572,8 @@ represented by freqs"
 
 (defn nth-subset
   [items n]
-  (assert-with-message (< n (count-subsets items))
-                       (format "%s is too large. Input has only %s subsets."
-                               (str n) (str (count-subsets items))))
+  (assert (< n (count-subsets items))
+          (print-str n "is too large. Input has only" (count-subsets items) "subsets."))
   (loop [size 0,
          n n]
     (let [num-combinations (count-combinations items size)]
diff --git a/src/test/clojure/clojure/math/test_combinatorics.cljc b/src/test/clojure/clojure/math/test_combinatorics.cljc
@@ -1,6 +1,10 @@
 (ns clojure.math.test-combinatorics
-  (:use clojure.test
-        clojure.math.combinatorics))
+  (:require [clojure.math.combinatorics :refer 
+             [subsets combinations selections permutations cartesian-product
+              partitions nth-permutation permutation-index drop-permutations 
+              count-permutations count-combinations count-subsets 
+              nth-subset nth-combination]]
+          [clojure.test :refer [deftest is are testing run-tests]]))
 
 (deftest test-combinations
   (are [x y] (= x y)
