First separator version

Author: altavir

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/LateBindDeviceState.kt

@@ -1,7 +1,6 @@
 package space.kscience.controls.constructor
 
 import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
@@ -15,7 +14,6 @@ import kotlinx.coroutines.flow.flow
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 public class LateBindDeviceState<T>(
-    scope: CoroutineScope,
     private val initialValue: T
 ) : DeviceState<T> {
 

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousBuffer.kt

@@ -28,8 +28,8 @@ public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
     public val algebra: AmountAlgebra<U, T>,
     public val bufferCapacity: DeviceState<Numeric<U>>,
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(context, algebra.zero),
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(context, Numeric.zero()),
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState( algebra.zero),
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero()),
     initialLevel: T = algebra.zero,
     timeStep: Duration = 1.seconds
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T>, ContinuousConsumerInterface<U, T> {

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousConsumer.kt

@@ -43,7 +43,7 @@ public class ContinuousConsumer<U : UnitsOfMeasurement, T : Amount<U>>(
     override val consumationCapacity: DeviceState<Numeric<U>>,
 ) : ModelConstructor(context), ContinuousConsumerInterface<U, T> {
 
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(this, algebra.zero)
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(algebra.zero)
 
     init {
         registerState(consumationCapacity)

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousMix.kt

@@ -32,11 +32,11 @@ public class ContinuousMix<U : UnitsOfMeasurement, T : Amount<U>>(
     private val joinManagementStrategy: JoinManagementStrategy = JoinManagementStrategy.PROPORTIONAL,
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(this, Numeric.zero())
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero())
 
 
     public val supplyRequest: Map<String, LateBindDeviceState<T>> = supplyKeys.associateWith {
-        LateBindDeviceState(this, algebra.zero)
+        LateBindDeviceState( algebra.zero)
     }
 
 
@@ -125,7 +125,7 @@ public fun <U : UnitsOfMeasurement> ContinuousMix(
     outputNames: Collection<String>,
     joinManagementStrategy: JoinManagementStrategy = JoinManagementStrategy.PROPORTIONAL
 ): ContinuousMix<U, Numeric<U>> =
-    ContinuousMix(context, NumericAmountAlgebra<U>(), outputNames, joinManagementStrategy)
+    ContinuousMix(context, NumericAmountAlgebra(), outputNames, joinManagementStrategy)
 
 /**
  * Creates a consumer instance for a specific supply key from a continuous mix instance.

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousProducer.kt

@@ -42,7 +42,7 @@ public class ContinuousProducer<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
     public val algebra: AmountAlgebra<U, T>,
     override val productionCapacity: DeviceState<T>,
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(context,Numeric.zero()),
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero()),
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
 
     init {

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousReaction.kt

@@ -79,9 +79,9 @@ public class ContinuousReaction<U : UnitsOfMeasurement, T : Amount<U>>(
     public val reaction: ReactionRule<U, T>,
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(this, Numeric.zero())
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero())
     public val supplyRequest: Map<String, LateBindDeviceState<T>> = reaction.supplyKeys.associateWith {
-        LateBindDeviceState(this, algebra.zero)
+        LateBindDeviceState( algebra.zero)
     }
 
 

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousSeparate.kt

@@ -34,6 +34,7 @@ public interface SeparationRule<U : UnitsOfMeasurement, T : Amount<U>> {
             }
 
         }
+
     }
 }
 
@@ -43,10 +44,10 @@ public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
     public val rule: SeparationRule<U, T>,
 ) : ModelConstructor(context), ContinuousConsumerInterface<U, T> {
 
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(this, algebra.zero)
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState( algebra.zero)
 
     public val consumationRequest: Map<String, LateBindDeviceState<Numeric<U>>> = rule.productionKeys.associateWith {
-        LateBindDeviceState(this, Numeric.zero())
+        LateBindDeviceState( Numeric.zero())
     }
 
     private val jointConsumationRequest: DeviceState<Map<String, Numeric<U>>> = combineState(consumationRequest) {
@@ -58,9 +59,9 @@ public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
         second = jointConsumationRequest
     ) { supply: T, consumation: Map<String, Numeric<U>> ->
         val expectation = rule.forward(supply)
-        val limitingFactor = expectation.minOf { (key, value) ->
+        val limitingFactor = expectation.minOfOrNull { (key, value) ->
             (consumation[key] ?: Numeric.zero()).value / value.value
-        }
+        } ?: 0.0
         with(algebra) {
             supply * limitingFactor to expectation.mapValues { (key, value) -> supply * limitingFactor }
         }
@@ -69,7 +70,7 @@ public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
     public val production: DeviceState<Map<String, T>> = mapState(balance) { it.second }
 
     public val individualProduction: Map<String, DeviceState<T>> = rule.productionKeys.associateWith { key ->
-        mapState(production) { it[key]!! }
+        mapState(production) { it[key] ?: algebra.zero }
     }
 
     public val productionCapacity: DeviceState<Map<String, T>> = combineState(
@@ -84,7 +85,7 @@ public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
     }
 
     public val individualProductionCapacity: Map<String, DeviceState<T>> = rule.productionKeys.associateWith { key ->
-        mapState(productionCapacity) { it[key]!! }
+        mapState(productionCapacity) { it[key] ?: algebra.zero }
     }
 
     override val consumation: DeviceState<T> = mapState(balance) { it.first }

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/ContinuousTransformer.kt

@@ -45,8 +45,8 @@ public class ContinuousTransformer<U1 : UnitsOfMeasurement, T : Amount<U1>, U2 :
     public val rule: ContinuousTransformationRule<U1, T, U2, R>,
 ) : ModelConstructor(context), ContinuousProducerInterface<U2, R>, ContinuousConsumerInterface<U1, T> {
 
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(this, supplyAlgebra.zero)
-    override val consumerRequest: LateBindDeviceState<Numeric<U2>> = LateBindDeviceState(this, Numeric.zero())
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(supplyAlgebra.zero)
+    override val consumerRequest: LateBindDeviceState<Numeric<U2>> = LateBindDeviceState(Numeric.zero())
 
     override val consumation: DeviceState<T> = combineState(supplyRequest, consumerRequest) { supply, consume ->
         with(supplyAlgebra) {

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/models/continuous/modifications.kt

@@ -11,38 +11,52 @@ import space.kscience.controls.constructor.units.Numeric
 import space.kscience.controls.constructor.units.UnitsOfMeasurement
 import kotlin.time.Duration
 
+/**
+ * Delays the emission of the values from the current [DeviceState] by a specified [delay] duration.
+ *
+ * @param scope The [CoroutineScope] used to manage the asynchronous operation of delaying the values.
+ * @param delay The delay duration to apply to each value emitted by the [DeviceState].
+ * @return A new [DeviceState] that emits delayed values from the current state by the specified [delay].
+ */
+public fun <T> DeviceState<T>.delayedBy(scope: CoroutineScope, delay: Duration): DeviceState<T> =
+    DeviceState.transform(scope, this, value) {
+        delay(delay)
+        it
+    }
 
+/**
+ * Delays the emission of values from the production and productionCapacity properties of a
+ * [ContinuousProducerInterface] by a specified duration.
+ *
+ * @param scope The [CoroutineScope] used to manage the asynchronous operation of delaying values.
+ * @param delay The duration by which the values are delayed.
+ * @return A new [ContinuousProducerInterface] with production and productionCapacity values delayed by the specified duration.
+ */
 public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousProducerInterface<U, T>.delayed(
     scope: CoroutineScope,
-    delay: Duration
+    delay: Duration,
 ): ContinuousProducerInterface<U, T> = object : ContinuousProducerInterface<U, T> {
 
-    override val production: DeviceState<T> = DeviceState.transform(
-        scope = scope,
-        state = this@delayed.production,
-        initialValue = this@delayed.production.value
-    ) {
-        delay(delay)
-        it
-    }
+    override val production: DeviceState<T> = this@delayed.production
 
+    override val productionCapacity: DeviceState<T> get() = this@delayed.productionCapacity.delayedBy(scope, delay)
 
-    override val productionCapacity: DeviceState<T> get() = this@delayed.productionCapacity
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero())
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> get() = this@delayed.consumerRequest
+    init {
+        this@delayed.consumerRequest.bind(consumerRequest.delayedBy(scope, delay))
+    }
 }
 
 public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousProducerInterface<U, T>.limited(
     scope: CoroutineScope,
     productionLimit: DeviceState<Numeric<U>>
 ): ContinuousProducerInterface<U, T> = object : ContinuousProducerInterface<U, T> {
-    override val production: DeviceState<T>
-        get() = this@limited.production
+    override val production: DeviceState<T> get() = this@limited.production
 
-    override val productionCapacity: DeviceState<T>
-        get() = this@limited.productionCapacity
+    override val productionCapacity: DeviceState<T> get() = this@limited.productionCapacity
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(scope,productionLimit.value)
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(productionLimit.value)
 
     private val limitedValue: DeviceState<Numeric<U>> = DeviceState.combine(
         scope,

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/units/AmountAlgebra.kt

@@ -35,22 +35,18 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> AmountAlgebra<U, T>.maxOf(fir
 public fun <U : UnitsOfMeasurement, T : Amount<U>> AmountAlgebra<U, T>.sum(args: Iterable<T>): T =
     args.fold(zero) { acc, t -> acc + t }
 
-private object NumericAmountAlgebra : AmountAlgebra<Nothing, Numeric<Nothing>> {
-    override fun Numeric<Nothing>.plus(other: Numeric<Nothing>): Numeric<Nothing> = Numeric(value + other.value)
+public open class NumericAmountAlgebra<U: UnitsOfMeasurement> : AmountAlgebra<U, Numeric<U>> {
+    override fun Numeric<U>.plus(other: Numeric<U>): Numeric<U> = Numeric(value + other.value)
 
-    override fun Numeric<Nothing>.minus(other: Numeric<Nothing>): Numeric<Nothing> = Numeric(value - other.value)
+    override fun Numeric<U>.minus(other: Numeric<U>): Numeric<U> = Numeric(value - other.value)
 
-    override fun Numeric<Nothing>.unaryMinus(): Numeric<Nothing> = Numeric(-value)
+    override fun Numeric<U>.unaryMinus(): Numeric<U> = Numeric(-value)
 
-    override fun Numeric<Nothing>.times(scale: Number): Numeric<Nothing> = Numeric(value * scale.toDouble())
+    override fun Numeric<U>.times(scale: Number): Numeric<U> = Numeric(value * scale.toDouble())
 
-    override fun Numeric<Nothing>.div(scale: Number): Numeric<Nothing> = Numeric(value / scale.toDouble())
+    override fun Numeric<U>.div(scale: Number): Numeric<U> = Numeric(value / scale.toDouble())
 
-    override val zero: Numeric<Nothing> = Numeric(0.0)
+    override val zero: Numeric<U> = Numeric(0.0)
 
-    override val one: Numeric<Nothing> = Numeric(1.0)
-}
-
-@Suppress("UNCHECKED_CAST", "FunctionName")
-public fun <U : UnitsOfMeasurement> NumericAmountAlgebra(): AmountAlgebra<U, Numeric<U>> =
-    NumericAmountAlgebra as AmountAlgebra<U, Numeric<U>>
+    override val one: Numeric<U> = Numeric(1.0)
+}