More type hints, remove clojure.data.avl

project.clj

@@ -61,7 +61,8 @@
                  [hiccup "1.0.5"]                                     ; HTML templating
                  [honeysql "0.8.2"]                                   ; Transform Clojure data structures to SQL
                  [kixi/stats "0.3.8"                                  ; Various statistic measures implemented as transducers
-                  :exclusions [org.clojure/test.check]]
+                  :exclusions [org.clojure/test.check                 ; test.check and AVL trees are used in kixi.stats.random. Remove exlusion if using.
+                               org.clojure/data.avl]]
                  [log4j/log4j "1.2.17"                                ; logging framework
                   :exclusions [javax.mail/mail
                                javax.jms/jms

src/metabase/fingerprinting/stl.clj

@@ -4,37 +4,42 @@
   (:import (com.github.brandtg.stl StlDecomposition StlResult StlConfig)))
 
 (def ^:private setters
-  {:inner-loop-passes           (memfn setNumberOfInnerLoopPasses n)
-   :robustness-iterations       (memfn setNumberOfRobustnessIterations n)
-   :trend-bandwidth             (memfn setTrendComponentBandwidth bw)
-   :seasonal-bandwidth          (memfn setSeasonalComponentBandwidth bw)
-   :loess-robustness-iterations (memfn setLoessRobustnessIterations n)
-   :periodic?                   (memfn setPeriodic periodic?)})
+  {:inner-loop-passes           (memfn ^StlConfig setNumberOfInnerLoopPasses n)
+   :robustness-iterations       (memfn ^StlConfig setNumberOfRobustnessIterations n)
+   :trend-bandwidth             (memfn ^StlConfig setTrendComponentBandwidth bw)
+   :seasonal-bandwidth          (memfn ^StlConfig setSeasonalComponentBandwidth bw)
+   :loess-robustness-iterations (memfn ^StlConfig setLoessRobustnessIterations n)
+   :periodic?                   (memfn ^StlConfig setPeriodic periodic?)})
 
 (defn decompose
   "Decompose time series into trend, seasonal component, and residual."
   ([period ts]
    (decompose period {} ts))
   ([period opts ts]
-   (let [xs                           (map first ts)
-         ys                           (map second ts)
-         preprocess                   (if-let [transform (:transform opts)]
-                                        (partial map transform)
-                                        identity)
-         postprocess                  (if-let [transform (:reverse-transform opts)]
-                                        (partial map transform)
-                                        vec)
-         ^StlDecomposition decomposer (StlDecomposition. period)
-         _                            (reduce-kv (fn [^StlConfig config k v]
-                                                   (when-let [setter (setters k)]
-                                                     (setter config v))
-                                                   config)
-                                                 (.getConfig decomposer)
-                                                 (merge {:inner-loop-passes 100}
-                                                        opts))
-         ^StlResult decomposition     (.decompose decomposer xs (preprocess ys))]
-     {:trend    (postprocess (.getTrend decomposition))
-      :seasonal (postprocess (.getSeasonal decomposition))
-      :residual (postprocess (.getRemainder decomposition))
-      :xs       xs
-      :ys       ys})))
+   (let [xs          (map first ts)
+         ys          (map second ts)
+         preprocess  (if-let [transform (:transform opts)]
+                       (partial map transform)
+                       identity)
+         postprocess (if-let [transform (:reverse-transform opts)]
+                       (partial map transform)
+                       vec)]
+     (transduce identity
+                (let [^StlDecomposition decomposer (StlDecomposition. period)]
+                  (fn
+                    ([] (.getConfig decomposer))
+                    ([_]
+                     (let [^StlResult decomposition (.decompose decomposer
+                                                                xs
+                                                                (preprocess ys))]
+                       {:trend    (postprocess (.getTrend decomposition))
+                        :seasonal (postprocess (.getSeasonal decomposition))
+                        :residual (postprocess (.getRemainder decomposition))
+                        :xs       xs
+                        :ys       ys}))
+                    ([^StlConfig config [k v]]
+                     (when-let [setter (setters k)]
+                       (setter config v))
+                     config)))
+                (merge {:inner-loop-passes 100}
+                       opts)))))