Use primitive-math

Author: valerauko

project.clj

@@ -7,6 +7,7 @@
   :dependencies [[org.clojure/clojure "1.11.1" :scope "provided"]
                  [org.clojure/tools.logging "1.2.4" :exclusions [org.clojure/clojure]]
                  [org.clj-commons/dirigiste "1.0.3"]
+                 [org.clj-commons/primitive-math "1.0.0"]
                  [riddley "0.2.0"]
                  [org.clojure/core.async "1.6.673" :scope "provided"]
                  [potemkin "0.4.6"]]

src/manifold/executor.clj

@@ -1,6 +1,7 @@
 (ns manifold.executor
   (:require
-    [clojure.tools.logging :as log])
+    [clojure.tools.logging :as log]
+    [clj-commons.primitive-math :as p])
   (:import
     [io.aleph.dirigiste
      Executors
@@ -147,7 +148,7 @@
               (Executor.
                 thread-factory
                 (if (and queue-length (pos? queue-length))
-                  (if (<= queue-length 1024)
+                  (if (p/<= queue-length 1024)
                     (ArrayBlockingQueue. queue-length false)
                     (LinkedBlockingQueue. (int queue-length)))
                   (SynchronousQueue. false))
@@ -177,9 +178,9 @@
            :max-threads num-threads
            :controller (reify Executor$Controller
                          (shouldIncrement [_ n]
-                           (< n num-threads))
+                           (p/< n num-threads))
                          (adjustment [_ s]
-                           (- num-threads (.getNumWorkers s)))))))))
+                           (p/- num-threads (.getNumWorkers s)))))))))
 
 (defn utilization-executor
   "Returns an executor which sizes the thread pool according to target utilization, within

src/manifold/time.clj

@@ -6,7 +6,8 @@
     [manifold.executor :as ex]
     [clojure.string :as str]
     [manifold.utils :refer [definterface+]]
-    [potemkin.types :refer [defprotocol+]])
+    [potemkin.types :refer [defprotocol+]]
+    [clj-commons.primitive-math :as p])
   (:import
     [java.util
      Calendar
@@ -23,12 +24,12 @@
 (defn nanoseconds
   "Converts nanoseconds -> milliseconds"
   [^double n]
-  (/ n 1e6))
+  (p// n 1e6))
 
 (defn microseconds
   "Converts microseconds -> milliseconds"
   [^double n]
-  (/ n 1e3))
+  (p// n 1e3))
 
 (defn milliseconds
   "Converts milliseconds -> milliseconds"
@@ -38,27 +39,27 @@
 (defn seconds
   "Converts seconds -> milliseconds"
   [^double n]
-  (* n 1e3))
+  (p/* n 1e3))
 
 (defn minutes
   "Converts minutes -> milliseconds"
   [^double n]
-  (* n 6e4))
+  (p/* n 6e4))
 
 (defn hours
   "Converts hours -> milliseconds"
   [^double n]
-  (* n 36e5))
+  (p/* n 36e5))
 
 (defn days
   "Converts days -> milliseconds"
   [^double n]
-  (* n 864e5))
+  (p/* n 864e5))
 
 (defn hz
   "Converts frequency -> period in milliseconds"
   [^double n]
-  (/ 1e3 n))
+  (p// 1e3 n))
 
 (let [intervals (partition 2 ["d" (days 1)
                               "h" (hours 1)
@@ -75,9 +76,9 @@
           "0s"
           (str/trim s))
         (let [[desc ^double val] (first intervals)]
-          (if (>= n val)
+          (if (p/>= n val)
             (recur
-              (str s (int (/ n val)) desc " ")
+              (str s (int (p// n val)) desc " ")
               (rem n val)
               (rest intervals))
             (recur s n (rest intervals))))))))
@@ -161,7 +162,7 @@
 (defn scheduled-executor->clock [^ScheduledExecutorService e]
   (reify IClock
     (in [_ interval-millis f]
-      (let [^Future scheduled-future (.schedule e f (long (* interval-millis 1e3)) TimeUnit/MICROSECONDS)
+      (let [^Future scheduled-future (.schedule e f (long (p/* interval-millis 1e3)) TimeUnit/MICROSECONDS)
             cancel-fn                (fn []
                                        (.cancel scheduled-future false))]
         cancel-fn))
@@ -173,8 +174,8 @@
         (deliver future-ref
                  (.scheduleAtFixedRate e
                                        ^Runnable (cancel-on-exception f cancel-fn)
-                                       (long (* delay-millis 1e3))
-                                       (long (* period-millis 1e3))
+                                       (long (p/* delay-millis 1e3))
+                                       (long (p/* period-millis 1e3))
                                        TimeUnit/MICROSECONDS))
         cancel-fn))))
 
@@ -190,14 +191,14 @@
      (reify
        IClock
        (in [this interval-millis f]
-         (swap! events update-in [(+ ^double @now interval-millis)] #(conj (or % []) f))
+         (swap! events update-in [(p/+ ^double @now interval-millis)] #(conj (or % []) f))
          (advance this 0))
        (every [this delay-millis period-millis f]
-         (assert (< 0 period-millis))
+         (assert (p/< 0.0 period-millis))
          (let [period    (atom period-millis)
                cancel-fn #(reset! period -1)]
            (->> (with-meta (cancel-on-exception f cancel-fn) {::period period})
-                (.in this (max 0 delay-millis)))
+                (.in this (p/max 0.0 delay-millis)))
            cancel-fn))
 
        IMockClock
@@ -207,7 +208,7 @@
          (let [limit (+ ^double @now ^double time)]
            (loop []
              (if (or (empty? @events)
-                     (< limit ^double (key (first @events))))
+                     (p/< limit ^double (key (first @events))))
                (do
                  (reset! now limit)
                  nil)
@@ -217,7 +218,7 @@
                  (reset! now t)
                  (doseq [f fs]
                    (let [period (some-> f meta ::period deref)]
-                     (when (or (nil? period) (pos? ^double period))
+                     (when (or (nil? period) (p/< 0.0 ^double period))
                        (try
                          (f)
                          (when period (.in this period f))
@@ -281,5 +282,5 @@
   "Schedules no-arg function `f` to be invoked at `timestamp`, which is the milliseconds
    since the epoch.  Returns a deferred representing the returned value of the function
    (unwrapped if `f` itself returns a deferred)."
-  [^double timestamp f]
-  (in (max 0 (- timestamp (System/currentTimeMillis))) f))
+  [^long timestamp f]
+  (in (p/max 0 (p/- timestamp (System/currentTimeMillis))) f))