std.timeseries.compute — xyz.zcaudate/std.timeseries 4.0.1

+aggregation-forms+ clj

+aggregations+ clj

+templates+ clj

apply-template clj

(apply-template [k & rest])

applies the template

(= (apply-template [:s/norm :bench.stats.lag]) (list `/ :bench.stats.lag [:s/max :bench.stats.lag])) => true

compile clj

(compile m)

complies a map of expressions

(compile '{:diff (- [:s/norm :bench.stats.time] [:s/norm :bench.stats.lag])})

compile-aggregates clj

(compile-aggregates aggregates)

compiles the aggregates

(compile-aggregates '{v1 [:s/max :bench.stats.lag]})

compile-form clj

(compile-form form)

compiles the entire form

(compile-form '(- [:s/norm :bench.stats.time] [:s/norm :bench.stats.lag]))

compile-keyword clj

(compile-keyword k)

compiles a single keyword

(compile-keyword :bench.stats.lag) => `(get ~'output (keyword "bench.stats.lag"))

compile-single clj

(compile-single compute)

complise a single fn form

(eval (compile-single '(- [:s/norm :bench.stats.time] [:s/norm :bench.stats.lag]))) => fn?

compute clj

(compute arr exprs)

computes additional values given array

(-> (compute [{:start 10 :output.value 1} {:start 11 :output.value 4} {:start 12 :output.value 1} {:start 13 :output.value 6} {:start 14 :output.value 10.1}] {:t '(* :start 100000000) :t0 [:s/adj :t] :t1 [:s/inv :t0] :output.norm [:s/norm :output.value]}) first) => {:start 10, :output.value 1, :t 1000000000, :t0 0, :t1 400000000, :output.norm 0.09900990099009901}

key-order clj

(key-order m)

(key-order {:output.norm [:s/norm :output.value] :t1 [:s/inv :t0] :t0 [:s/adj :t] :t '(* :start 100000000)}) => [:t :t0 :t1 :output.norm]

key-references clj

(key-references m)

finds all references for the expr map

(key-references {:t '(* :start 100000000) :t0 [:s/adj :t] :t1 [:s/inv :t0] :output.norm [:s/norm :output.value]}) => {:t #{}, :t0 #{:t}, :t1 #{:t0}, :output.norm #{}}

max-fn clj

(max-fn arr)

max function accepting array

middle-fn clj

(middle-fn arr)

middling function

(middle-fn [1 2 3]) => 2

min-fn clj

(min-fn arr)

min function accepting array

range-fn clj

(range-fn arr)

range function accepting array

template? clj

(template? [k & rest])

checks if vector is a template

(template? [:s/norm 1]) => true

wrap-not-nil clj

(wrap-not-nil f)

ensures no null values