diff --git a/Sources/LoopAlgorithm/Glucose/GlucoseEffect.swift b/Sources/LoopAlgorithm/Glucose/GlucoseEffect.swift
index dbcf015..9572f80 100644
--- a/Sources/LoopAlgorithm/Glucose/GlucoseEffect.swift
+++ b/Sources/LoopAlgorithm/Glucose/GlucoseEffect.swift
@@ -8,7 +8,7 @@
 import Foundation
 
 
-public struct GlucoseEffect: GlucoseValue, Equatable {
+public struct GlucoseEffect: GlucoseValue, Equatable, Sendable {
     public let startDate: Date
     public let quantity: LoopQuantity
 
diff --git a/Sources/LoopAlgorithm/Insulin/InsulinMath.swift b/Sources/LoopAlgorithm/Insulin/InsulinMath.swift
index 3e250cf..b78edf3 100644
--- a/Sources/LoopAlgorithm/Insulin/InsulinMath.swift
+++ b/Sources/LoopAlgorithm/Insulin/InsulinMath.swift
@@ -397,41 +397,73 @@ extension Collection where Element == BasalRelativeDose {
             return []
         }
 
-        var lastDate = start
-        var date = start
-        var values = [GlucoseEffect]()
         let unit = LoopUnit.milligramsPerDeciliter
+        let dosesArray = Array(self)
+
+        // Build the list of time points up front. timePoints[i] is the date at
+        // which the cumulative effect through that time is recorded.
+        // increments[i] = effect contribution during (timePoints[i-1], timePoints[i]];
+        // increments[0] = 0 (base case — no doses applied yet at start).
+        var timePoints: [Date] = []
+        do {
+            var d = start
+            while d <= end {
+                timePoints.append(d)
+                d = d.addingTimeInterval(delta)
+            }
+        }
+        let n = timePoints.count
+        guard n > 1 else {
+            return timePoints.map { GlucoseEffect(startDate: $0, quantity: LoopQuantity(unit: unit, doubleValue: 0)) }
+        }
 
-        var value: Double = 0
-        repeat {
-            // Sum effects over doses
-            value = reduce(value) { (value, dose) -> Double in
-                guard date != lastDate else {
-                    return 0
-                }
-
-                // Sum effects over pertinent ISF timeline segments
+        // Parallelize the per-step increments across CPU cores. Each step's
+        // increment depends only on its own (lastDate, date) interval — there's
+        // no cross-step dependency until the final cumsum.
+        var increments = [Double](repeating: 0, count: n)
+
+        // Reduce loop body to a closure-free static-like body to keep
+        // capture/Sendable surface minimal. concurrentPerform's closure isn't
+        // @Sendable, so this is tolerated by the compiler.
+        increments.withUnsafeMutableBufferPointer { incBuf in
+            DispatchQueue.concurrentPerform(iterations: n - 1) { idx in
+                // idx in 0..<n-1 maps to step (idx+1)
+                let i = idx + 1
+                let lastDate = timePoints[i - 1]
+                let date = timePoints[i]
+                var inc = 0.0
                 let isfSegments = insulinSensitivityHistory.filterDateRange(lastDate, date)
-                if isfSegments.count == 0 {
-                    preconditionFailure("ISF Timeline must cover dose absorption duration")
+                if isfSegments.isEmpty {
+                    // Outside ISF coverage; treat increment as 0
+                    incBuf[i] = 0
+                    return
                 }
-                return value + isfSegments.reduce(0, { partialResult, segment in
-                    let start = Swift.max(lastDate, segment.startDate)
-                    let end = Swift.min(date, segment.endDate)
-                    if start != end {
-                        let effect = dose.glucoseEffect(during: DateInterval(start: start, end: end), insulinSensitivity: segment.value.doubleValue(for: unit), delta: delta)
-                        return partialResult + effect
-                    } else {
-                        return partialResult
+                for dose in dosesArray {
+                    for segment in isfSegments {
+                        let segStart = Swift.max(lastDate, segment.startDate)
+                        let segEnd   = Swift.min(date,    segment.endDate)
+                        if segStart != segEnd {
+                            inc += dose.glucoseEffect(
+                                during: DateInterval(start: segStart, end: segEnd),
+                                insulinSensitivity: segment.value.doubleValue(for: unit),
+                                delta: delta
+                            )
+                        }
                     }
-                })
+                }
+                incBuf[i] = inc
             }
+        }
 
-            values.append(GlucoseEffect(startDate: date, quantity: LoopQuantity(unit: unit, doubleValue: value)))
-            lastDate = date
-            date = date.addingTimeInterval(delta)
-        } while date <= end
-
+        // Cumsum + emit GlucoseEffect — fast, single-threaded.
+        var values = [GlucoseEffect]()
+        values.reserveCapacity(n)
+        var running = 0.0
+        for i in 0..<n {
+            running += increments[i]
+            values.append(GlucoseEffect(startDate: timePoints[i],
+                                        quantity: LoopQuantity(unit: unit, doubleValue: running)))
+        }
         return values
     }
 
diff --git a/Sources/LoopAlgorithm/Insulin/PrecomputedInsulinInput.swift b/Sources/LoopAlgorithm/Insulin/PrecomputedInsulinInput.swift
new file mode 100644
index 0000000..23894cf
--- /dev/null
+++ b/Sources/LoopAlgorithm/Insulin/PrecomputedInsulinInput.swift
@@ -0,0 +1,215 @@
+// PrecomputedInsulinInput.swift
+//
+// An optimized input type for callers that evaluate many consecutive
+// predictions sharing the same dose history (e.g., historical back-testing).
+//
+// ┌──────────────────────────────────────────────────────────────────────────┐
+// │ What's expensive in a dense prediction sweep                             │
+// │                                                                          │
+// │  doses.annotated(with: basal)         O(D × B) — ISF-independent        │
+// │  annotated.glucoseEffects(isf:)       O(D × T) — ISF-dependent          │
+// │  Everything else (CGM, carbs, RC…)    per-step, unavoidable              │
+// │                                                                          │
+// │ For a 7-day window at 5-min step (n ≈ 2016 steps per ISF config):        │
+// │                                                                          │
+// │  annotation:  called 2016× without caching → call ONCE, reuse always    │
+// │  effects:     called 2016× per ISF value   → call ONCE per ISF value    │
+// │                                                                          │
+// │ ISF-sweep usage pattern (e.g. 10 multipliers × 2016 steps):             │
+// │                                                                          │
+// │   let base = PrecomputedInsulinInput.annotate(doses: doses, basal: basal)│
+// │   for multiplier in [0.7, 0.8, 0.9, 1.0, 1.1, ...] {                   │
+// │     let scaled = scaledSensitivity(sensitivity, by: multiplier)          │
+// │     let input  = base.withEffects(sensitivity: scaled)  // O(D×T) once  │
+// │     for t in sweepSteps {                                                │
+// │       let result = LoopAlgorithm.generatePrediction(                    │
+// │         start: t, ..., precomputedInsulin: input, ...)  // no annotation │
+// │     }                                                                    │
+// │   }                                                                      │
+// └──────────────────────────────────────────────────────────────────────────┘
+
+import Foundation
+
+// MARK: - Binary search helper
+
+private extension Array {
+    /// Returns the index of the first element where `key` > `date` (after: true)
+    /// or `key` >= `date` (after: false), using binary search.
+    /// Assumes the array is sorted ascending by `key`.
+    func partition<K: Comparable>(index date: K, key: KeyPath<Element, K>, after: Bool) -> Int {
+        var lo = 0, hi = count
+        while lo < hi {
+            let mid = (lo + hi) / 2
+            let k = self[mid][keyPath: key]
+            if after ? k <= date : k < date { lo = mid + 1 } else { hi = mid }
+        }
+        return lo
+    }
+}
+
+// MARK: - PrecomputedInsulinInput
+
+/// Pre-annotated insulin data for use in multi-step prediction sweeps.
+///
+/// **Typical usage — ISF sweep:**
+/// ```swift
+/// // 1. Annotate once (ISF-independent, reused across all multipliers)
+/// let base = PrecomputedInsulinInput.annotate(doses: doses, basal: basal)
+///
+/// // 2. For each ISF value: compute effects once, sweep all time steps
+/// for multiplier in isfMultipliers {
+///     let input = base.withEffects(sensitivity: scale(sensitivity, by: multiplier),
+///                                  from: sweepStart, to: sweepEnd + activityDuration)
+///     for t in sweepSteps {
+///         let prediction = LoopAlgorithm.generatePrediction(
+///             start: t, glucoseHistory: cgm[t], precomputedInsulin: input, ...)
+///     }
+/// }
+/// ```
+///
+/// **Note on `Sendable`:** Not conformed because `BasalRelativeDose` stores
+/// `any InsulinModel`, a non-Sendable existential.  Sweeps run on a single
+/// actor so this is not limiting in practice.
+public struct PrecomputedInsulinInput {
+
+    // MARK: - Stored properties
+
+    /// Doses annotated against the scheduled basal timeline.
+    ///
+    /// ISF-independent — build once with `annotate(doses:basal:)` and reuse
+    /// across every ISF multiplier in a sweep.
+    public var annotatedDoses: [BasalRelativeDose]
+
+    /// Pre-computed glucose-effect timeline for `annotatedDoses` at a
+    /// specific ISF schedule.
+    ///
+    /// When non-nil, `generatePrediction` uses this directly instead of
+    /// calling `glucoseEffects(insulinSensitivityHistory:from:to:)`.
+    ///
+    /// **ISF sweeps:** rebuild this once per multiplier using `withEffects(sensitivity:)`.
+    /// The `annotatedDoses` array is unchanged and does not need to be rebuilt.
+    ///
+    /// **Timeline coverage:** must cover
+    /// `[glucoseHistory.first.startDate, sweepEnd + defaultInsulinActivityDuration]`
+    /// for all steps in the sweep.  Pass a generous `to:` date when calling
+    /// `withEffects(sensitivity:from:to:)`.
+    public var insulinEffects: [GlucoseEffect]?
+
+    // MARK: - Init
+
+    public init(annotatedDoses: [BasalRelativeDose], insulinEffects: [GlucoseEffect]? = nil) {
+        self.annotatedDoses = annotatedDoses
+        self.insulinEffects = insulinEffects
+    }
+}
+
+// MARK: - Factory methods
+
+extension PrecomputedInsulinInput {
+
+    /// **Step 1 of 2 for ISF sweeps.**
+    ///
+    /// Annotates a full-window dose list against the basal timeline once.
+    /// The result can be reused across all ISF multipliers — annotation does
+    /// not depend on ISF.
+    ///
+    /// - Parameters:
+    ///   - doses: All insulin doses for the sweep window, sorted by startDate.
+    ///   - basal: Scheduled basal timeline covering the same window.
+    /// - Returns: A `PrecomputedInsulinInput` with `insulinEffects == nil`.
+    ///   Call `withEffects(sensitivity:from:to:)` before passing to
+    ///   `generatePrediction`.
+    public static func annotate<DoseType: InsulinDose>(
+        doses: [DoseType],
+        basal: [AbsoluteScheduleValue<Double>]
+    ) -> PrecomputedInsulinInput {
+        PrecomputedInsulinInput(annotatedDoses: doses.annotated(with: basal))
+    }
+
+    /// **Step 2 of 2 for ISF sweeps.**
+    ///
+    /// Computes the glucose-effect timeline for the already-annotated doses
+    /// at the given ISF schedule.  Call once per ISF multiplier value; then
+    /// pass the result into every `generatePrediction` call for that multiplier.
+    ///
+    /// - Parameters:
+    ///   - sensitivity: The (possibly scaled) ISF timeline for this sweep config.
+    ///   - from: Start of the effect timeline.  Defaults to earliest dose start.
+    ///     Should be <= `glucoseHistory.first.startDate` for the first eval step.
+    ///   - to: End of the effect timeline.  Should cover
+    ///     `sweepEnd + defaultInsulinActivityDuration` to avoid truncation at
+    ///     the tail of long sweeps.
+    ///   - useMidAbsorptionISF: Use mid-absorption ISF computation.
+    /// - Returns: A new `PrecomputedInsulinInput` with `insulinEffects` populated.
+    public func withEffects(
+        sensitivity: [AbsoluteScheduleValue<LoopQuantity>],
+        from: Date? = nil,
+        to: Date? = nil,
+        useMidAbsorptionISF: Bool = false
+    ) -> PrecomputedInsulinInput {
+        let effects: [GlucoseEffect]
+        if useMidAbsorptionISF {
+            effects = annotatedDoses.glucoseEffectsMidAbsorptionISF(
+                insulinSensitivityHistory: sensitivity,
+                from: from,
+                to: to
+            )
+        } else {
+            effects = annotatedDoses.glucoseEffects(
+                insulinSensitivityHistory: sensitivity,
+                from: from,
+                to: to
+            )
+        }
+        return PrecomputedInsulinInput(annotatedDoses: annotatedDoses, insulinEffects: effects)
+    }
+
+    /// Returns a copy with `annotatedDoses` sliced to doses that overlap
+    /// `[from, to]`, and `insulinEffects` unchanged (the full pre-built
+    /// timeline is always passed through — generatePrediction only reads
+    /// the entries it needs).
+    ///
+    /// Use this per evaluation step to pass only the relevant dose window
+    /// into `generatePrediction`, matching what the standard path does when
+    /// it calls `doses.annotated(with: basal)` on the per-step slice.
+    ///
+    /// `annotatedDoses` must be sorted by `startDate`.
+    public func sliced(from: Date, to: Date) -> PrecomputedInsulinInput {
+        // Keep annotated doses that overlap [from, to]:
+        //   dose.startDate <= to  AND  dose.endDate > from
+        //
+        // annotatedDoses is sorted by startDate, so we can binary-search for
+        // the upper bound (first startDate > to) and then linear-scan backward
+        // from there. For the lower bound we use a linear filter on endDate
+        // since the array is NOT sorted by endDate.
+        //
+        // In practice the dose arrays are small (~100-200 entries per 16h
+        // window) so the linear endDate check is negligible.
+        let hiIdx = annotatedDoses.partition(index: to, key: \.startDate, after: false)
+        let slicedDoses = annotatedDoses[0..<hiIdx].filter { $0.endDate > from }
+        return PrecomputedInsulinInput(annotatedDoses: slicedDoses, insulinEffects: insulinEffects)
+    }
+
+    /// Convenience: annotate and compute effects in one call.
+    ///
+    /// Use when running a single config (no ISF sweep).  For ISF sweeps,
+    /// prefer `annotate(doses:basal:)` + `withEffects(sensitivity:from:to:)`
+    /// so annotation cost is paid only once.
+    public static func build<DoseType: InsulinDose>(
+        doses: [DoseType],
+        basal: [AbsoluteScheduleValue<Double>],
+        sensitivity: [AbsoluteScheduleValue<LoopQuantity>]? = nil,
+        effectsFrom: Date? = nil,
+        effectsTo: Date? = nil,
+        useMidAbsorptionISF: Bool = false
+    ) -> PrecomputedInsulinInput {
+        let base = annotate(doses: doses, basal: basal)
+        guard let sensitivity else { return base }
+        return base.withEffects(
+            sensitivity: sensitivity,
+            from: effectsFrom,
+            to: effectsTo,
+            useMidAbsorptionISF: useMidAbsorptionISF
+        )
+    }
+}
diff --git a/Sources/LoopAlgorithm/LoopAlgorithm.swift b/Sources/LoopAlgorithm/LoopAlgorithm.swift
index 2e711a1..fce1746 100644
--- a/Sources/LoopAlgorithm/LoopAlgorithm.swift
+++ b/Sources/LoopAlgorithm/LoopAlgorithm.swift
@@ -179,7 +179,8 @@ public struct LoopAlgorithm {
         includingPositiveVelocityAndRC: Bool = true,
         useMidAbsorptionISF: Bool = false,
         carbAbsorptionModel: CarbAbsorptionComputable = PiecewiseLinearAbsorption(),
-        gradualTransitionsThreshold: Double? = 40.0
+        gradualTransitionsThreshold: Double? = 40.0,
+        momentumVelocityMaximum: LoopQuantity? = nil
     ) -> LoopPrediction<CarbType> where CarbType: CarbEntry, GlucoseType: GlucoseSampleValue, InsulinDoseType: InsulinDose {
 
         var prediction: [PredictedGlucoseValue] = []
@@ -311,7 +312,7 @@ public struct LoopAlgorithm {
             var useMomentum: Bool = true
             if algorithmEffectsOptions.contains(.momentum) {
                 let momentumInputData = glucoseHistory.filterDateRange(start.addingTimeInterval(-GlucoseMath.momentumDataInterval), start)
-                momentumEffects = momentumInputData.linearMomentumEffect()
+                momentumEffects = momentumInputData.linearMomentumEffect(velocityMaximum: momentumVelocityMaximum)
                 if !includingPositiveVelocityAndRC, let netMomentum = momentumEffects.netEffect(), netMomentum.quantity.doubleValue(for: .milligramsPerDeciliter) > 0 {
                     // positive momentum is turned off
                     useMomentum = false
@@ -352,6 +353,201 @@ public struct LoopAlgorithm {
         )
     }
 
+    /// Generates a forecast using pre-annotated insulin data.
+    ///
+    /// This overload is optimised for multi-step historical sweeps where the
+    /// same dose history is evaluated at many consecutive time points.  By
+    /// accepting a `PrecomputedInsulinInput` the caller can:
+    ///
+    ///   1. **Skip `annotated(with: basal)`** — the most expensive per-step
+    ///      operation (~O(doses × basalSegments)).  Annotate the full window
+    ///      once with `PrecomputedInsulinInput.build(...)`, then slice
+    ///      `annotatedDoses` to the lookback window for each call.
+    ///
+    ///   2. **Skip `glucoseEffects(...)`** — when `precomputedInsulin.insulinEffects`
+    ///      is non-nil the function clips the pre-built effect timeline to the
+    ///      needed range instead of recomputing from scratch.  This is only
+    ///      valid when ISF does not change between steps (i.e. you are NOT
+    ///      sweeping ISF multipliers).
+    ///
+    /// All other effects (carbs, RC, momentum) are computed normally.
+    ///
+    /// - Parameters:
+    ///   - start: The starting time of the glucose prediction.
+    ///   - glucoseHistory: History of glucose values: t-10h to t.
+    ///   - precomputedInsulin: Pre-annotated dose data for this step.  Caller
+    ///     must slice `annotatedDoses` to `[t - insulinLookback, t]` (or
+    ///     `[t - lookback, t + 6h]` for future-insulin mode).
+    ///   - carbEntries: History of carb entries.
+    ///   - sensitivity: ISF timeline — still required for carb + RC effects.
+    ///   - carbRatio: Carb ratio timeline.
+    ///   - algorithmEffectsOptions: Which effects to include.
+    ///   - useIntegralRetrospectiveCorrection: Use integral RC.
+    ///   - includingPositiveVelocityAndRC: Include positive velocity/RC.
+    ///   - useMidAbsorptionISF: Use mid-absorption ISF (ignored when
+    ///     `precomputedInsulin.insulinEffects` is non-nil).
+    ///   - carbAbsorptionModel: Carb absorption model.
+    ///   - gradualTransitionsThreshold: RC smoothness gate (default 40 mg/dL).
+    /// - Returns: A `LoopPrediction` struct.  `dosesRelativeToBasal` is
+    ///   populated from `precomputedInsulin.annotatedDoses`.
+    public static func generatePrediction<CarbType, GlucoseType>(
+        start: Date,
+        glucoseHistory: [GlucoseType],
+        precomputedInsulin: PrecomputedInsulinInput,
+        carbEntries: [CarbType],
+        sensitivity: [AbsoluteScheduleValue<LoopQuantity>],
+        carbRatio: [AbsoluteScheduleValue<Double>],
+        algorithmEffectsOptions: AlgorithmEffectsOptions = .all,
+        useIntegralRetrospectiveCorrection: Bool = false,
+        includingPositiveVelocityAndRC: Bool = true,
+        useMidAbsorptionISF: Bool = false,
+        carbAbsorptionModel: CarbAbsorptionComputable = PiecewiseLinearAbsorption(),
+        gradualTransitionsThreshold: Double? = 40.0,
+        momentumVelocityMaximum: LoopQuantity? = nil
+    ) -> LoopPrediction<CarbType> where CarbType: CarbEntry, GlucoseType: GlucoseSampleValue {
+
+        let dosesRelativeToBasal = precomputedInsulin.annotatedDoses
+        let activeInsulin = dosesRelativeToBasal.insulinOnBoard(at: start)
+
+        // ── Insulin effects ──────────────────────────────────────────────────────
+        // Fast path: clip the pre-computed effect timeline to the needed range.
+        // Slow path: compute from annotated doses (still faster than the full
+        //            overload because annotation is already done).
+        let insulinEffects: [GlucoseEffect]
+        if let prebuilt = precomputedInsulin.insulinEffects {
+            // Use the pre-built effects directly.  Extra entries (outside the
+            // needed range) are harmless; counteractionEffects() and
+            // predictGlucose() only consume entries within their required window.
+            // Pass the full array — callers should pre-build with a generous
+            // `effectsTo` covering the full sweep end + activity duration.
+            insulinEffects = prebuilt
+        } else {
+            var effectsInterval = dosesRelativeToBasal.effectsInterval() ?? DateInterval(start: start, end: start)
+            if let glucoseStart = glucoseHistory.first?.startDate, glucoseStart < effectsInterval.start {
+                effectsInterval = effectsInterval.extendedToInclude(glucoseStart)
+            }
+            if let glucoseEnd = glucoseHistory.last?.endDate, glucoseEnd > effectsInterval.end {
+                effectsInterval = effectsInterval.extendedToInclude(glucoseEnd)
+            }
+            if useMidAbsorptionISF {
+                insulinEffects = dosesRelativeToBasal.glucoseEffectsMidAbsorptionISF(
+                    insulinSensitivityHistory: sensitivity,
+                    from: effectsInterval.start,
+                    to: effectsInterval.end
+                )
+            } else {
+                insulinEffects = dosesRelativeToBasal.glucoseEffects(
+                    insulinSensitivityHistory: sensitivity,
+                    from: effectsInterval.start,
+                    to: effectsInterval.end
+                )
+            }
+        }
+
+        // ── ICE, carbs, RC, momentum — identical to the standard overload ────────
+        let insulinCounteractionEffects = glucoseHistory.counteractionEffects(to: insulinEffects)
+
+        let carbStatus = carbEntries.map(
+            to: insulinCounteractionEffects,
+            carbRatio: carbRatio,
+            insulinSensitivity: sensitivity
+        )
+        let carbEffects = carbStatus.dynamicGlucoseEffects(
+            from: start.addingTimeInterval(-IntegralRetrospectiveCorrection.retrospectionInterval),
+            carbRatios: carbRatio,
+            insulinSensitivities: sensitivity,
+            absorptionModel: carbAbsorptionModel
+        )
+        let activeCarbs = carbStatus.dynamicCarbsOnBoard(at: start, absorptionModel: carbAbsorptionModel)
+
+        let retrospectiveGlucoseDiscrepancies = insulinCounteractionEffects.subtracting(carbEffects)
+        let retrospectiveGlucoseDiscrepanciesSummed = retrospectiveGlucoseDiscrepancies
+            .combinedSums(of: LoopMath.retrospectiveCorrectionGroupingInterval * 1.01)
+
+        let rc: RetrospectiveCorrection = useIntegralRetrospectiveCorrection
+            ? IntegralRetrospectiveCorrection(effectDuration: LoopMath.retrospectiveCorrectionEffectDuration)
+            : StandardRetrospectiveCorrection(effectDuration: LoopMath.retrospectiveCorrectionEffectDuration)
+
+        var prediction: [PredictedGlucoseValue] = []
+        var retrospectiveCorrectionEffects: [GlucoseEffect] = []
+        var momentumEffects: [GlucoseEffect] = []
+        var totalRetrospectiveCorrectionEffect: LoopQuantity?
+
+        if let latestGlucose = glucoseHistory.last {
+            retrospectiveCorrectionEffects = rc.computeEffect(
+                startingAt: latestGlucose,
+                retrospectiveGlucoseDiscrepanciesSummed: retrospectiveGlucoseDiscrepanciesSummed,
+                recencyInterval: TimeInterval(minutes: 15),
+                retrospectiveCorrectionGroupingInterval: LoopMath.retrospectiveCorrectionGroupingInterval
+            )
+            totalRetrospectiveCorrectionEffect = rc.totalGlucoseCorrectionEffect
+
+            var effects = [[GlucoseEffect]]()
+            if algorithmEffectsOptions.contains(.carbs)  { effects.append(carbEffects) }
+            if algorithmEffectsOptions.contains(.insulin) { effects.append(insulinEffects) }
+
+            if algorithmEffectsOptions.contains(.retrospection) {
+                var useRC = true
+                let rcTransitionData = glucoseHistory.filterDateRange(
+                    start.addingTimeInterval(-LoopMath.retrospectiveCorrectionGroupingInterval),
+                    start
+                )
+                if !rcTransitionData.hasGradualTransitions(gradualTransitionThreshold: gradualTransitionsThreshold ?? 40.0) {
+                    useRC = false
+                }
+                if !includingPositiveVelocityAndRC,
+                   let netRC = retrospectiveCorrectionEffects.netEffect(),
+                   netRC.quantity.doubleValue(for: .milligramsPerDeciliter) > 0 {
+                    useRC = false
+                }
+                if useRC { effects.append(retrospectiveCorrectionEffects) }
+            }
+
+            var useMomentum = true
+            if algorithmEffectsOptions.contains(.momentum) {
+                let momentumInputData = glucoseHistory.filterDateRange(
+                    start.addingTimeInterval(-GlucoseMath.momentumDataInterval), start
+                )
+                momentumEffects = momentumInputData.linearMomentumEffect(velocityMaximum: momentumVelocityMaximum)
+                if !includingPositiveVelocityAndRC,
+                   let netMomentum = momentumEffects.netEffect(),
+                   netMomentum.quantity.doubleValue(for: .milligramsPerDeciliter) > 0 {
+                    useMomentum = false
+                }
+            } else {
+                useMomentum = false
+            }
+
+            prediction = LoopMath.predictGlucose(
+                startingAt: latestGlucose,
+                momentum: useMomentum ? momentumEffects : [],
+                effects: effects
+            )
+
+            let finalDate = start.addingTimeInterval(InsulinMath.defaultInsulinActivityDuration)
+            if let last = prediction.last, last.startDate < finalDate {
+                prediction.append(PredictedGlucoseValue(startDate: finalDate, quantity: last.quantity))
+            }
+        }
+
+        return LoopPrediction(
+            glucose: prediction,
+            effects: LoopAlgorithmEffects(
+                insulin: insulinEffects,
+                carbs: carbEffects,
+                carbStatus: carbStatus,
+                retrospectiveCorrection: retrospectiveCorrectionEffects,
+                momentum: momentumEffects,
+                insulinCounteraction: insulinCounteractionEffects,
+                retrospectiveGlucoseDiscrepancies: retrospectiveGlucoseDiscrepanciesSummed,
+                totalRetrospectiveCorrectionEffect: totalRetrospectiveCorrectionEffect
+            ),
+            dosesRelativeToBasal: dosesRelativeToBasal,
+            activeInsulin: activeInsulin,
+            activeCarbs: activeCarbs
+        )
+    }
+
     // Helper to generate prediction with LoopPredictionInput struct
     public static func generatePrediction<CarbType, GlucoseType, InsulinDoseType>(input: LoopPredictionInput<CarbType, GlucoseType, InsulinDoseType>) -> LoopPrediction<CarbType> {
 
@@ -371,7 +567,7 @@ public struct LoopAlgorithm {
     }
 
     // Computes an amount of insulin to correct the given prediction
-    static func insulinCorrection(
+    public static func insulinCorrection(
         prediction: [PredictedGlucoseValue],
         at deliveryDate: Date,
         target: GlucoseRangeTimeline,
@@ -388,7 +584,7 @@ public struct LoopAlgorithm {
     }
 
     // Computes a 30 minute temp basal dose to correct the given prediction
-    static func recommendTempBasal(
+    public static func recommendTempBasal(
         for correction: InsulinCorrection,
         neutralBasalRate: Double,
         activeInsulin: Double,
@@ -420,7 +616,7 @@ public struct LoopAlgorithm {
     }
 
     // Computes a bolus or low-temp basal dose to correct the given prediction
-    static func recommendAutomaticDose(
+    public static func recommendAutomaticDose(
         for correction: InsulinCorrection,
         applicationFactor: Double,
         neutralBasalRate: Double,
diff --git a/Sources/LoopAlgorithm/LoopMath.swift b/Sources/LoopAlgorithm/LoopMath.swift
index 13889fc..7fc9e48 100644
--- a/Sources/LoopAlgorithm/LoopMath.swift
+++ b/Sources/LoopAlgorithm/LoopMath.swift
@@ -192,19 +192,25 @@ extension GlucoseValue {
         let glucoseUnit = LoopUnit.milligramsPerDeciliter
         let velocityUnit = GlucoseEffectVelocity.perSecondUnit
 
-        // The starting rate, which we will decay to 0 over the specified duration
-        let intercept = rate.doubleValue(for: velocityUnit) // mg/dL/s
-        let decayStartDate = startDate.addingTimeInterval(delta)
-        let slope = -intercept / (duration - delta)  // mg/dL/s/s
+        let firstChange = rate.doubleValue(for: velocityUnit) * delta // mg/dL/s * s = mg/dL
+        let secondChange = firstChange * (1 - delta / (duration - delta))
+
+        // Solve for f(t) = a*t^2 + b*t + c, where t is relative to self.startDate.
+        // f(0) = c
+        // f(delta) - c = firstChange = a*delta^2 + b*delta
+        // f(2*delta) - c = firstChange + secondChange = 4*a*delta^2 + 2*b*delta
+        // --> firstChange - secondChange = 2*a*delta^2
+        let c = quantity.doubleValue(for: glucoseUnit)
+        let a = (secondChange - firstChange) / (2 * delta * delta) // mg/dL/s^2
+        let b = (firstChange + secondChange - 4 * a * delta * delta) / (2 * delta) // mg/dL/s
 
         var values = [GlucoseEffect(startDate: startDate, quantity: quantity)]
-        var date = decayStartDate
-        var lastValue = quantity.doubleValue(for: glucoseUnit)
+        var date = startDate.addingTimeInterval(delta)
 
         repeat {
-            let value = lastValue + (intercept + slope * date.timeIntervalSince(decayStartDate)) * delta
+            let time = min(duration, date.timeIntervalSince(self.startDate))
+            let value = a * time * time + b * time + c
             values.append(GlucoseEffect(startDate: date, quantity: LoopQuantity(unit: glucoseUnit, doubleValue: value)))
-            lastValue = value
             date = date.addingTimeInterval(delta)
         } while date < endDate
 
diff --git a/Sources/LoopAlgorithm/SampleValue.swift b/Sources/LoopAlgorithm/SampleValue.swift
index a7fee2e..fb978b2 100644
--- a/Sources/LoopAlgorithm/SampleValue.swift
+++ b/Sources/LoopAlgorithm/SampleValue.swift
@@ -98,3 +98,40 @@ public extension Sequence where Element: TimelineValue {
         return filterDateRange(interval.start, interval.end)
     }
 }
+
+/// Fast binary-search filter for ordered timeline arrays. Picks up when the
+/// collection conforms to RandomAccessCollection with Int index (i.e. Array)
+/// and the elements are sorted by startDate (which is the contract for all
+/// schedule arrays — sensitivity / basal / carb-ratio / target — across this
+/// codebase). Reduces filterDateRange from O(N) to O(log N) per call.
+///
+/// LoopEval sims with per-step ISF schedules (`--candidate-isf-csv`) call
+/// filterDateRange ~1.5M times on a 60-day window; this dropped sim time
+/// from ~30 min to ~2 min on that workload.
+public extension RandomAccessCollection where Element: TimelineValue, Index == Int {
+    func filterDateRange(_ startDate: Date?, _ endDate: Date?) -> [Element] {
+        guard !isEmpty else { return [] }
+        // Lower bound: first index where element.endDate >= startDate
+        var lo = startIndex
+        if let startDate {
+            var l = startIndex, r = endIndex
+            while l < r {
+                let m = (l + r) / 2
+                if self[m].endDate < startDate { l = m + 1 } else { r = m }
+            }
+            lo = l
+        }
+        // Upper bound: first index where element.startDate > endDate
+        var hi = endIndex
+        if let endDate {
+            var l = lo, r = endIndex
+            while l < r {
+                let m = (l + r) / 2
+                if self[m].startDate <= endDate { l = m + 1 } else { r = m }
+            }
+            hi = l
+        }
+        guard lo < hi else { return [] }
+        return Array(self[lo..<hi])
+    }
+}
diff --git a/Tests/LoopAlgorithmTests/FilterDateRangeTests.swift b/Tests/LoopAlgorithmTests/FilterDateRangeTests.swift
new file mode 100644
index 0000000..8a1b798
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/FilterDateRangeTests.swift
@@ -0,0 +1,138 @@
+//
+//  FilterDateRangeTests.swift
+//  LoopAlgorithm
+//
+//  Tests for the binary-search filterDateRange overload on
+//  RandomAccessCollection<TimelineValue> — must produce identical output
+//  to the Sequence-based linear-filter version.
+//
+
+import XCTest
+@testable import LoopAlgorithm
+
+final class FilterDateRangeTests: XCTestCase {
+
+    /// Minimal TimelineValue with a date range.
+    private struct Sample: TimelineValue, Equatable, CustomStringConvertible {
+        let startDate: Date
+        let endDate: Date
+        let id: Int
+        var description: String { "Sample(id=\(id), start=\(startDate.timeIntervalSinceReferenceDate.rounded()), end=\(endDate.timeIntervalSinceReferenceDate.rounded()))" }
+    }
+
+    /// Linear-scan reference implementation (the Sequence-based version that
+    /// the binary-search overload must match).
+    private func linearFilter(_ items: [Sample], _ start: Date?, _ end: Date?) -> [Sample] {
+        return items.filter { value in
+            if let start, value.endDate < start { return false }
+            if let end, value.startDate > end { return false }
+            return true
+        }
+    }
+
+    private func contiguousSamples(count: Int, segmentSeconds: TimeInterval = 300,
+                                   startingAt: Date = Date(timeIntervalSince1970: 1700000000)) -> [Sample] {
+        return (0..<count).map { i in
+            Sample(
+                startDate: startingAt.addingTimeInterval(TimeInterval(i) * segmentSeconds),
+                endDate: startingAt.addingTimeInterval(TimeInterval(i + 1) * segmentSeconds),
+                id: i
+            )
+        }
+    }
+
+    // MARK: - Equivalence
+
+    func testEmptyCollection() {
+        let empty: [Sample] = []
+        XCTAssertEqual(empty.filterDateRange(Date(), Date().addingTimeInterval(60)), [])
+    }
+
+    func testBothBoundsNil() {
+        let samples = contiguousSamples(count: 20)
+        XCTAssertEqual(samples.filterDateRange(nil, nil), samples)
+    }
+
+    func testOnlyStartDate() {
+        let samples = contiguousSamples(count: 20)
+        let start = samples[5].startDate
+        XCTAssertEqual(samples.filterDateRange(start, nil),
+                       linearFilter(samples, start, nil))
+    }
+
+    func testOnlyEndDate() {
+        let samples = contiguousSamples(count: 20)
+        let end = samples[15].endDate
+        XCTAssertEqual(samples.filterDateRange(nil, end),
+                       linearFilter(samples, nil, end))
+    }
+
+    func testBothBoundsInMiddle() {
+        let samples = contiguousSamples(count: 20)
+        let start = samples[5].startDate
+        let end = samples[15].endDate
+        XCTAssertEqual(samples.filterDateRange(start, end),
+                       linearFilter(samples, start, end))
+    }
+
+    func testStartBeforeAll() {
+        let samples = contiguousSamples(count: 20)
+        let start = samples[0].startDate.addingTimeInterval(-3600)
+        XCTAssertEqual(samples.filterDateRange(start, nil),
+                       linearFilter(samples, start, nil))
+    }
+
+    func testEndAfterAll() {
+        let samples = contiguousSamples(count: 20)
+        let end = samples.last!.endDate.addingTimeInterval(3600)
+        XCTAssertEqual(samples.filterDateRange(nil, end),
+                       linearFilter(samples, nil, end))
+    }
+
+    func testRangeFullyOutsideAllSamples() {
+        let samples = contiguousSamples(count: 20)
+        let start = samples.last!.endDate.addingTimeInterval(60)
+        let end = samples.last!.endDate.addingTimeInterval(3600)
+        XCTAssertEqual(samples.filterDateRange(start, end), [])
+    }
+
+    func testRangeBeforeAllSamples() {
+        let samples = contiguousSamples(count: 20)
+        let start = samples[0].startDate.addingTimeInterval(-3600)
+        let end = samples[0].startDate.addingTimeInterval(-60)
+        XCTAssertEqual(samples.filterDateRange(start, end), [])
+    }
+
+    func testRangeExactlyMatchesOneSegment() {
+        let samples = contiguousSamples(count: 20)
+        let s = samples[7]
+        XCTAssertEqual(samples.filterDateRange(s.startDate, s.endDate),
+                       linearFilter(samples, s.startDate, s.endDate))
+    }
+
+    func testRandomizedFuzz() {
+        // 100 random queries on a 200-element schedule.
+        let samples = contiguousSamples(count: 200)
+        let baseT = samples[0].startDate.timeIntervalSinceReferenceDate
+        let totalSpan = samples.last!.endDate.timeIntervalSince(samples[0].startDate)
+        var rng = SystemRandomNumberGenerator()
+        for _ in 0..<100 {
+            let startOffset = Double.random(in: -1000...(totalSpan + 1000), using: &rng)
+            let endOffset = startOffset + Double.random(in: 0...(totalSpan + 1000), using: &rng)
+            let start = Date(timeIntervalSinceReferenceDate: baseT + startOffset)
+            let end = Date(timeIntervalSinceReferenceDate: baseT + endOffset)
+            XCTAssertEqual(samples.filterDateRange(start, end),
+                           linearFilter(samples, start, end),
+                           "binary-search and linear filter must agree for [\(start), \(end)]")
+        }
+    }
+
+    func testSingleSampleCollection() {
+        let samples = contiguousSamples(count: 1)
+        let s = samples[0]
+        XCTAssertEqual(samples.filterDateRange(s.startDate, s.endDate), samples)
+        XCTAssertEqual(samples.filterDateRange(nil, nil), samples)
+        XCTAssertEqual(samples.filterDateRange(s.endDate.addingTimeInterval(60), nil), [])
+        XCTAssertEqual(samples.filterDateRange(nil, s.startDate.addingTimeInterval(-60)), [])
+    }
+}
diff --git a/Tests/LoopAlgorithmTests/Fixtures/carbs_with_isf_change_recommendation.json b/Tests/LoopAlgorithmTests/Fixtures/carbs_with_isf_change_recommendation.json
index b4e70af..bde6ac6 100644
--- a/Tests/LoopAlgorithmTests/Fixtures/carbs_with_isf_change_recommendation.json
+++ b/Tests/LoopAlgorithmTests/Fixtures/carbs_with_isf_change_recommendation.json
@@ -1,5 +1,5 @@
 {
   "manual" : {
-    "amount" : 10.546890782709953
+    "amount" : 10.52269112701204
   }
-}
+}
\ No newline at end of file
diff --git a/Tests/LoopAlgorithmTests/Fixtures/live_capture_predicted_glucose.json b/Tests/LoopAlgorithmTests/Fixtures/live_capture_predicted_glucose.json
index b77cb55..1baaacf 100644
--- a/Tests/LoopAlgorithmTests/Fixtures/live_capture_predicted_glucose.json
+++ b/Tests/LoopAlgorithmTests/Fixtures/live_capture_predicted_glucose.json
@@ -10,383 +10,383 @@
     "startDate" : "2023-06-23T02:40:00Z"
   },
   {
-    "quantity" : 180.52987493690765,
+    "quantity" : 180.52784693243598,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T02:45:00Z"
   },
   {
-    "quantity" : 179.77931710835796,
+    "quantity" : 179.77106522809387,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T02:50:00Z"
   },
   {
-    "quantity" : 177.81435588000684,
+    "quantity" : 177.7956842526296,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T02:55:00Z"
   },
   {
-    "quantity" : 175.04920382978105,
+    "quantity" : 175.01794458844162,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:00:00Z"
   },
   {
-    "quantity" : 172.09884468881066,
+    "quantity" : 172.05499783350902,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:05:00Z"
   },
   {
-    "quantity" : 169.0341959170697,
+    "quantity" : 168.97776144780588,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:10:00Z"
   },
   {
-    "quantity" : 165.91852357330802,
+    "quantity" : 165.84950149008202,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:15:00Z"
   },
   {
-    "quantity" : 162.78787379965794,
+    "quantity" : 162.70626410246973,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:20:00Z"
   },
   {
-    "quantity" : 159.67566374385987,
+    "quantity" : 159.58146643270948,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:25:00Z"
   },
   {
-    "quantity" : 156.6278000530812,
+    "quantity" : 156.5210151279686,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:30:00Z"
   },
   {
-    "quantity" : 153.68497899133908,
+    "quantity" : 153.5656064522643,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:35:00Z"
   },
   {
-    "quantity" : 150.85857622089654,
+    "quantity" : 150.73920368182175,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:40:00Z"
   },
   {
-    "quantity" : 148.1797464838103,
+    "quantity" : 148.06037394473552,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:45:00Z"
   },
   {
-    "quantity" : 145.67546444468488,
+    "quantity" : 145.5560919056101,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:50:00Z"
   },
   {
-    "quantity" : 143.36889813413907,
+    "quantity" : 143.24952559506428,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T03:55:00Z"
   },
   {
-    "quantity" : 141.27978455565565,
+    "quantity" : 141.16041201658086,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:00:00Z"
   },
   {
-    "quantity" : 139.4249156157845,
+    "quantity" : 139.3055430767097,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:05:00Z"
   },
   {
-    "quantity" : 137.7082164432302,
+    "quantity" : 137.58884390415542,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:10:00Z"
   },
   {
-    "quantity" : 135.9914530272836,
+    "quantity" : 135.8720804882088,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:15:00Z"
   },
   {
-    "quantity" : 134.2827664300858,
+    "quantity" : 134.163393891011,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:20:00Z"
   },
   {
-    "quantity" : 132.58882252103788,
+    "quantity" : 132.4694499819631,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:25:00Z"
   },
   {
-    "quantity" : 130.91436540926705,
+    "quantity" : 130.79499287019226,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:30:00Z"
   },
   {
-    "quantity" : 129.26245506698106,
+    "quantity" : 129.14308252790627,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:35:00Z"
   },
   {
-    "quantity" : 127.63445215517064,
+    "quantity" : 127.51507961609585,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:40:00Z"
   },
   {
-    "quantity" : 126.02931442610466,
+    "quantity" : 125.90994188702987,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:45:00Z"
   },
   {
-    "quantity" : 124.44584453318035,
+    "quantity" : 124.32647199410556,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:50:00Z"
   },
   {
-    "quantity" : 122.88145382927624,
+    "quantity" : 122.76208129020145,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T04:55:00Z"
   },
   {
-    "quantity" : 121.33291804466413,
+    "quantity" : 121.21354550558934,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:00:00Z"
   },
   {
-    "quantity" : 119.79660318395023,
+    "quantity" : 119.67723064487544,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:05:00Z"
   },
   {
-    "quantity" : 118.26822621269756,
+    "quantity" : 118.14885367362277,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:10:00Z"
   },
   {
-    "quantity" : 116.74288846240054,
+    "quantity" : 116.62351592332575,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:15:00Z"
   },
   {
-    "quantity" : 115.21516364934988,
+    "quantity" : 115.09579111027509,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:20:00Z"
   },
   {
-    "quantity" : 113.67917795139525,
+    "quantity" : 113.55980541232046,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:25:00Z"
   },
   {
-    "quantity" : 112.12868274578355,
+    "quantity" : 112.00931020670876,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:30:00Z"
   },
   {
-    "quantity" : 110.55712056957398,
+    "quantity" : 110.4377480304992,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:35:00Z"
   },
   {
-    "quantity" : 108.95768482515078,
+    "quantity" : 108.83831228607599,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:40:00Z"
   },
   {
-    "quantity" : 107.32337371691418,
+    "quantity" : 107.20400117783939,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:45:00Z"
   },
   {
-    "quantity" : 105.64703887119052,
+    "quantity" : 105.52766633211573,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:50:00Z"
   },
   {
-    "quantity" : 103.92146136061618,
+    "quantity" : 103.80208882154139,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T05:55:00Z"
   },
   {
-    "quantity" : 102.13957364029821,
+    "quantity" : 102.02020110122342,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:00:00Z"
   },
   {
-    "quantity" : 100.29425666336888,
+    "quantity" : 100.1748841242941,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:05:00Z"
   },
   {
-    "quantity" : 98.37810372588095,
+    "quantity" : 98.25873118680616,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:10:00Z"
   },
   {
-    "quantity" : 96.38393930539169,
+    "quantity" : 96.2645667663169,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:15:00Z"
   },
   {
-    "quantity" : 94.30446350902744,
+    "quantity" : 94.18509096995265,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:20:00Z"
   },
   {
-    "quantity" : 92.24204127278486,
+    "quantity" : 92.12266873371007,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:25:00Z"
   },
   {
-    "quantity" : 90.33818302395392,
+    "quantity" : 90.21881048487913,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:30:00Z"
   },
   {
-    "quantity" : 88.58657375772682,
+    "quantity" : 88.46720121865204,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:35:00Z"
   },
   {
-    "quantity" : 86.9796355549934,
+    "quantity" : 86.8602630159186,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:40:00Z"
   },
   {
-    "quantity" : 85.50932186775859,
+    "quantity" : 85.3899493286838,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:45:00Z"
   },
   {
-    "quantity" : 84.16822997919033,
+    "quantity" : 84.04885744011554,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:50:00Z"
   },
   {
-    "quantity" : 82.94837192653554,
+    "quantity" : 82.82899938746075,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T06:55:00Z"
   },
   {
-    "quantity" : 81.84224397138112,
+    "quantity" : 81.72287143230633,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:00:00Z"
   },
   {
-    "quantity" : 80.8433012790305,
+    "quantity" : 80.72392873995571,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:05:00Z"
   },
   {
-    "quantity" : 79.94514990703274,
+    "quantity" : 79.82577736795795,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:10:00Z"
   },
   {
-    "quantity" : 79.1425285689858,
+    "quantity" : 79.02315602991101,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:15:00Z"
   },
   {
-    "quantity" : 78.43073701607969,
+    "quantity" : 78.3113644770049,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:20:00Z"
   },
   {
-    "quantity" : 77.80513210408813,
+    "quantity" : 77.68575956501334,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:25:00Z"
   },
   {
-    "quantity" : 77.26038909817899,
+    "quantity" : 77.1410165591042,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:30:00Z"
   },
   {
-    "quantity" : 76.79214128522554,
+    "quantity" : 76.67276874615075,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:35:00Z"
   },
   {
-    "quantity" : 76.39636603545401,
+    "quantity" : 76.27699349637922,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:40:00Z"
   },
   {
-    "quantity" : 76.06917517261084,
+    "quantity" : 75.94980263353605,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:45:00Z"
   },
   {
-    "quantity" : 75.80681469169488,
+    "quantity" : 75.6874421526201,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:50:00Z"
   },
   {
-    "quantity" : 75.60563685065486,
+    "quantity" : 75.48626431158007,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T07:55:00Z"
   },
   {
-    "quantity" : 75.46174433219417,
+    "quantity" : 75.34237179311938,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:00:00Z"
   },
   {
-    "quantity" : 75.3700976935867,
+    "quantity" : 75.25072515451191,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:05:00Z"
   },
   {
-    "quantity" : 75.32563190200372,
+    "quantity" : 75.20625936292893,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:10:00Z"
   },
   {
-    "quantity" : 75.32301505961473,
+    "quantity" : 75.20364252053994,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:15:00Z"
   },
   {
-    "quantity" : 75.33414614640142,
+    "quantity" : 75.21477360732663,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:20:00Z"
   },
   {
-    "quantity" : 75.34232624108009,
+    "quantity" : 75.2229537020053,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:25:00Z"
   },
   {
-    "quantity" : 75.34805924470882,
+    "quantity" : 75.22868670563403,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:30:00Z"
   },
   {
-    "quantity" : 75.35181912391843,
+    "quantity" : 75.23244658484364,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:35:00Z"
   },
   {
-    "quantity" : 75.35405041818424,
+    "quantity" : 75.23467787910946,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:40:00Z"
   },
   {
-    "quantity" : 75.35517138501669,
+    "quantity" : 75.2357988459419,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:45:00Z"
   },
   {
-    "quantity" : 75.35557365902051,
+    "quantity" : 75.23620111994572,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:50:00Z"
   },
   {
-    "quantity" : 75.35562264689557,
+    "quantity" : 75.23625010782078,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T08:55:00Z"
   },
   {
-    "quantity" : 75.35562264689557,
+    "quantity" : 75.23625010782078,
     "quantityUnit" : "mg\/dL",
     "startDate" : "2023-06-23T09:00:00Z"
   }
-]
+]
\ No newline at end of file
diff --git a/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-isf.json b/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-isf.json
new file mode 100644
index 0000000..d89763f
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-isf.json
@@ -0,0 +1,192 @@
+{
+  "automaticBolusApplicationFactor" : 0.4,
+  "basal" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "value" : 0.85
+    },
+    {
+      "endDate" : "2025-07-29T14:49:56Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:12:36Z",
+      "startDate" : "2025-07-29T14:49:56Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:12:44Z",
+      "startDate" : "2025-07-29T16:12:36Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:39:30Z",
+      "startDate" : "2025-07-29T16:12:44Z",
+      "value" : 1
+    }
+  ],
+  "carbEntries" : [
+    {
+      "absorptionTime" : 10800,
+      "date" : "2025-07-29T16:12:48Z",
+      "grams" : 20
+    }
+  ],
+  "carbRatio" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-29T04:11:52Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T14:49:56Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T16:12:36Z",
+      "startDate" : "2025-07-29T14:49:56Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T16:12:44Z",
+      "startDate" : "2025-07-29T16:12:36Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T18:12:44Z",
+      "startDate" : "2025-07-29T16:12:44Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T22:25:00Z",
+      "startDate" : "2025-07-29T18:12:44Z",
+      "value" : 10
+    }
+  ],
+  "doses" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "type" : "basal",
+      "volume" : 7.65
+    },
+    {
+      "endDate" : "2025-07-29T14:49:01Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "type" : "basal",
+      "volume" : 9.8
+    },
+    {
+      "endDate" : "2025-07-29T15:07:36Z",
+      "startDate" : "2025-07-29T14:49:01Z",
+      "type" : "basal",
+      "volume" : 0.3
+    },
+    {
+      "endDate" : "2025-07-29T15:57:58Z",
+      "startDate" : "2025-07-29T15:07:36Z",
+      "type" : "basal",
+      "volume" : 0.85
+    },
+    {
+      "endDate" : "2025-07-29T16:01:05Z",
+      "startDate" : "2025-07-29T15:57:58Z",
+      "type" : "basal",
+      "volume" : 0.05
+    },
+    {
+      "endDate" : "2025-07-29T16:07:02Z",
+      "startDate" : "2025-07-29T16:01:05Z",
+      "type" : "basal",
+      "volume" : 0.1
+    },
+    {
+      "endDate" : "2025-07-29T16:09:30Z",
+      "startDate" : "2025-07-29T16:07:02Z",
+      "type" : "basal",
+      "volume" : 0.04098938193586137
+    },
+    {
+      "endDate" : "2025-07-29T16:39:30Z",
+      "startDate" : "2025-07-29T16:09:30Z",
+      "type" : "basal",
+      "volume" : 0
+    }
+  ],
+  "glucoseHistory" : [
+    {
+      "date" : "2025-07-29T14:49:01Z",
+      "value" : 110
+    },
+    {
+      "date" : "2025-07-29T14:54:01Z",
+      "value" : 112
+    },
+    {
+      "date" : "2025-07-29T14:59:01Z",
+      "value" : 113
+    },
+    {
+      "date" : "2025-07-29T15:04:37Z",
+      "value" : 115
+    },
+    {
+      "date" : "2025-07-29T15:07:36Z",
+      "value" : 116
+    },
+    {
+      "date" : "2025-07-29T15:14:11Z",
+      "value" : 119
+    },
+    {
+      "date" : "2025-07-29T15:57:58Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:01:05Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:06:05Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:07:02Z",
+      "value" : 130
+    },
+    {
+      "date" : "2025-07-29T16:09:30Z",
+      "value" : 130
+    }
+  ],
+  "maxBasalRate" : 5,
+  "maxBolus" : 10,
+  "predictionStart" : "2025-07-29T16:12:52Z",
+  "recommendationInsulinType" : "novolog",
+  "recommendationType" : "manualBolus",
+  "sensitivity" : [
+    {
+      "endDate" : "2025-07-29T16:30:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "value" : 55
+    },
+    {
+      "endDate" : "2025-07-29T22:50:00Z",
+      "startDate" : "2025-07-29T16:30:00Z",
+      "value" : 65
+    }
+  ],
+  "suspendThreshold" : 75,
+  "target" : [
+    {
+      "endDate" : "2025-07-29T22:25:00Z",
+      "lowerBound" : 140,
+      "startDate" : "2025-07-29T16:12:44Z",
+      "upperBound" : 160
+    }
+  ],
+  "useMidAbsorptionISF" : true
+}
diff --git a/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-no-isf.json b/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-no-isf.json
new file mode 100644
index 0000000..807510c
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/Fixtures/meal-bolus-no-isf.json
@@ -0,0 +1,192 @@
+{
+  "automaticBolusApplicationFactor" : 0.4,
+  "basal" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "value" : 0.85
+    },
+    {
+      "endDate" : "2025-07-29T14:49:56Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:12:36Z",
+      "startDate" : "2025-07-29T14:49:56Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:12:44Z",
+      "startDate" : "2025-07-29T16:12:36Z",
+      "value" : 1
+    },
+    {
+      "endDate" : "2025-07-29T16:39:30Z",
+      "startDate" : "2025-07-29T16:12:44Z",
+      "value" : 1
+    }
+  ],
+  "carbEntries" : [
+    {
+      "absorptionTime" : 10800,
+      "date" : "2025-07-29T16:12:48Z",
+      "grams" : 20
+    }
+  ],
+  "carbRatio" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-29T04:11:52Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T14:49:56Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T16:12:36Z",
+      "startDate" : "2025-07-29T14:49:56Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T16:12:44Z",
+      "startDate" : "2025-07-29T16:12:36Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T18:12:44Z",
+      "startDate" : "2025-07-29T16:12:44Z",
+      "value" : 10
+    },
+    {
+      "endDate" : "2025-07-29T22:25:00Z",
+      "startDate" : "2025-07-29T18:12:44Z",
+      "value" : 10
+    }
+  ],
+  "doses" : [
+    {
+      "endDate" : "2025-07-29T05:00:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "type" : "basal",
+      "volume" : 7.65
+    },
+    {
+      "endDate" : "2025-07-29T14:49:01Z",
+      "startDate" : "2025-07-29T05:00:00Z",
+      "type" : "basal",
+      "volume" : 9.8
+    },
+    {
+      "endDate" : "2025-07-29T15:07:36Z",
+      "startDate" : "2025-07-29T14:49:01Z",
+      "type" : "basal",
+      "volume" : 0.3
+    },
+    {
+      "endDate" : "2025-07-29T15:57:58Z",
+      "startDate" : "2025-07-29T15:07:36Z",
+      "type" : "basal",
+      "volume" : 0.85
+    },
+    {
+      "endDate" : "2025-07-29T16:01:05Z",
+      "startDate" : "2025-07-29T15:57:58Z",
+      "type" : "basal",
+      "volume" : 0.05
+    },
+    {
+      "endDate" : "2025-07-29T16:07:02Z",
+      "startDate" : "2025-07-29T16:01:05Z",
+      "type" : "basal",
+      "volume" : 0.1
+    },
+    {
+      "endDate" : "2025-07-29T16:09:30Z",
+      "startDate" : "2025-07-29T16:07:02Z",
+      "type" : "basal",
+      "volume" : 0.04098938193586137
+    },
+    {
+      "endDate" : "2025-07-29T16:39:30Z",
+      "startDate" : "2025-07-29T16:09:30Z",
+      "type" : "basal",
+      "volume" : 0
+    }
+  ],
+  "glucoseHistory" : [
+    {
+      "date" : "2025-07-29T14:49:01Z",
+      "value" : 110
+    },
+    {
+      "date" : "2025-07-29T14:54:01Z",
+      "value" : 112
+    },
+    {
+      "date" : "2025-07-29T14:59:01Z",
+      "value" : 113
+    },
+    {
+      "date" : "2025-07-29T15:04:37Z",
+      "value" : 115
+    },
+    {
+      "date" : "2025-07-29T15:07:36Z",
+      "value" : 116
+    },
+    {
+      "date" : "2025-07-29T15:14:11Z",
+      "value" : 119
+    },
+    {
+      "date" : "2025-07-29T15:57:58Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:01:05Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:06:05Z",
+      "value" : 129
+    },
+    {
+      "date" : "2025-07-29T16:07:02Z",
+      "value" : 130
+    },
+    {
+      "date" : "2025-07-29T16:09:30Z",
+      "value" : 130
+    }
+  ],
+  "maxBasalRate" : 5,
+  "maxBolus" : 10,
+  "predictionStart" : "2025-07-29T16:12:52Z",
+  "recommendationInsulinType" : "novolog",
+  "recommendationType" : "manualBolus",
+  "sensitivity" : [
+    {
+      "endDate" : "2025-07-29T16:30:00Z",
+      "startDate" : "2025-07-28T20:00:00Z",
+      "value" : 55
+    },
+    {
+      "endDate" : "2025-07-29T22:50:00Z",
+      "startDate" : "2025-07-29T16:30:00Z",
+      "value" : 65
+    }
+  ],
+  "suspendThreshold" : 75,
+  "target" : [
+    {
+      "endDate" : "2025-07-29T22:25:00Z",
+      "lowerBound" : 140,
+      "startDate" : "2025-07-29T16:12:44Z",
+      "upperBound" : 160
+    }
+  ],
+  "useMidAbsorptionISF" : false
+}
diff --git a/Tests/LoopAlgorithmTests/LoopAlgorithmTests.swift b/Tests/LoopAlgorithmTests/LoopAlgorithmTests.swift
index e8d1f1f..0784e30 100644
--- a/Tests/LoopAlgorithmTests/LoopAlgorithmTests.swift
+++ b/Tests/LoopAlgorithmTests/LoopAlgorithmTests.swift
@@ -76,7 +76,7 @@ final class LoopAlgorithmTests: XCTestCase {
         let output = LoopAlgorithm.run(input: input)
 
         XCTAssertEqual(output.activeCarbs, 50)
-        XCTAssertEqual(output.recommendation!.manual!.amount, 5.83, accuracy: 0.01)
+        XCTAssertEqual(output.recommendation!.manual!.amount, 5.86, accuracy: 0.01)
     }
 
 
@@ -112,8 +112,8 @@ final class LoopAlgorithmTests: XCTestCase {
         XCTAssertEqual(outputA.effects.insulin.last?.quantity.doubleValue(for: .milligramsPerDeciliter), 0.0)
         XCTAssertEqual(outputB.effects.insulin.last?.quantity.doubleValue(for: .milligramsPerDeciliter), 0.0)
 
-        XCTAssertEqual(outputA.effects.retrospectiveCorrection.last?.quantity.doubleValue(for: .milligramsPerDeciliter), 165)
-        XCTAssertEqual(outputB.effects.retrospectiveCorrection.last?.quantity.doubleValue(for: .milligramsPerDeciliter), 165)
+        XCTAssertEqual(outputA.effects.retrospectiveCorrection.last?.quantity.doubleValue(for: .milligramsPerDeciliter) ?? 0, 165, accuracy: 0.05)
+        XCTAssertEqual(outputB.effects.retrospectiveCorrection.last?.quantity.doubleValue(for: .milligramsPerDeciliter) ?? 0, 165, accuracy: 0.05)
 
         // These tests fail, because the momentum effect is *not* time independent yet.
         // Even though all the input data is the same (just shifted in time), momentum effect varies in relation to how offset
@@ -222,14 +222,14 @@ final class LoopAlgorithmTests: XCTestCase {
         let decoder = JSONDecoder()
         decoder.dateDecodingStrategy = .iso8601
 
-        let url = Bundle.module.url(forResource: "meal-bolus", withExtension: "json", subdirectory: "Fixtures")!
+        let url = Bundle.module.url(forResource: "meal-bolus-isf", withExtension: "json", subdirectory: "Fixtures")!
         var input = try! decoder.decode(AlgorithmInputFixture.self, from: try! Data(contentsOf: url))
 
         let output = LoopAlgorithm.run(input: input)
 
         // Should recommend bolus to cover meal
-        XCTAssertEqual(output.predictedGlucose.last!.quantity.doubleValue(for: .milligramsPerDeciliter), 274, accuracy: 0.1)
-        XCTAssertEqual(output.recommendation!.manual!.amount, 1.9, accuracy: 0.01)
+        XCTAssertEqual(output.predictedGlucose.last!.quantity.doubleValue(for: .milligramsPerDeciliter), 274.14, accuracy: 0.1)
+        XCTAssertEqual(output.recommendation!.manual!.amount, 1.91, accuracy: 0.01)
 
         // Now check forecast if bolus recommendation is accepted and delivered.
         input.doses.append(
@@ -247,7 +247,38 @@ final class LoopAlgorithmTests: XCTestCase {
         XCTAssertEqual(output2.predictedGlucose.last!.quantity.doubleValue(for: .milligramsPerDeciliter), 150, accuracy: 0.1)
     }
 
-    func testMidAborptionISFFlag() {
+    func testMealBolusNoMidAbsorptionISFScenario() {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+
+        let url = Bundle.module.url(
+            forResource: "meal-bolus-no-isf", withExtension: "json", subdirectory: "Fixtures")!
+        var input = try! decoder.decode(
+            AlgorithmInputFixture.self, from: try! Data(contentsOf: url))
+
+        let output = LoopAlgorithm.run(input: input)
+
+        // Should recommend bolus to cover meal
+        XCTAssertEqual(output.predictedGlucose.last!.quantity.doubleValue(for: .milligramsPerDeciliter), 269.15, accuracy: 0.1)
+        XCTAssertEqual(output.recommendation!.manual!.amount, 2.16, accuracy: 0.01)
+
+        // Now check forecast if bolus recommendation is accepted and delivered.
+        input.doses.append(
+            .init(
+                deliveryType: .bolus,
+                startDate: input.predictionStart,
+                endDate: input.predictionStart.addingTimeInterval(30),
+                volume: output.recommendation!.manual!.amount
+            )
+        )
+
+        let output2 = LoopAlgorithm.run(input: input)
+
+        // 150 mg/dL is the middle of the target range
+        XCTAssertEqual(output2.predictedGlucose.last!.quantity.doubleValue(for: .milligramsPerDeciliter), 150, accuracy: 0.1)
+    }
+
+    func testMidAbsorptionISFFlag() {
         let now = ISO8601DateFormatter().date(from: "2024-01-03T00:00:00+0000")!
         var input = AlgorithmInputFixture.mock(for: now)
 
@@ -298,7 +329,7 @@ final class LoopAlgorithmTests: XCTestCase {
         var recommendedBolus = output.recommendation!.automatic?.bolusUnits
         var activeInsulin = output.activeInsulin!
         XCTAssertEqual(activeInsulin, 8.0)
-        XCTAssertEqual(recommendedBolus!, 1.66, accuracy: 0.01)
+        XCTAssertEqual(recommendedBolus!, 1.69, accuracy: 0.01)
 
         // Now try with maxBolus of 4; should not recommend any more insulin, as we're at our max iob
         input.maxBolus = 4
@@ -366,12 +397,12 @@ final class LoopAlgorithmTests: XCTestCase {
         // Without mid-absorption ISF
         input.useMidAbsorptionISF = false
         var output = LoopAlgorithm.run(input: input)
-        XCTAssertEqual(2.58, output.recommendation!.manual!.amount, accuracy: 0.01)
+        XCTAssertEqual(2.73, output.recommendation!.manual!.amount, accuracy: 0.01)
 
         // With mid-absorption ISF
         input.useMidAbsorptionISF = true
         output = LoopAlgorithm.run(input: input)
-        XCTAssertEqual(1.41, output.recommendation!.manual!.amount, accuracy: 0.01)
+        XCTAssertEqual(1.49, output.recommendation!.manual!.amount, accuracy: 0.01)
     }
 
     func testIncompleteISFTimelineDetected() {
diff --git a/Tests/LoopAlgorithmTests/LoopMathTests.swift b/Tests/LoopAlgorithmTests/LoopMathTests.swift
new file mode 100644
index 0000000..ff3bac5
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/LoopMathTests.swift
@@ -0,0 +1,48 @@
+//
+//  LoopMathTests.swift
+//  LoopAlgorithm
+//
+
+import XCTest
+@testable import LoopAlgorithm
+
+class LoopMathTests: XCTestCase {
+
+    /// `decayEffect` previously accumulated the decay step-by-step starting from
+    /// the simulation-grid boundary (the sample's `startDate` floored to `delta`),
+    /// so two samples sitting on opposite sides of a 5-minute boundary produced
+    /// different effect values at the same future absolute timestamp. With the
+    /// continuous formulation, a sub-`delta` shift in the input timestamp only
+    /// shifts the output series by one slot and leaves shared-timestamp values
+    /// effectively unchanged.
+    func testDecayEffectIsContinuousAcrossSimulationBoundary() {
+        let calendar = Calendar(identifier: .gregorian)
+        let alignedDate = calendar.date(from: DateComponents(year: 2024, month: 1, day: 1, hour: 10, minute: 15, second: 0))!
+        let shiftedDate = alignedDate.addingTimeInterval(-1e-6)
+
+        let rate = LoopQuantity(unit: .milligramsPerDeciliterPerMinute, doubleValue: -0.5)
+
+        let alignedSample = FixtureGlucoseSample(startDate: alignedDate, quantity: .glucose(100))
+        let shiftedSample = FixtureGlucoseSample(startDate: shiftedDate, quantity: .glucose(100))
+
+        let alignedEffects = alignedSample.decayEffect(atRate: rate, for: .minutes(30))
+        let shiftedEffects = shiftedSample.decayEffect(atRate: rate, for: .minutes(30))
+
+        // The shifted sample's floored start lands one `delta` earlier, so its
+        // series has one extra leading entry equal to the sample's value.
+        XCTAssertEqual(shiftedEffects.count, alignedEffects.count + 1)
+        XCTAssertEqual(shiftedEffects[0].quantity.doubleValue(for: .milligramsPerDeciliter), 100, accuracy: 1e-9)
+
+        // Shared timestamps should produce shared values.
+        let mgdl = LoopUnit.milligramsPerDeciliter
+        for (index, aligned) in alignedEffects.enumerated() {
+            let shifted = shiftedEffects[index + 1]
+            XCTAssertEqual(aligned.startDate, shifted.startDate)
+            XCTAssertEqual(
+                aligned.quantity.doubleValue(for: mgdl),
+                shifted.quantity.doubleValue(for: mgdl),
+                accuracy: 1e-6
+            )
+        }
+    }
+}
diff --git a/Tests/LoopAlgorithmTests/Mocks/IntegralRetrospectiveCorrectionTests.swift b/Tests/LoopAlgorithmTests/Mocks/IntegralRetrospectiveCorrectionTests.swift
index da43231..ccd112f 100644
--- a/Tests/LoopAlgorithmTests/Mocks/IntegralRetrospectiveCorrectionTests.swift
+++ b/Tests/LoopAlgorithmTests/Mocks/IntegralRetrospectiveCorrectionTests.swift
@@ -42,7 +42,7 @@ final class IntegralRetrospectiveCorrectionTests: XCTestCase {
             retrospectiveCorrectionGroupingInterval: LoopMath.retrospectiveCorrectionGroupingInterval
         )
 
-        XCTAssertEqual(effect.last?.quantity.doubleValue(for: .milligramsPerDeciliter), 110)
+        XCTAssertEqual(effect.last?.quantity.doubleValue(for: .milligramsPerDeciliter) ?? 0, 110, accuracy: 0.05)
         XCTAssertEqual(effect.last?.startDate, dateFormatter.date(from: "2015-07-13T13:00:00")!)
     }
 }
diff --git a/Tests/LoopAlgorithmTests/PrecomputedInsulinInputTests.swift b/Tests/LoopAlgorithmTests/PrecomputedInsulinInputTests.swift
new file mode 100644
index 0000000..25f6096
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/PrecomputedInsulinInputTests.swift
@@ -0,0 +1,215 @@
+// PrecomputedInsulinInputTests.swift
+//
+// Verifies that generatePrediction(precomputedInsulin:) produces bit-identical
+// output to the standard overload, and that the pre-built effects fast-path
+// also matches.
+
+import XCTest
+@testable import LoopAlgorithm
+
+final class PrecomputedInsulinInputTests: XCTestCase {
+
+    // MARK: - Fixture loading (mirrors LoopAlgorithmTests.swift)
+
+    typealias Input = LoopPredictionInput<FixtureCarbEntry, FixtureGlucoseSample, FixtureInsulinDose>
+
+    private func loadInput() throws -> Input {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let url = Bundle.module.url(
+            forResource: "live_capture_input",
+            withExtension: "json",
+            subdirectory: "Fixtures"
+        )!
+        return try decoder.decode(Input.self, from: Data(contentsOf: url))
+    }
+
+    // MARK: - Test: annotated-only fast path matches standard output
+
+    func testPrecomputedAnnotationMatchesStandard() throws {
+        let input = try loadInput()
+        let start = input.glucoseHistory.last!.startDate
+
+        // Standard prediction (full annotation inside generatePrediction)
+        let standard = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            doses: input.doses,
+            carbEntries: input.carbEntries,
+            basal: input.basal,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        // Pre-annotate once (ISF-independent); no effects → standard inner glucoseEffects path
+        let precomputed = PrecomputedInsulinInput.annotate(doses: input.doses, basal: input.basal)
+
+        let fast = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            precomputedInsulin: precomputed,
+            carbEntries: input.carbEntries,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        XCTAssertEqual(standard.glucose.count, fast.glucose.count,
+                       "Prediction point count should match")
+        for (s, f) in zip(standard.glucose, fast.glucose) {
+            XCTAssertEqual(s.startDate, f.startDate)
+            XCTAssertEqual(
+                s.quantity.doubleValue(for: .milligramsPerDeciliter),
+                f.quantity.doubleValue(for: .milligramsPerDeciliter),
+                accuracy: 0.001,
+                "Mismatch at \(s.startDate)"
+            )
+        }
+        XCTAssertEqual(standard.activeInsulin ?? 0, fast.activeInsulin ?? 0, accuracy: 0.001)
+    }
+
+    // MARK: - Test: pre-built effects path compiles and returns a prediction
+    //
+    // Bit-identical output is NOT guaranteed (see PrecomputedInsulinInput.insulinEffects
+    // for the timeline-snapping caveat).  This test only verifies that the fast
+    // path runs without crashing and returns the expected number of points.
+
+    func testPrebuiltEffectsFastPathRunsWithoutError() throws {
+        let input = try loadInput()
+        let start = input.glucoseHistory.last!.startDate
+
+        let standard = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            doses: input.doses,
+            carbEntries: input.carbEntries,
+            basal: input.basal,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        // ISF-sweep pattern: annotate once, compute effects per ISF value
+        let precomputed = PrecomputedInsulinInput
+            .annotate(doses: input.doses, basal: input.basal)
+            .withEffects(sensitivity: input.sensitivity)
+
+        let fast = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            precomputedInsulin: precomputed,
+            carbEntries: input.carbEntries,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        XCTAssertEqual(standard.glucose.count, fast.glucose.count,
+                       "Pre-built effects path should return the same number of prediction points")
+        XCTAssertNotNil(fast.activeInsulin)
+    }
+
+    // MARK: - Test: sliced annotated doses round-trip
+
+    func testSlicedAnnotatedDosesMatchStandard() throws {
+        let input = try loadInput()
+        let start = input.glucoseHistory.last!.startDate
+
+        let standard = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            doses: input.doses,
+            carbEntries: input.carbEntries,
+            basal: input.basal,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        // Simulate EvalCore: build once, then pass the (unsliced) annotated set
+        let sliced = PrecomputedInsulinInput.annotate(doses: input.doses, basal: input.basal)
+
+        let fromSlice = LoopAlgorithm.generatePrediction(
+            start: start,
+            glucoseHistory: input.glucoseHistory,
+            precomputedInsulin: sliced,
+            carbEntries: input.carbEntries,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+
+        for (s, f) in zip(standard.glucose, fromSlice.glucose) {
+            XCTAssertEqual(
+                s.quantity.doubleValue(for: .milligramsPerDeciliter),
+                f.quantity.doubleValue(for: .milligramsPerDeciliter),
+                accuracy: 0.001
+            )
+        }
+    }
+
+    // MARK: - Test: ISF sweep pattern — annotate once, withEffects per multiplier
+
+    func testISFSweepPattern() throws {
+        let input = try loadInput()
+        let start = input.glucoseHistory.last!.startDate
+
+        // Annotate ONCE — shared across all ISF values
+        let base = PrecomputedInsulinInput.annotate(doses: input.doses, basal: input.basal)
+
+        let multipliers: [Double] = [0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3]
+
+        for multiplier in multipliers {
+            // Scale ISF — O(n_isf_segments), negligible.
+            // Preserve whatever unit the fixture uses by scaling the raw double
+            // and re-wrapping in the same unit.
+            let scaledSensitivity = input.sensitivity.map { entry -> AbsoluteScheduleValue<LoopQuantity> in
+                let unit = entry.value.unit
+                let scaled = entry.value.doubleValue(for: unit) * multiplier
+                return AbsoluteScheduleValue(
+                    startDate: entry.startDate,
+                    endDate: entry.endDate,
+                    value: LoopQuantity(unit: unit, doubleValue: scaled)
+                )
+            }
+
+            // Compute effects once for this ISF value — O(D × T), not per-step
+            let precomputed = base.withEffects(sensitivity: scaledSensitivity)
+            XCTAssertNotNil(precomputed.insulinEffects, "withEffects should populate insulinEffects")
+
+            // Verify it produces the same result as the standard path with the same scaled ISF
+            let standard = LoopAlgorithm.generatePrediction(
+                start: start,
+                glucoseHistory: input.glucoseHistory,
+                doses: input.doses,
+                carbEntries: input.carbEntries,
+                basal: input.basal,
+                sensitivity: scaledSensitivity,
+                carbRatio: input.carbRatio,
+                useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+            )
+
+            let fast = LoopAlgorithm.generatePrediction(
+                start: start,
+                glucoseHistory: input.glucoseHistory,
+                precomputedInsulin: precomputed,
+                carbEntries: input.carbEntries,
+                sensitivity: scaledSensitivity,
+                carbRatio: input.carbRatio,
+                useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+            )
+
+            XCTAssertEqual(standard.glucose.count, fast.glucose.count,
+                           "Count mismatch at ISF multiplier \(multiplier)")
+            for (s, f) in zip(standard.glucose, fast.glucose) {
+                XCTAssertEqual(
+                    s.quantity.doubleValue(for: .milligramsPerDeciliter),
+                    f.quantity.doubleValue(for: .milligramsPerDeciliter),
+                    accuracy: 0.001,
+                    "ISF \(multiplier)×: mismatch at \(s.startDate)"
+                )
+            }
+        }
+    }
+}
diff --git a/Tests/LoopAlgorithmTests/StandardRetrospectiveCorrectionTests.swift b/Tests/LoopAlgorithmTests/StandardRetrospectiveCorrectionTests.swift
new file mode 100644
index 0000000..9703f84
--- /dev/null
+++ b/Tests/LoopAlgorithmTests/StandardRetrospectiveCorrectionTests.swift
@@ -0,0 +1,233 @@
+//
+//  StandardRetrospectiveCorrectionTests.swift
+//  LoopAlgorithm
+//
+//  Unit tests for StandardRetrospectiveCorrection (the P-only retrospective
+//  correction controller). Standard RC takes the most-recent
+//  prediction-vs-actual discrepancy and projects it forward as a decaying
+//  glucose effect over `effectDuration` (default 60 min).
+//
+
+import XCTest
+@testable import LoopAlgorithm
+
+final class StandardRetrospectiveCorrectionTests: XCTestCase {
+
+    private let unit = LoopUnit.milligramsPerDeciliter
+
+    // MARK: - Helpers
+
+    private let dateFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        return formatter
+    }()
+
+    private func date(_ s: String) -> Date {
+        return dateFormatter.date(from: s)!
+    }
+
+    private func change(from start: Date, to end: Date, mgdl: Double) -> GlucoseChange {
+        return GlucoseChange(startDate: start, endDate: end, quantity: .glucose(mgdl))
+    }
+
+    private func makeRC() -> StandardRetrospectiveCorrection {
+        return StandardRetrospectiveCorrection(
+            effectDuration: LoopMath.retrospectiveCorrectionEffectDuration
+        )
+    }
+
+    // MARK: - Recency gating
+
+    func testStaleDiscrepancyClearsEffect() {
+        // Discrepancy ends > recencyInterval before the starting glucose date.
+        // Effect must be empty + totalGlucoseCorrectionEffect must be nil.
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let discrepancy = change(
+            from: glucoseDate.addingTimeInterval(-.minutes(60)),
+            to: glucoseDate.addingTimeInterval(-.minutes(30)),
+            mgdl: 10
+        )
+        let rc = makeRC()
+        // recencyInterval = 15 min, but discrepancy ends 30 min ago → stale
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [discrepancy],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertTrue(effect.isEmpty, "stale discrepancy should produce no effect")
+        XCTAssertNil(rc.totalGlucoseCorrectionEffect)
+    }
+
+    func testNilDiscrepancyListReturnsEmpty() {
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: nil,
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertTrue(effect.isEmpty)
+        XCTAssertNil(rc.totalGlucoseCorrectionEffect)
+    }
+
+    func testEmptyDiscrepancyListReturnsEmpty() {
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertTrue(effect.isEmpty)
+        XCTAssertNil(rc.totalGlucoseCorrectionEffect)
+    }
+
+    // MARK: - Total correction effect
+
+    func testTotalCorrectionEffectEqualsLatestDiscrepancy() {
+        // Standard RC: totalGlucoseCorrectionEffect == latest discrepancy magnitude.
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(120))
+        let rc = makeRC()
+        _ = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(30)),
+                       to: glucoseDate, mgdl: 15)
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertEqual(rc.totalGlucoseCorrectionEffect?.doubleValue(for: unit), 15.0)
+    }
+
+    // MARK: - Effect projection
+
+    func testPositiveDiscrepancyProjectsForward() {
+        // +12 mg/dL discrepancy over 30 min → decay over 60-min effectDuration.
+        // The integrated effect should ramp from 0 at startingGlucose to ~+12
+        // at endDate of effectDuration.
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(30)),
+                       to: glucoseDate, mgdl: 12)
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertFalse(effect.isEmpty)
+        // Last sample should be roughly startingGlucose + 12 (decay applies the
+        // proportional correction over the effect window)
+        let last = effect.last!.quantity.doubleValue(for: unit)
+        XCTAssertEqual(last, 112.0, accuracy: 0.5,
+            "last projected glucose ≈ starting + discrepancy")
+    }
+
+    func testNegativeDiscrepancyProjectsDownward() {
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(150))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(30)),
+                       to: glucoseDate, mgdl: -10)
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertFalse(effect.isEmpty)
+        let last = effect.last!.quantity.doubleValue(for: unit)
+        XCTAssertEqual(last, 140.0, accuracy: 0.5,
+            "last projected glucose ≈ starting + (negative) discrepancy")
+        XCTAssertEqual(rc.totalGlucoseCorrectionEffect?.doubleValue(for: unit), -10.0)
+    }
+
+    func testEffectStartsAtStartingGlucoseValue() {
+        // First effect sample should equal startingGlucose value (correction
+        // has not yet had time to apply).
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(110))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(30)),
+                       to: glucoseDate, mgdl: 20)
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertFalse(effect.isEmpty)
+        XCTAssertEqual(effect.first!.quantity.doubleValue(for: unit), 110.0, accuracy: 0.01)
+        XCTAssertEqual(effect.first!.startDate, glucoseDate)
+    }
+
+    // MARK: - Multiple discrepancies — only LATEST is used
+
+    func testOnlyMostRecentDiscrepancyIsUsed() {
+        // Standard RC uses ONLY .last — older entries are ignored even when
+        // they would change the answer (this is exactly what IntegralRC fixes).
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let rc = makeRC()
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(150)),
+                       to: glucoseDate.addingTimeInterval(-.minutes(120)), mgdl: 50),  // big older
+                change(from: glucoseDate.addingTimeInterval(-.minutes(60)),
+                       to: glucoseDate.addingTimeInterval(-.minutes(30)), mgdl: 30),   // medium older
+                change(from: glucoseDate.addingTimeInterval(-.minutes(30)),
+                       to: glucoseDate, mgdl: 5),                                       // small latest
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        // Total effect must reflect ONLY the most recent (+5), not the larger older ones.
+        XCTAssertEqual(rc.totalGlucoseCorrectionEffect?.doubleValue(for: unit), 5.0)
+        XCTAssertEqual(effect.last!.quantity.doubleValue(for: unit), 105.0, accuracy: 0.5)
+    }
+
+    // MARK: - Grouping interval clamps short discrepancies
+
+    func testShortDiscrepancyClampedByGroupingInterval() {
+        // If the discrepancy's interval is shorter than retrospectiveCorrection-
+        // GroupingInterval, the velocity calc uses groupingInterval as the
+        // denominator (not the actual interval). This protects against over-
+        // amplified projections from very short discrepancies.
+        let glucoseDate = date("2025-01-01T12:00:00")
+        let startingGlucose = SimpleGlucoseValue(startDate: glucoseDate, quantity: .glucose(100))
+        let rc = makeRC()
+        // Discrepancy is +10 over only 5 minutes (very short window). If we
+        // used 5 min as the denominator, velocity would be 6× larger.
+        let effect = rc.computeEffect(
+            startingAt: startingGlucose,
+            retrospectiveGlucoseDiscrepanciesSummed: [
+                change(from: glucoseDate.addingTimeInterval(-.minutes(5)),
+                       to: glucoseDate, mgdl: 10)
+            ],
+            recencyInterval: .minutes(15),
+            retrospectiveCorrectionGroupingInterval: .minutes(30)
+        )
+        XCTAssertFalse(effect.isEmpty)
+        // Total effect over the effectDuration should still be ~+10 (the
+        // proportional correction), but spread over the full duration not
+        // amplified for the short window.
+        let last = effect.last!.quantity.doubleValue(for: unit)
+        XCTAssertEqual(last, 110.0, accuracy: 0.5)
+    }
+}