get 'er done

Author: marke000

deps.edn

@@ -6,8 +6,9 @@
              de.xypron.jcobyla/jcobyla        {:mvn/version "1.4"}
 
              ;;;HIPPARCHUS
-             org.hipparchus/hipparchus-core   {:mvn/version "4.0.2"}
-             org.hipparchus/hipparchus-optim  {:mvn/version "4.0.2"}
+             org.hipparchus/hipparchus-core    {:mvn/version "4.0.2"}
+             org.hipparchus/hipparchus-optim   {:mvn/version "4.0.2"}
+             org.hipparchus/hipparchus-fitting {:mvn/version "4.0.2"}
 
              ;;;PROVISDOM
              provisdom/math                   {:local/root "../math"}

src/provisdom/solvers/anomalies.clj

@@ -0,0 +1,148 @@
+(ns provisdom.solvers.common
+  "Common utilities, specs, and anomaly categories for solvers.
+  Consolidates shared functionality used across multiple solver implementations."
+  (:require
+    [clojure.spec.alpha :as s]
+    [clojure.spec.gen.alpha :as gen]
+    [provisdom.math.core :as m]
+    [provisdom.math.vector :as vector]))
+
+;;;SOLVER ANOMALY CATEGORIES
+;; These extend the base anomaly system with solver-specific categories.
+;; Use these as the value for ::anomalies/category in anomaly maps.
+(s/def ::solver-category
+  #{::bad-supplied-function   ; user-provided function has issues (wrong arity, throws, returns invalid values)
+    ::max-iterations-exceeded ; solver hit iteration limit without converging
+    ::not-bracketed           ; root not bracketed (for bracketing root solvers)
+    ::singular-matrix         ; matrix is singular or ill-conditioned
+    ::out-of-bounds           ; query point outside valid interpolation range
+    ::diverged                ; algorithm diverged (rounding errors, etc.)
+    ::invalid-input})         ; input violates solver requirements
+
+;;;CONSTANTS
+(def accu-precision
+  "Minimum precision for accuracy parameters. Values below this are treated as zero by some solvers
+  (e.g., Hipparchus)."
+  9e-16)
+
+(def mdl
+  "Max dimension length for generators."
+  6)
+
+;;;ARRAY HELPERS
+(defn double-array?
+  "Tests if a value is a double array."
+  [x]
+  (instance? (Class/forName "[D") x))
+
+(defn ->array2D
+  "Creates a 2D double array from nested collections."
+  [coll2D]
+  (into-array (Class/forName "[D")
+    (map #(into-array Double/TYPE %) coll2D)))
+
+(defn vec->double-array
+  "Converts a vector to a double array."
+  [v]
+  (double-array v))
+
+;;;COMMON SPECS
+(s/def ::double-array
+  (s/with-gen
+    double-array?
+    #(gen/fmap double-array (gen/vector (s/gen ::m/double) 0 mdl))))
+
+(s/def ::max-iter
+  (s/with-gen (s/nilable ::m/int+)
+    #(gen/one-of [(s/gen (s/int-in 100 1000))
+                  (gen/return nil)])))
+
+(s/def ::max-evaluations
+  (s/with-gen (s/nilable ::m/int+)
+    #(gen/one-of [(s/gen (s/int-in 100 1000))
+                  (gen/return nil)])))
+
+(s/def ::rel-accu
+  (s/with-gen (s/and ::m/finite+
+                (fn [x] (>= x accu-precision)))
+    #(s/gen (s/double-in :min accu-precision
+              :max 1.0
+              :NaN? false))))
+
+(s/def ::abs-accu
+  (s/with-gen (s/and ::m/finite+
+                (fn [x] (>= x accu-precision)))
+    #(s/gen (s/double-in :min accu-precision
+              :max 1.0
+              :NaN? false))))
+
+(s/def ::goal #{:min :max})
+(s/def ::value ::m/number)
+(s/def ::vector-point ::vector/vector)
+(s/def ::value-and-vector-point (s/keys :req [::vector-point ::value]))
+
+(s/def ::vars-guess
+  (s/and ::vector/vector-finite
+    (fn [v] (pos? (count v)))))
+
+(s/def ::var-lower-bounds ::vector/vector-finite)
+(s/def ::var-upper-bounds ::vector/vector-finite)
+
+(s/def ::check-by-objective? boolean?)
+
+;;; Function type specs - use fn? to avoid orchestra issues with fspecs
+(s/def ::array->number fn?)
+(s/def ::array->vector fn?)
+(s/def ::array->nilable-matrix (s/nilable fn?))
+
+;;;INTERPOLATION-RELATED SPECS
+(s/def ::strictly-ascending-vector-finite
+  (s/with-gen
+    (s/and (s/coll-of ::m/finite
+             :kind clojure.core/vector?
+             :into []
+             :min-count 2)
+      (fn [v]
+        (let [dv (map double v)]
+          (= dv (sort (distinct dv))))))
+    #(gen/bind
+       (gen/vector-distinct
+         (s/gen ::m/finite)
+         {:min-elements 2
+          :max-elements 5})
+       (fn [v]
+         (gen/return (vec (sort v)))))))
+
+(s/def ::x-vals ::strictly-ascending-vector-finite)
+(s/def ::y-vals ::strictly-ascending-vector-finite)
+(s/def ::z-vals ::strictly-ascending-vector-finite)
+
+(s/def ::f-vals
+  (s/with-gen
+    (s/coll-of ::m/finite
+      :kind clojure.core/vector?
+      :into []
+      :min-count 2)
+    #(gen/vector (s/gen ::m/finite) 2 5)))
+
+(s/def ::x-vals-with-f-vals
+  (s/with-gen
+    (s/and (s/keys :req [::x-vals ::f-vals])
+      (fn [{::keys [x-vals f-vals]}]
+        (= (count f-vals) (count x-vals))))
+    #(gen/bind
+       (s/gen ::x-vals)
+       (fn [x]
+         (gen/bind
+           (gen/vector (s/gen ::m/num)
+             (count x))
+           (fn [f-v]
+             (gen/return {::x-vals x
+                          ::f-vals f-v})))))))
+
+(s/def ::bandwidth-for-loess
+  (s/with-gen ::m/open-prob
+    #(s/gen (s/double-in :infinite? false
+              :NaN? false
+              :min 0.25
+              :max 0.5))))