Clojure Cosine Similarity

cosine_similarity.clj

#?(:clj (defn cosine-similarity [vec1 vec2]
          (let [dot-product (reduce + (map * vec1 vec2))
                magnitude-vec1 (Math/sqrt (reduce + (map #(Math/pow % 2) vec1)))
                magnitude-vec2 (Math/sqrt (reduce + (map #(Math/pow % 2) vec2)))]
            (if (or (zero? magnitude-vec1) (zero? magnitude-vec2))
              0
              (/ dot-product (* magnitude-vec1 magnitude-vec2))))))

#?(:clj (defn double1:dot-product [^double/1 v1 ^double/1 v2]
          (let [n (alength v1)]
            (loop [sum 0.0 idx 0]
              (if (= n idx)
                sum
                (recur (+ (* (aget v1 idx) (aget v2 idx))
                          sum)
                       (inc idx)))))))

#?(:clj (defn double1:magnitude [^double/1 v]
          (let [n (alength v)]
            (loop [sum 0.0 idx 0]
              (if (= n idx)
                sum
                (recur (+ (* (aget v idx) (aget v idx))
                          sum)
                       (inc idx)))))))

#?(:clj (defn double1:cosine-similarity [^double/1 v1 ^double/1 v2]
          (let [dot-product (double1:dot-product v1 v2)
                magnitude-vec1 (double1:magnitude v1)
                magnitude-vec2 (double1:magnitude v2)]
            (if (or (zero? magnitude-vec1) (zero? magnitude-vec2))
              0
              (/ dot-product (Math/sqrt (* magnitude-vec1 magnitude-vec2)))))))

The double-array implementation is somewhat optimised, but could probably be a lot faster :^)