tesser.utils — tesser.core 1.0.4

Toolbox.

append clj

(append coll element)

Appends a single value to the end of a sequence. O(1); uses conj for vectors, concat for other seqs.

chunk-array clj

(chunk-array chunk-size ary)

Partitions an array into reducibles of size chunk-size (like chunk), but faster.

chunk-vec clj

(chunk-vec n v)

Partitions a vector into reducibles of size n (somewhat like partition-all) but uses subvec for speed.

(chunk-vec 2 [1])     ; => ([1])
(chunk-vec 2 [1 2 3]) ; => ([1 2] [3])

Useful for supplying vectors to tesser.core/tesser.

complete-triangular-matrix clj

(complete-triangular-matrix m)

Given a map of [x y] keys to values, returns a map where both [x y] and [y x] point to identical values. Useful for pairwise comparisons which compute triangular matrices but want to return a full matrix.

cumulative-sums clj

(cumulative-sums coll)

(cumulative-sums init coll)

A seq of the cumulative sums of all elements in coll, starting at init or the first element of coll if init is not provided. If differences provides differentials, cumulative-sums provides integrals.

(cumulative-sums 1 [1 2 1 -3])
; (1 2 4 5 2)

def-type-predicate clj macro

(def-type-predicate name exemplar)

Takes an instance of an object and defines a function that tests an object to see if its class is an instance of the exemplar's.

differences clj

(differences coll)

A seq of the differences between successive elements in a collection. For example,

(differences [1 2 4 5 2])
; (1 2 1 -3)

doubles? clj

(doubles? x__1270__auto__)

first-non-nil-reducer clj

(first-non-nil-reducer _ x)

A reducing function that simply returns the first non-nil element in the collection.

floats? clj

(floats? x__1270__auto__)

index-by clj

(index-by f xs)

Given an indexing function f and a collection of xs, return a map of (f x) -> x.

ints? clj

(ints? x__1270__auto__)

longs? clj

(longs? x__1270__auto__)

map-vals clj

(map-vals f m)

Maps over a key-value map, returning a new map by transforming each value with (f v).

maybe-unary clj

(maybe-unary f)

Not all functions used in tesser/fold and tesser/reduce have a single-arity form. This takes a function f and returns a fn g such that (g x) is (f x) unless (f x) throws ArityException, in which case (g x) returns just x.

objects? clj

(objects? x__1270__auto__)

Pair clj protocol

a clj

(a pair)

Returns the first element in the Pair.

b clj

(b pair)

Returns the second element in the Pair.

set-a! clj

(set-a! pair a')

Set the first element in the Pair.

set-b! clj

(set-b! pair b')

Set the second element in the Pair.

set-both! clj

(set-both! pair a' b')

Set both the first and second element in the pair.

path-fn clj

(path-fn path)

Takes a path for get-in and converts it to a function that operates on associative structures.

prepend clj

(prepend coll element)

Prepends a single value to the beginning of a sequence. O(1) for sequences using cons, O(n) for vectors. Returns a singleton vector when coll is nil.

reduce-first clj

(reduce-first reducible)

clojure.core/first, but for for reducibles.

reducible-chunk clj

(reducible-chunk n coll)

Like partition-all, but only emits reducibles. Faster for vectors and arrays. May return chunks of any reducible type. Useful for supplying colls to tesser.

(->> [1 2 3 4 5 6 7 8]
     (chunk 2)
     (map (partial into [])))
; => ([1 2] [3 4] [5 6] [7 8])

reducible-slice clj macro

(reducible-slice getter coll length offset)

A reducible slice of an indexed collection. Expands into a reified CollReduce which uses (getter coll ... i) to return the ith element. Defined as a macro so we can do primitive agets, which are waaaay faster for arrays. Slice will have maximum length n, and starts at index i0.

reducible-slice-bytes clj

(reducible-slice-bytes ary chunk-size offset)

reducible-slice-doubles clj

(reducible-slice-doubles ary chunk-size offset)

reducible-slice-floats clj

(reducible-slice-floats ary chunk-size offset)

reducible-slice-ints clj

(reducible-slice-ints ary chunk-size offset)

reducible-slice-longs clj

(reducible-slice-longs ary chunk-size offset)

reducible-slice-objects clj

(reducible-slice-objects ary chunk-size offset)

reducible-slice-shorts clj

(reducible-slice-shorts ary chunk-size offset)

scred clj macro

(scred rfn-name expr)

Helper for short-circuiting nested reduction functions which can emit reduced values. Given the name of a function that could emit a reduced value, and an expression:

(scred rfn [1 (rfn x y)])

Expands to code that converts the expression to a reduced value whenever the underlying function emits a reduced value:

(let [acc (rfn x y)]
  (if (reduced? acc)
    (let [acc @acc] (reduced [1 acc]))
    [1 acc]))

scred does not interpret lexical scope, so don't rebind rfn in expr. Uses prewalk, so the outermost fn is where scred will cut out an expr. Keep this as simple as possible, haha.

shorts? clj

(shorts? x__1270__auto__)

successive-pairs clj

(successive-pairs coll)

(successive-pairs prev coll)

A much faster version of (partition 2 1 coll) which generates vectors, not lazy seqs.

unsafe-pair clj

(unsafe-pair)

(unsafe-pair a b)

Constructs a new unsynchronized mutable pair object, suitable for single-threaded mutation.

var->sym clj

(var->sym v)

Converts a var to fully qualified symbol.