//

// LoopAlgorithm.swift

//

// Created by Pete Schwamb on 6/30/23.

// Copyright © 2023 LoopKit Authors. All rights reserved.

//

import Foundation

public enum AlgorithmError: Error {

case missingGlucose

case glucoseTooOld

case basalTimelineIncomplete

case missingSuspendThreshold

case sensitivityTimelineStartsTooLate

case sensitivityTimelineEndsTooEarly

case futureBasalNotAllowed

}

public struct LoopAlgorithmEffects<CarbStatusType: CarbEntry> {

public var insulin: [GlucoseEffect]

public var carbs: [GlucoseEffect]

public var carbStatus: [CarbStatus<CarbStatusType>]

public var retrospectiveCorrection: [GlucoseEffect]

public var momentum: [GlucoseEffect]

public var insulinCounteraction: [GlucoseEffectVelocity]

public var retrospectiveGlucoseDiscrepancies: [GlucoseChange]

public var totalRetrospectiveCorrectionEffect: LoopQuantity?

public init(

insulin: [GlucoseEffect],

carbs: [GlucoseEffect],

carbStatus: [CarbStatus<CarbStatusType>],

retrospectiveCorrection: [GlucoseEffect],

momentum: [GlucoseEffect],

insulinCounteraction: [GlucoseEffectVelocity],

retrospectiveGlucoseDiscrepancies: [GlucoseChange],

totalRetrospectiveCorrectionEffect: LoopQuantity? = nil

) {

self.insulin = insulin

self.carbs = carbs

self.carbStatus = carbStatus

self.retrospectiveCorrection = retrospectiveCorrection

self.momentum = momentum

self.insulinCounteraction = insulinCounteraction

self.retrospectiveGlucoseDiscrepancies = retrospectiveGlucoseDiscrepancies

self.totalRetrospectiveCorrectionEffect = totalRetrospectiveCorrectionEffect

}

}

extension LoopAlgorithmEffects<FixtureCarbEntry>: Codable {

public init(from decoder: Decoder) throws {

let container = try decoder.container(keyedBy: CodingKeys.self)

self.insulin = try container.decode([GlucoseEffect].self, forKey: .insulin)

self.carbs = try container.decode([GlucoseEffect].self, forKey: .carbs)

self.carbStatus = try container.decode([CarbStatus<FixtureCarbEntry>].self, forKey: .carbStatus)

self.retrospectiveCorrection = try container.decode([GlucoseEffect].self, forKey: .retrospectiveCorrection)

self.momentum = try container.decode([GlucoseEffect].self, forKey: .momentum)

self.insulinCounteraction = try container.decode([GlucoseEffectVelocity].self, forKey: .insulinCounteraction)

self.retrospectiveGlucoseDiscrepancies = try container.decode([GlucoseChange].self, forKey: .retrospectiveGlucoseDiscrepancies)

if let totalRetrospectiveCorrectionEffectValue = try container.decodeIfPresent(Double.self, forKey: .totalRetrospectiveCorrectionEffect) {

self.totalRetrospectiveCorrectionEffect = LoopQuantity(

unit: .milligramsPerDeciliter,

doubleValue: totalRetrospectiveCorrectionEffectValue

)

}

}

public func encode(to encoder: Encoder) throws {

var container = encoder.container(keyedBy: CodingKeys.self)

try container.encode(insulin, forKey: .insulin)

try container.encode(carbs, forKey: .carbs)

try container.encode(carbStatus, forKey: .carbStatus)

try container.encode(retrospectiveCorrection, forKey: .retrospectiveCorrection)

try container.encode(momentum, forKey: .momentum)

try container.encode(insulinCounteraction, forKey: .insulinCounteraction)

try container.encode(retrospectiveGlucoseDiscrepancies, forKey: .retrospectiveGlucoseDiscrepancies)

if let totalRetrospectiveCorrectionEffect {

try container.encode(

totalRetrospectiveCorrectionEffect.doubleValue(for: .milligramsPerDeciliter),

forKey: .totalRetrospectiveCorrectionEffect

)

}

}

private enum CodingKeys: String, CodingKey {

case insulin

case carbs

case carbStatus

case retrospectiveCorrection

case momentum

case insulinCounteraction

case retrospectiveGlucoseDiscrepancies

case totalRetrospectiveCorrectionEffect

}

}

public struct AlgorithmEffectsOptions: OptionSet, Sendable {

public let rawValue: UInt8

public static let carbs = AlgorithmEffectsOptions(rawValue: 1 << 0)

public static let insulin = AlgorithmEffectsOptions(rawValue: 1 << 1)

public static let momentum = AlgorithmEffectsOptions(rawValue: 1 << 2)

public static let retrospection = AlgorithmEffectsOptions(rawValue: 1 << 3)

public static let all: AlgorithmEffectsOptions = [.carbs, .insulin, .momentum, .retrospection]

public init(rawValue: UInt8) {

self.rawValue = rawValue

}

}

public struct LoopPrediction<CarbStatusType: CarbEntry> {

public var glucose: [PredictedGlucoseValue]

public var effects: LoopAlgorithmEffects<CarbStatusType>

public var dosesRelativeToBasal: [BasalRelativeDose]

public var activeInsulin: Double?

public var activeCarbs: Double?

}

public struct LoopAlgorithm {

/// Percentage of recommended dose to apply as bolus when using automatic bolus dosing strategy

static public let defaultBolusPartialApplicationFactor = 0.4

/// The duration of recommended temp basals

static public let tempBasalDuration = TimeInterval(minutes: 30)

/// The amount of time since a given date that input data should be considered valid

public static let inputDataRecencyInterval = TimeInterval(minutes: 15)

/// Calculates the needed interval for insulin sensitivity to run the algorithm

/// - Parameters:

/// - doses: The active doses affecting the forecast

/// - glucoseHistoryStart: The start date of glucose history

/// - recommendationEffectInterval:The interval covering effects of a recommended dose

public static func timelineIntervalForSensitivity<DoseType: InsulinDose>(

doses: [DoseType],

glucoseHistoryStart: Date,

recommendationEffectInterval: DateInterval

) -> DateInterval {

return (doses.effectsInterval() ?? DateInterval(start: glucoseHistoryStart, end: glucoseHistoryStart))

.extendedToInclude(glucoseHistoryStart)

.extendedToInclude(recommendationEffectInterval)

.extendedForSimulation()

}

/// Generates a forecast predicting glucose.

/// Outputs may be incomplete, if there are issues with the provided data, but as many intermediate derived fields as can be computed, will be computed.

///

/// Returns nil if the normal scheduled basal, or active temporary basal, is sufficient.

///

///

/// - Parameters:

/// - start: The starting time of the glucose prediction.

/// - glucoseHistory: History of glucose values: t-10h to t. Must include at least one value.

/// - doses: History of insulin doses: t-16h to t

/// - carbEntries: History of carb entries: t-10h to t

/// - basal: Scheduled basal rate timeline: t-16h to t

/// - sensitivity: Insulin sensitivity timeline: t-16h to t (eventually with mid-absorption isf changes, it will be t-10h to t)

/// - carbRatio: Carb ratio timeline: t-10h to t+6h

/// - algorithmEffectsOptions: Which effects to include when combining effects to generate glucose prediction

/// - useIntegralRetrospectiveCorrection: If true, the prediction will use Integral Retrospection. If false, will use traditional Retrospective Correction

/// - includingPositiveVelocityAndRC: If false, only net negative momentum and RC effects will used.

/// - carbAbsorptionModel: A model conforming to CarbAbsorptionComputable that is used for computing carb absorption over time.

/// - Returns: A LoopPrediction struct containing the predicted glucose and the computed intermediate effects used to make the prediction

public static func generatePrediction<CarbType, GlucoseType, InsulinDoseType>(

start: Date,

glucoseHistory: [GlucoseType],

doses: [InsulinDoseType],

carbEntries: [CarbType],

basal: [AbsoluteScheduleValue<Double>],

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, InsulinDoseType: InsulinDose {

var prediction: [PredictedGlucoseValue] = []

var insulinEffects: [GlucoseEffect] = []

var carbEffects: [GlucoseEffect] = []

var retrospectiveCorrectionEffects: [GlucoseEffect] = []

var momentumEffects: [GlucoseEffect] = []

var insulinCounteractionEffects: [GlucoseEffectVelocity] = []

var retrospectiveGlucoseDiscrepanciesSummed: [GlucoseChange] = []

var totalRetrospectiveCorrectionEffect: LoopQuantity?

var activeInsulin: Double?

var activeCarbs: Double?

//var carbStatus: [CarbStatus] = []

var dosesRelativeToBasal: [BasalRelativeDose] = []

// Ensure basal history covers doses

let doseStart = doses.first?.startDate ?? start

if !basal.isEmpty, basal.first!.startDate <= doseStart {

// Overlay basal history on basal doses, splitting doses to get amount delivered relative to basal

dosesRelativeToBasal = doses.annotated(with: basal)

activeInsulin = dosesRelativeToBasal.insulinOnBoard(at: start)

var insulinEffectsInterval = dosesRelativeToBasal.effectsInterval() ?? DateInterval(start: start, end: start)

// Extend range of insulin effects to cover glucose, if needed

if let glucoseStart = glucoseHistory.first?.startDate, glucoseStart < insulinEffectsInterval.start {

insulinEffectsInterval = insulinEffectsInterval.extendedToInclude(glucoseStart)

}

if let glucoseEnd = glucoseHistory.last?.endDate, glucoseEnd > insulinEffectsInterval.end {

insulinEffectsInterval = insulinEffectsInterval.extendedToInclude(glucoseEnd)

}

if useMidAbsorptionISF {

insulinEffects = dosesRelativeToBasal.glucoseEffectsMidAbsorptionISF(

insulinSensitivityHistory: sensitivity,

from: insulinEffectsInterval.start,

to: insulinEffectsInterval.end)

} else {

insulinEffects = dosesRelativeToBasal.glucoseEffects(

insulinSensitivityHistory: sensitivity,

from: insulinEffectsInterval.start,

to: insulinEffectsInterval.end)

}

// ICE

insulinCounteractionEffects = glucoseHistory.counteractionEffects(to: insulinEffects)

} else {

activeInsulin = 0

}

// Carb Effects

let carbStatus = carbEntries.map(

to: insulinCounteractionEffects,

carbRatio: carbRatio,

insulinSensitivity: sensitivity

)

carbEffects = carbStatus.dynamicGlucoseEffects(

from: start.addingTimeInterval(-IntegralRetrospectiveCorrection.retrospectionInterval),

carbRatios: carbRatio,

insulinSensitivities: sensitivity,

absorptionModel: carbAbsorptionModel

)

activeCarbs = carbStatus.dynamicCarbsOnBoard(at: start, absorptionModel: carbAbsorptionModel)

// RC

let retrospectiveGlucoseDiscrepancies = insulinCounteractionEffects.subtracting(carbEffects)

retrospectiveGlucoseDiscrepanciesSummed = retrospectiveGlucoseDiscrepancies.combinedSums(of: LoopMath.retrospectiveCorrectionGroupingInterval * 1.01)

let rc: RetrospectiveCorrection

if useIntegralRetrospectiveCorrection {

rc = IntegralRetrospectiveCorrection(effectDuration: LoopMath.retrospectiveCorrectionEffectDuration)

} else {

rc = StandardRetrospectiveCorrection(effectDuration: LoopMath.retrospectiveCorrectionEffectDuration)

}

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) {

// Check if glucose data is smooth enough for RC

// Use the same input window as retrospective correction

var useRC: Bool = true

// Don't apply RC if glucose has large jumps

let rcTransitionData = glucoseHistory.filterDateRange(

start.addingTimeInterval(-LoopMath.retrospectiveCorrectionGroupingInterval),

start

)

if !rcTransitionData.hasGradualTransitions(gradualTransitionThreshold: gradualTransitionsThreshold ?? 40.0) {

useRC = false

}

// Don't apply positive RC if that setting is disabled

if !includingPositiveVelocityAndRC,

let netRC = retrospectiveCorrectionEffects.netEffect(),

netRC.quantity.doubleValue(for: .milligramsPerDeciliter) > 0 {

useRC = false

}

if useRC {

effects.append(retrospectiveCorrectionEffects)

}

}

// Glucose Momentum

var useMomentum: Bool = 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 {

// positive momentum is turned off

useMomentum = false

}

} else {

useMomentum = false

}

prediction = LoopMath.predictGlucose(

startingAt: latestGlucose,

momentum: useMomentum ? momentumEffects : [],

effects: effects

)

// Dosing requires prediction entries at least as long as the insulin model duration.

// If our prediction is shorter than that, then extend it here.

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

)

}

/// 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> {

return generatePrediction(

start: input.glucoseHistory.last?.startDate ?? Date(),

glucoseHistory: input.glucoseHistory,

doses: input.doses,

carbEntries: input.carbEntries,

basal: input.basal,

sensitivity: input.sensitivity,

carbRatio: input.carbRatio,

algorithmEffectsOptions: input.algorithmEffectsOptions,

useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection,

carbAbsorptionModel: input.carbAbsorptionModel.model,

gradualTransitionsThreshold: input.gradualTransitionsThreshold

)

}

// Computes an amount of insulin to correct the given prediction

public static func insulinCorrection(

prediction: [PredictedGlucoseValue],

at deliveryDate: Date,

target: GlucoseRangeTimeline,

suspendThreshold: LoopQuantity,

sensitivity: [AbsoluteScheduleValue<LoopQuantity>],

insulinModel: InsulinModel

) -> InsulinCorrection {

return prediction.insulinCorrection(

to: target,

at: deliveryDate,

suspendThreshold: suspendThreshold,

insulinSensitivity: sensitivity,

model: insulinModel)

}

// Computes a 30 minute temp basal dose to correct the given prediction

public static func recommendTempBasal(

for correction: InsulinCorrection,

neutralBasalRate: Double,

activeInsulin: Double,

maxBolus: Double,

maxBasalRate: Double,

maxActiveInsulin: Double

) -> TempBasalRecommendation {

var maxBasalRate = maxBasalRate

// TODO: Allow `highBasalThreshold` to be a configurable setting

if case .aboveRange(min: let min, correcting: _, minTarget: let highBasalThreshold, units: _) = correction,

min.quantity < highBasalThreshold

{

maxBasalRate = neutralBasalRate

}

// Enforce max active insulin

let activeInsulinHeadroom = maxActiveInsulin - activeInsulin

let maxThirtyMinuteRateToKeepActiveInsulinBelowLimit = activeInsulinHeadroom * (TimeInterval.hours(1) / tempBasalDuration) + neutralBasalRate // 30 minutes of a U/hr rate

maxBasalRate = Swift.min(maxThirtyMinuteRateToKeepActiveInsulinBelowLimit, maxBasalRate)

return correction.asTempBasal(

neutralBasalRate: neutralBasalRate,

maxBasalRate: maxBasalRate,

duration: tempBasalDuration

)

}

// Computes a bolus or low-temp basal dose to correct the given prediction

public static func recommendAutomaticDose(

for correction: InsulinCorrection,

applicationFactor: Double,

neutralBasalRate: Double,

activeInsulin: Double,

maxBolus: Double,

maxBasalRate: Double,

maxActiveInsulin: Double

) -> AutomaticDoseRecommendation {

let deliveryHeadroom = max(0, maxActiveInsulin - activeInsulin)

var deliveryMax = min(maxBolus * applicationFactor, deliveryHeadroom)

if case .aboveRange(min: let min, correcting: _, minTarget: let minTarget, units: _) = correction,

min.quantity < minTarget

{

deliveryMax = 0

}

let temp: TempBasalRecommendation = correction.asTempBasal(

neutralBasalRate: neutralBasalRate,

maxBasalRate: neutralBasalRate,

duration: .minutes(30)

)

let bolusUnits = correction.asPartialBolus(

partialApplicationFactor: applicationFactor,

maxBolusUnits: deliveryMax

)

return AutomaticDoseRecommendation(basalAdjustment: temp, direction: .from(correction: correction), bolusUnits: bolusUnits)

}

// Computes a manual bolus to correct the given prediction

public static func recommendManualBolus(

for correction: InsulinCorrection,

maxBolus: Double,

currentGlucose: GlucoseSampleValue,

target: GlucoseRangeTimeline

) -> ManualBolusRecommendation {

var bolus = correction.asManualBolus(maxBolus: maxBolus)

if let targetAtCurrentGlucose = target.closestPrior(to: currentGlucose.startDate),

currentGlucose.quantity < targetAtCurrentGlucose.value.lowerBound

{

bolus.notice = .currentGlucoseBelowTarget(glucose: SimpleGlucoseValue(currentGlucose))

}

return bolus

}

public static func run<LoopAlgorithmInputType: AlgorithmInput>(input: LoopAlgorithmInputType) -> AlgorithmOutput<LoopAlgorithmInputType.CarbType> {

var prediction = LoopPrediction(

glucose: [],

effects: LoopAlgorithmEffects(

insulin: [],

carbs: [],

carbStatus: [CarbStatus<LoopAlgorithmInputType.CarbType>](),

retrospectiveCorrection: [],

momentum: [],

insulinCounteraction: [],

retrospectiveGlucoseDiscrepancies: []

),

dosesRelativeToBasal: []

)

// Now validate/recommend

let result: Result<LoopAlgorithmDoseRecommendation,Error>

do {

guard let latestGlucose = input.glucoseHistory.last else {

throw AlgorithmError.missingGlucose

}

guard input.predictionStart.timeIntervalSince(latestGlucose.startDate) < inputDataRecencyInterval else {

throw AlgorithmError.glucoseTooOld

}

// When running the algorithm for automated dosing, future basal should not be included

if let basalEnd = input.doses.filter({ $0.deliveryType == .basal }).map({ $0.endDate }).max() {

guard !input.recommendationType.automated || basalEnd <= input.predictionStart else {

throw AlgorithmError.futureBasalNotAllowed

}

}

let forecastEnd = input.predictionStart.addingTimeInterval(input.recommendationInsulinModel.effectDuration).dateCeiledToTimeInterval(GlucoseMath.defaultDelta)

let glucoseStart = input.glucoseHistory.first?.startDate ?? input.predictionStart

// Make sure ISF covers needed timeline

let recommendationEffectInterval = DateInterval(

start: input.predictionStart,

duration: input.recommendationInsulinModel.effectDuration)

let neededISFInterval = timelineIntervalForSensitivity(

doses: input.doses,

glucoseHistoryStart: glucoseStart,

recommendationEffectInterval: recommendationEffectInterval

)

guard let sensitivityStartDate = input.sensitivity.first?.startDate, sensitivityStartDate <= neededISFInterval.start else {

throw AlgorithmError.sensitivityTimelineStartsTooLate

}

guard let sensitivityEndDate = input.sensitivity.last?.endDate, sensitivityEndDate >= neededISFInterval.end else {

throw AlgorithmError.sensitivityTimelineEndsTooEarly

}

// Make sure Basal covers needed timeline

guard let scheduledBasalRate = input.basal.closestPrior(to: input.predictionStart)?.value else {

throw AlgorithmError.basalTimelineIncomplete

}

guard let suspendThreshold = input.suspendThreshold ?? input.target.closestPrior(to: input.predictionStart)?.value.lowerBound else {

throw AlgorithmError.missingSuspendThreshold

}

prediction = generatePrediction(

start: input.predictionStart,

glucoseHistory: input.glucoseHistory,

doses: input.doses,

carbEntries: input.carbEntries,

basal: input.basal,

sensitivity: input.sensitivity,

carbRatio: input.carbRatio,

algorithmEffectsOptions: .all,

useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection,

includingPositiveVelocityAndRC: input.includePositiveVelocityAndRC,

useMidAbsorptionISF: input.useMidAbsorptionISF,

carbAbsorptionModel: input.carbAbsorptionModel.model,

gradualTransitionsThreshold: input.gradualTransitionsThreshold

)

let sensitivityForDosing: [AbsoluteScheduleValue<LoopQuantity>]

if input.useMidAbsorptionISF {

sensitivityForDosing = input.sensitivity

} else {

// This sets a single ISF value for the duration of the dose.

let sensitivityEnd = max(forecastEnd, prediction.effects.insulin.last?.startDate ?? .distantPast)

let sensitivityAtPredictionStart = input.sensitivity.first { $0.startDate <= input.predictionStart && $0.endDate >= input.predictionStart }!

let sensitivityOverPrediction = AbsoluteScheduleValue(

startDate: sensitivityAtPredictionStart.startDate,

endDate: sensitivityEnd,

value: sensitivityAtPredictionStart.value

)

sensitivityForDosing = [sensitivityOverPrediction]

}

let correction = insulinCorrection(

prediction: prediction.glucose,

at: input.predictionStart,

target: input.target,

suspendThreshold: suspendThreshold,

sensitivity: sensitivityForDosing,

insulinModel: input.recommendationInsulinModel)

let maxActiveInsulin = input.maxBolus * (input.maxActiveInsulinMultiplier ?? 2)

switch input.recommendationType {

case .manualBolus:

let recommendation = recommendManualBolus(

for: correction,

maxBolus: input.maxBolus,

currentGlucose: latestGlucose,

target: input.target)

result = .success(.init(manual: recommendation))

case .automaticBolus:

let recommendation = recommendAutomaticDose(

for: correction,

applicationFactor: input.automaticBolusApplicationFactor ?? defaultBolusPartialApplicationFactor,

neutralBasalRate: scheduledBasalRate,

activeInsulin: prediction.activeInsulin!,

maxBolus: input.maxBolus,

maxBasalRate: input.maxBasalRate,

maxActiveInsulin: maxActiveInsulin)

result = .success(.init(automatic: recommendation))

case .tempBasal:

let recommendation = recommendTempBasal(

for: correction,

neutralBasalRate: scheduledBasalRate,

activeInsulin: prediction.activeInsulin!,

maxBolus: input.maxBolus,

maxBasalRate: input.maxBasalRate,

maxActiveInsulin: maxActiveInsulin)

result = .success(.init(automatic: AutomaticDoseRecommendation(basalAdjustment: recommendation, direction: .from(correction: correction))))

}

} catch {

result = .failure(error)

}

return AlgorithmOutput(

recommendationResult: result,

predictedGlucose: prediction.glucose,

effects: prediction.effects,

dosesRelativeToBasal: prediction.dosesRelativeToBasal,

activeInsulin: prediction.activeInsulin,

activeCarbs: prediction.activeCarbs

)

}

}