ummm

gym.clj

(ns gym.core)

(def db
  {:equipment [{:equipment :dumbells
                :weights (vec (range 10 40 2))}
               {:equipment :barbell
                :weights (vec (range 20 300 2.5))}]
   :exercises [{:exercise :dumbell-bench
                :equipment :dumbells}
               {:exercise :squat
                :equipment :barbell}
               {:exercise :press
                :equipment :barbell}
               {:exercise :deadlift
                :equipment :barbell}]
   :rep-ranges [{:range :heavy
                 :reps [5 6 7 8]}
                {:range :light
                 :reps [9 10 11 12]}]
   :rep-maxes [{:reps 1
                :pc 100}
               {:reps 2
                :pc 95}
               {:reps 3
                :pc 92.5}
               {:reps 4
                :pc 90}
               {:reps 5
                :pc 87.5}
               {:reps 6
                :pc 85}
               {:reps 7
                :pc 82.5}
               {:reps 8
                :pc 80}
               {:reps 9
                :pc 77.5}
               {:reps 10
                :pc 75}
               {:reps 11
                :pc 72.5}
               {:reps 12
                :pc 70}]
   :maxes [{:exercise :dumbell-bench
            :max 30}
           {:exercise :squat
            :max 110}
           {:exercise :deadlift
            :max 132.5}
           {:exercise :press
            :max 49}]})

(defn pick
  [op]
  (let [{:keys [src a v f]} op]
    (first (filter #(= (get % a) v) (get db src)))))

(defn exercise [ex rep-range]
  (let [{:keys [max]} (pick {:src :maxes, :a :exercise, :v ex})
        {:keys [equipment]} (pick {:src :exercises, :a :exercise, :v ex})
        {:keys [reps]} (pick {:src :rep-ranges, :a :range, :v rep-range})
        {:keys [weights]} (pick {:src :equipment, :a :equipment, :v equipment})
        exercise (->> (for [r reps
                            w weights
                            :let [{:keys [pc]} (pick {:src :rep-maxes, :a :reps, :v r})
                                  max' (int (* 0.01M pc max))
                                  diff (Math/abs (- w max'))]
                            :let [d (cond (pos? (- w max')) [:over-by diff] (neg? (- w max')) [:under-by diff])]]
                        (merge {:max-reps r
                                :weight w
                                (keyword (str r "RM")) max'}
                               (when d {:diff d})))
                      (sort-by :diff)
                      (first))]
    (as-> exercise $
      (assoc $ :reps (dec (get $ :max-reps)))
      (assoc $ :sets (int (/ (if (= rep-range :heavy) 25 30) (:reps $)))))))

(exercise :press :light) ; => {:max-reps 11, :weight 35.0, :11RM 35, :reps 10, :sets 3}

(def week
  {:monday {:press :light
            :squat :light}
   :tuesday {:dumbell-bench :light
             :deadlift :light}
   :thursday {:press :heavy
              :squat :heavy}
   :friday {:dumbell-bench :heavy
            :deadlift :heavy}})

(defn program []
  (for [[day exercises] week]
    [day (for [[ex rep-range] exercises]
           [ex (exercise ex rep-range)])]))

(program)

;; ->

([:monday
  ([:press {:max-reps 11, :weight 35.0, :11RM 35, :reps 10, :sets 3}]
   [:squat {:max-reps 9, :weight 85.0, :9RM 85, :reps 8, :sets 3}])]
 [:tuesday
  ([:dumbell-bench
    {:max-reps 10, :weight 22, :10RM 22, :reps 9, :sets 3}]
   [:deadlift
    {:max-reps 9,
     :weight 102.5,
     :9RM 102,
     :diff [:over-by 0.5],
     :reps 8,
     :sets 3}])]
 [:thursday
  ([:press {:max-reps 7, :weight 40.0, :7RM 40, :reps 6, :sets 4}]
   [:squat {:max-reps 7, :weight 90.0, :7RM 90, :reps 6, :sets 4}])]
 [:friday
  ([:dumbell-bench
    {:max-reps 5, :weight 26, :5RM 26, :reps 4, :sets 6}]
   [:deadlift
    {:max-reps 5, :weight 115.0, :5RM 115, :reps 4, :sets 6}])])