Snippet of clojure

precip-in-clojure.clj

(ns precip
  (:use [clojure.math.numeric-tower :only (expt)]))

(defn average [l]
  (float (/
    (reduce + l)
    (count l))))
  
(defn variance [l]
  (let [vmean (average l)]
    (/ (reduce +
              (map #(expt (- % vmean) 2) l))
      (- (count l) 1))))

(defn create-sum-vector [v]
  (loop [sum-vector []
         remaining v]
    (if (empty? remaining)
      sum-vector
      (recur (conj sum-vector (+ (or (last sum-vector) 0)
                                 (first remaining)))
             (rest remaining)))))

(defn create-diff-vector [v start-zero?]
  (into [(if start-zero? 0 (first v))]
    (map - (rest v) v)))

(defn sum [v]
  (reduce + v))
      
(defn sum-where [f s]
  (reduce + (for [v s] (if (f v) v 0))))

(defn get-nonnegative-precip [s]
  (let [total (sum s)
        pos-total (sum-where pos? s)
        adj-factor (if (pos? pos-total)
                     (/ total pos-total)
                     0)
        adjusted #(if (pos? %)
                    (* % adj-factor)
                    0.0)]
    (map adjusted s)))

(defn zero-dry-period [deltas winsize]
  (let [curave (average deltas)
        curvar (variance deltas)
        meetsDrynessCriteria (and (< curave 0.005)
                                  (< curvar 0.00035))
        is-fullsize (>= (count deltas) winsize)]
    
    (if (and is-fullsize
             meetsDrynessCriteria)
      (repeat (count deltas) 0)
      deltas)))
        
(defn zero-dry-periods [deltas winsize]
  (let [chunks (partition winsize deltas)]
    (flatten (for [chunk chunks] (zero-dry-period chunk)))))

(defn zero-on-fn [deltas f control-list]
  "Returns a map from a function which takes a vector of two values"
  (map f (map vector deltas control-list)))

(defn zero-with-wetness-sensor [deltas wetness]
  (defn threshold-fn [[val wet]] (if (> wet 500) 0.0 val))
    (zero-on-fn deltas threshold-fn wetness))

(defn zero-where-flagged [deltas flags]
  (defn flag-fn [[val flag]] (if (zero? flag) val 0.0))
  (zero-on-fn deltas flag-fn flags))

(defn get-means [ss]
  "given a sequence of 3 sequences (say 3 lists of 
   deltas), gives the mean of the 3 at each point
   in the sequence"
  (map #(/ (reduce + %) (count %))
       (partition 3 (apply interleave ss))))
  
(defn seq-variance [s means]
  (defn ind-variance [v m]
    (expt (- v m) 2))
  (map ind-variance s means))

(defn ave-variances [d1 d2 d3]
  (let [means (get-means [d1 d2 d3])]
    (map #(/ (sum (seq-variance % means)) 
             (- (count means) 1)) 
       [d1 d2 d3])))

(defn calculate-wireweights [d1 d2 d3]
  (map
    #(/ 1.0 (max % 0.00001))
    (ave-variances d1 d2 d3)))

(defn remove-giant-events [deltas]
  "construct seq from deltas where seq[i] = deltas[i]
   except if deltas[i] > 25 or deltas[i-1] > 25, seq[i] = 0"
  (defn zero-if-out-of-bounds [s ex]
    (defn zero-fn [v m]
      (if (<= v 25) m 0))
    (map zero-fn s ex))
  (zero-if-out-of-bounds (cons 0 deltas)
                         (zero-if-out-of-bounds deltas deltas)))

(defn round [n precision]
  (let [scale (expt 10 precision)]
    (float (/ (Math/round (* n scale)) scale))))

(defn round-all [s precision]
  (let [round-fn (fn [n] (round n precision))]
    (map round-fn s)))

(defn empty-list [s]
  (repeat (count s) 0))