[cs] fix analysis and quick-cs-subsets functions

Inversions of the intervals were not being accounted.

Author: diegovdc

src/erv/constant_structures/brute_force.cljc

@@ -2,7 +2,7 @@
   "Find constant structures by brute force"
   (:require
    [clojure.math.combinatorics :refer [combinations]]
-   [erv.constant-structures.core :refer [analyze maybe-round]]
+   [erv.constant-structures.core :refer [analyze maybe-rationalize]]
    [erv.utils.conversions :as conv]
    [erv.utils.core :refer [interval]]
    [erv.utils.ratios :refer [ratios->scale]]
@@ -92,7 +92,7 @@
   (let [[deg1 deg2] (sort deg-pair)
         a (:bounded-ratio (nth scale deg1))
         b (:bounded-ratio (nth scale deg2))]
-    (maybe-round (interval a b))))
+    (maybe-rationalize (interval a b) 10)))
 
 (def ^:private memoized-deg-combinations
   (memoize (comp #(map sort %)
@@ -102,22 +102,35 @@
 
 (def ^:private conj-set (fnil conj #{}))
 
+(defn- invert-interval [interval period]
+  (* period (/ 1 interval)))
+
 (defn- quick-check-cs?
   [deg-combinations scale]
-  (reduce
-   (fn [data deg-pair]
-     (let [[deg1 deg2] deg-pair
-           steps (- deg2 deg1)
-           interval (get-interval scale deg-pair)
-           updated-data (update data interval conj-set steps)
-           interval-steps (updated-data interval)]
-       (if (> (count interval-steps) 1)
-         (reduced {})
-         updated-data)))
-   {}
-   deg-combinations))
+  (let [period (-> scale first :bounding-period)
+        size (count scale)]
+    (reduce
+     (fn [data deg-pair]
+       (let [[deg1 deg2] deg-pair
+             steps (- deg2 deg1)
+             interval (get-interval scale deg-pair)
+             inversion-steps (- size steps)
+             inversion (invert-interval interval period)
+             updated-data (-> data
+                              (update interval conj-set steps)
+                              (update inversion conj-set inversion-steps))
+             interval-steps (updated-data interval)]
+         (when (> inversion period)
+           (timbre/error "Error in calculation, `inversion` cannot be larger than period"))
+         (if (> (count interval-steps) 1)
+           (reduced {})
+           updated-data)))
+     {}
+     deg-combinations)))
 
 (defn quick-cs-subsets
+  "Calculate all CS subset of the given sizes.
+  FIXME only really works for JI scales."
   [cs-sizes scale]
   (eduction
    (mapcat #(combinations (range (count scale)) %))

src/erv/constant_structures/core.cljc

@@ -13,22 +13,33 @@
             (round2 6 n))
      :cljs (round2 6 n)))
 
+(defn maybe-rationalize
+  [n decimals]
+  #?(:clj (if (rational? n)
+            n
+            (rationalize (round2 decimals n)))
+     ;; TODO implement
+     :cljs (round2 6 n)))
+
 (defn get-intervals
-  [note-pair]
+  [scale-size note-pair]
   (->> note-pair
        ((fn [[a b]]
-          {(maybe-round (interval (:bounded-ratio a)
-                                  (:bounded-ratio b)))
-           {:steps #{(- (:index b)
-                        (:index a))}
-            :intervals [[a b]]}}))))
+          (let [period (:bounding-period a)
+                intvl (maybe-round (interval (:bounded-ratio a)
+                                             (:bounded-ratio b)))
+                inversion (* period (/ 1 intvl))]
+            {intvl {:steps #{(- (:index b) (:index a))}
+                    :intervals [[a b]]}
+             inversion {:steps #{(- scale-size (- (:index b) (:index a)))}
+                        :intervals [[b a]]}})))))
 
 (defn analyze
   [scale]
   (let [interval-data (->> (combo/combinations
                             (map-indexed #(assoc %2 :index %1) scale)
                             2)
-                           (map get-intervals)
+                           (map (partial get-intervals (count scale)))
                            (apply merge-with (partial merge-with concat))
                            (map (fn [[interval data]]
                                   {interval (update data :steps (partial into #{}))}))
@@ -64,7 +75,7 @@
                          (:scale (cps/make 2 [11 13 5 7]))))
 
 (:constant-structure? (analyze
-                       (:scale (cps/make 2 [1 3 5 7 9]))))
+                       (:scale (cps/make 2 [1 3 5 7]))))
 (:constant-structure? (analyze
                        (:scale (edo/from-pattern [2 2 1 2 2 2 1]))))
 #_(:non-cs-intervals (analyze