Add algebra to all consumers and producers

Author: altavir

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

@@ -14,7 +14,7 @@ import kotlin.time.Duration.Companion.seconds
  * @param U The unit of measurement associated with the buffer contents.
  * @param T The amount type representing the measurable quantity stored in the buffer.
  * @param context The simulation context in which the buffer operates.
- * @param algebra The algebraic operations to manipulate the amount type.
+ * @param consumerAlgebra The algebraic operations to manipulate the amount type.
  * @param bufferCapacity The maximum capacity of the buffer as a device state.
  * @param supplyRequest A device state representing the amount requested to be added to the buffer.
  * @param consumerRequest A device state representing the amount requested to be consumed from the buffer.
@@ -26,14 +26,16 @@ import kotlin.time.Duration.Companion.seconds
  */
 public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val consumerAlgebra: AmountAlgebra<U, T>,
     public val bufferCapacity: DeviceState<Numeric<U>>,
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState( algebra.zero),
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero()),
-    initialLevel: T = algebra.zero,
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(consumerAlgebra.zero),
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero()),
+    initialLevel: T = consumerAlgebra.zero,
     timeStep: Duration = 1.seconds
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T>, ContinuousConsumerInterface<U, T> {
 
+    override val producerAlgebra: AmountAlgebra<U, T> get() = consumerAlgebra
+
     private val _content: MutableDeviceState<T> = MutableDeviceState(initialLevel)
 
     public val content: DeviceState<T> get() = _content
@@ -49,7 +51,7 @@ public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
         supplyRequest,
         content
     ) { supplyRequest: T, content: T ->
-        with(algebra) {
+        with(consumerAlgebra) {
             supplyRequest + content
         }
     }
@@ -59,7 +61,7 @@ public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
         content,
         consumerRequest
     ) { supplyRequest, content, consumeRequest ->
-        with(algebra) {
+        with(consumerAlgebra) {
             val productionCapacity = supplyRequest + content
             productionCapacity.coerceValueIn(Numeric.zero<U>()..consumeRequest)
         }
@@ -79,7 +81,7 @@ public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
         content,
         consumerRequest
     ) { supplyRequest: T, bufferCapacity, content, consumationRequest ->
-        with(algebra) {
+        with(consumerAlgebra) {
             val remainingSpace = bufferCapacity - Numeric<U>(content.value)
             val consumationCapacity = remainingSpace + consumationRequest
             supplyRequest.coerceValueIn(Numeric.zero<U>()..consumationCapacity)
@@ -91,7 +93,7 @@ public class ContinuousBuffer<U : UnitsOfMeasurement, T : Amount<U>>(
         reads = listOf(production, consumation, bufferCapacity),
         writes = listOf(content)
     ) { prev, next ->
-        with(algebra) {
+        with(consumerAlgebra) {
             delay(timeStep)
 
             val delta = consumation.value - production.value
@@ -132,7 +134,7 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousFlowModel.buffer(
 ): ContinuousBuffer<U, T> = model(
     ContinuousBuffer(
         context = context,
-        algebra = algebra,
+        consumerAlgebra = algebra,
         bufferCapacity = DeviceState(bufferCapacity),
         initialLevel = initialLevel,
         timeStep = timeStep

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

@@ -5,13 +5,19 @@ import space.kscience.controls.constructor.units.*
 import space.kscience.dataforge.context.Context
 
 public interface ContinuousConsumerInterface<U : UnitsOfMeasurement, T : Amount<U>> {
+    public val consumerAlgebra: AmountAlgebra<U, T>
+
     public val consumation: DeviceState<T>
     public val consumationCapacity: DeviceState<Numeric<U>>
     public val supplyRequest: LateBindDeviceState<T>
 }
 
 public interface ContinuousConsumerWrapper<U : UnitsOfMeasurement, T : Amount<U>> : ContinuousConsumerInterface<U, T> {
     public val consumer: ContinuousConsumerInterface<U, T>
+
+    override val consumerAlgebra: AmountAlgebra<U, T> get() = consumer.consumerAlgebra
+
+
     override val consumation: DeviceState<T> get() = consumer.consumation
     override val consumationCapacity: DeviceState<Numeric<U>> get() = consumer.consumationCapacity
     override val supplyRequest: LateBindDeviceState<T> get() = consumer.supplyRequest
@@ -45,11 +51,11 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousConsumerInterface<U
  */
 public class ContinuousConsumer<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val consumerAlgebra: AmountAlgebra<U, T>,
     override val consumationCapacity: DeviceState<Numeric<U>>,
 ) : ModelConstructor(context), ContinuousConsumerInterface<U, T> {
 
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(algebra.zero)
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(consumerAlgebra.zero)
 
     init {
         registerState(consumationCapacity)
@@ -60,7 +66,7 @@ public class ContinuousConsumer<U : UnitsOfMeasurement, T : Amount<U>>(
         supplyRequest,
         consumationCapacity
     ) { request, capacity ->
-        with(algebra) {
+        with(consumerAlgebra) {
             request.coerceValueIn(Numeric.zero<U>()..capacity)
         }
     }
@@ -69,7 +75,7 @@ public class ContinuousConsumer<U : UnitsOfMeasurement, T : Amount<U>>(
         supplyRequest,
         consumationCapacity
     ) { request, capacity ->
-        with(algebra) {
+        with(consumerAlgebra) {
             val consumation = request.coerceValueIn(Numeric.zero<U>()..capacity)
             consumation.value / capacity.value
         }

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

@@ -27,16 +27,16 @@ public enum class JoinManagementStrategy {
  */
 public class ContinuousMix<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val producerAlgebra: AmountAlgebra<U, T>,
     public val supplyKeys: Collection<String>,
     private val joinManagementStrategy: JoinManagementStrategy = JoinManagementStrategy.PROPORTIONAL,
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero())
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero())
 
 
     public val supplyRequest: Map<String, LateBindDeviceState<T>> = supplyKeys.associateWith {
-        LateBindDeviceState( algebra.zero)
+        LateBindDeviceState(producerAlgebra.zero)
     }
 
 
@@ -55,7 +55,7 @@ public class ContinuousMix<U : UnitsOfMeasurement, T : Amount<U>>(
         consumerRequest, jointSupplyRequest
     ) { consumerRequest, supplyRequest: Map<String, T> ->
 
-        with(algebra) {
+        with(producerAlgebra) {
             val totalInput: T = sum(supplyRequest.values)
             val totalOutput: Numeric<U> = consumerRequest
 
@@ -98,11 +98,11 @@ public class ContinuousMix<U : UnitsOfMeasurement, T : Amount<U>>(
         }
 
     override val productionCapacity: DeviceState<T> = mapState(jointSupplyRequest) { supply: Map<String, T> ->
-        algebra.sum(supply.values)
+        producerAlgebra.sum(supply.values)
     }
 
     override val production: DeviceState<T> = mapState(consumation) { consume ->
-        algebra.sum(consume.values)
+        producerAlgebra.sum(consume.values)
     }
 
 
@@ -141,6 +141,8 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousMix<U, T>.asConsume
     val consumation = individualConsumation[key]!!
 
     object : ContinuousConsumerInterface<U, T> {
+        override val consumerAlgebra: AmountAlgebra<U, T> get() = this@asConsumer.producerAlgebra
+
         override val consumation: DeviceState<T> get() = consumation
         override val consumationCapacity: DeviceState<Numeric<U>> get() = consumation.asNumeric()
         override val supplyRequest: LateBindDeviceState<T> get() = input
@@ -165,11 +167,11 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousMix<U, T>.connectPr
 public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousMix(
     producers: Map<String, ContinuousProducer<U, T>>,
     consumer: ContinuousConsumer<U, T>,
-    algebra: AmountAlgebra<U, T> = consumer.algebra,
+    algebra: AmountAlgebra<U, T> = consumer.consumerAlgebra,
     context: Context = producers.values.first().context,
 ): ContinuousMix<U, T> = ContinuousMix<U, T>(
     context = context,
-    algebra = algebra,
+    producerAlgebra = algebra,
     supplyKeys = producers.keys
 ).also { join ->
     join.connectConsumer(consumer)

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

@@ -5,6 +5,8 @@ import space.kscience.controls.constructor.units.*
 import space.kscience.dataforge.context.Context
 
 public interface ContinuousProducerInterface<U : UnitsOfMeasurement, T : Amount<U>> {
+    public val producerAlgebra: AmountAlgebra<U, T>
+
     public val production: DeviceState<T>
     public val productionCapacity: DeviceState<T>
     public val consumerRequest: LateBindDeviceState<Numeric<U>>
@@ -13,6 +15,8 @@ public interface ContinuousProducerInterface<U : UnitsOfMeasurement, T : Amount<
 public interface ContinuousProducerWrapper<U : UnitsOfMeasurement, T : Amount<U>> : ContinuousProducerInterface<U, T> {
     public val producer: ContinuousProducerInterface<U, T>
 
+    override val producerAlgebra: AmountAlgebra<U, T> get() = producer.producerAlgebra
+
     override val production: DeviceState<T> get() = producer.production
     override val productionCapacity: DeviceState<T> get() = producer.productionCapacity
     override val consumerRequest: LateBindDeviceState<Numeric<U>> get() = producer.consumerRequest
@@ -48,7 +52,7 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousProducerInterface<U
  */
 public class ContinuousProducer<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val producerAlgebra: AmountAlgebra<U, T>,
     override val productionCapacity: DeviceState<T>,
     override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero()),
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
@@ -62,7 +66,7 @@ public class ContinuousProducer<U : UnitsOfMeasurement, T : Amount<U>>(
         first = consumerRequest,
         second = productionCapacity
     ) { request: Numeric<U>, capacity: T ->
-        with(algebra) {
+        with(producerAlgebra) {
             capacity.coerceValueIn(Numeric.zero<U>()..request)
         }
     }
@@ -71,7 +75,7 @@ public class ContinuousProducer<U : UnitsOfMeasurement, T : Amount<U>>(
         consumerRequest,
         productionCapacity
     ) { request, capacity ->
-        with(algebra) {
+        with(producerAlgebra) {
             val production = capacity.coerceValueIn(Numeric.zero<U>()..request)
             production.value / capacity.value
         }
@@ -96,7 +100,7 @@ public class ContinuousProducer<U : UnitsOfMeasurement, T : Amount<U>>(
         ): ContinuousProducer<U, T> {
             return ContinuousProducer(
                 context = consumer.context,
-                algebra = consumer.algebra,
+                producerAlgebra = consumer.consumerAlgebra,
                 productionCapacity = capacity,
             ).also { producer ->
                 //provide bi-directional connection

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

@@ -70,19 +70,19 @@ public interface ReactionRule<U : UnitsOfMeasurement, T : Amount<U>> {
  * @param U The type of the units of measurement associated with the amounts.
  * @param T The type of the amount with units, representing the quantities of substances.
  * @param context The simulation context in which the reaction operates.
- * @param algebra The algebra defining the operations on the amounts of type T.
+ * @param producerAlgebra The algebra defining the operations on the amounts of type T.
  * @param reaction The reaction rule defining consumption and production behavior
  *                 for given supply and product keys.
  */
 public class ContinuousReaction<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val producerAlgebra: AmountAlgebra<U, T>,
     public val reaction: ReactionRule<U, T>,
 ) : ModelConstructor(context), ContinuousProducerInterface<U, T> {
 
-    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState( Numeric.zero())
+    override val consumerRequest: LateBindDeviceState<Numeric<U>> = LateBindDeviceState(Numeric.zero())
     public val supplyRequest: Map<String, LateBindDeviceState<T>> = reaction.supplyKeys.associateWith {
-        LateBindDeviceState( algebra.zero)
+        LateBindDeviceState(producerAlgebra.zero)
     }
 
 
@@ -102,11 +102,11 @@ public class ContinuousReaction<U : UnitsOfMeasurement, T : Amount<U>>(
     public val consumation: DeviceState<Map<String, T>> = combineState(
         consumerRequest, jointSupplyRequest
     ) { consumerRequest, supplyRequest: Map<String, T> ->
-        with(algebra) {
+        with(producerAlgebra) {
             //compute expected amount of each supply
             val forwardRequest = reaction.forward(supplyRequest)
             //limit forward request to consumer capacity
-            val forward = forwardRequest.coerceIn(algebra.zero..consumerRequest)
+            val forward = forwardRequest.coerceIn(producerAlgebra.zero..consumerRequest)
             //consumation from request
             val backward = reaction.backward(forward)
 
@@ -127,11 +127,11 @@ public class ContinuousReaction<U : UnitsOfMeasurement, T : Amount<U>>(
     public val consumationCapacity: DeviceState<Map<String, Numeric<U>>> = combineState(
         consumerRequest, jointSupplyRequest
     ) { consumerRequest: Numeric<U>, supplyRequest: Map<String, T> ->
-        with(algebra) {
+        with(producerAlgebra) {
             //compute expected amount of each supply
             val forwardRequest = reaction.forward(supplyRequest)
             //limit forward request to consumer capacity
-            val forward = forwardRequest.coerceIn(algebra.zero..consumerRequest)
+            val forward = forwardRequest.coerceIn(producerAlgebra.zero..consumerRequest)
             //consumation from request
             reaction.backward(forward)
         }
@@ -150,7 +150,7 @@ public class ContinuousReaction<U : UnitsOfMeasurement, T : Amount<U>>(
     override val production: DeviceState<T> = combineState(
         consumerRequest, jointSupplyRequest
     ) { consumerRequest, supplyRequest: Map<String, T> ->
-        with(algebra) {
+        with(producerAlgebra) {
             reaction.forward(supplyRequest).coerceValueIn(Numeric.zero<U>()..consumerRequest)
         }
     }
@@ -172,6 +172,8 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousReaction<U, T>.asCo
     key: String
 ): ContinuousConsumerInterface<U, T> = supplyRequest[key]?.let { input ->
     object : ContinuousConsumerInterface<U, T> {
+        override val consumerAlgebra: AmountAlgebra<U, T> get() = this@asConsumer.producerAlgebra
+
         override val consumation: DeviceState<T> get() = individualConsumation[key]!!
         override val consumationCapacity: DeviceState<Numeric<U>> get() = individualConsumationCapacity[key]!!
         override val supplyRequest: LateBindDeviceState<T> get() = input

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

@@ -40,14 +40,14 @@ public interface SeparationRule<U : UnitsOfMeasurement, T : Amount<U>> {
 
 public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
     context: Context,
-    public val algebra: AmountAlgebra<U, T>,
+    override val consumerAlgebra: AmountAlgebra<U, T>,
     public val rule: SeparationRule<U, T>,
 ) : ModelConstructor(context), ContinuousConsumerInterface<U, T> {
 
-    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState( algebra.zero)
+    override val supplyRequest: LateBindDeviceState<T> = LateBindDeviceState(consumerAlgebra.zero)
 
     public val consumationRequest: Map<String, LateBindDeviceState<Numeric<U>>> = rule.productionKeys.associateWith {
-        LateBindDeviceState( Numeric.zero())
+        LateBindDeviceState(Numeric.zero())
     }
 
     private val jointConsumationRequest: DeviceState<Map<String, Numeric<U>>> = combineState(consumationRequest) {
@@ -62,30 +62,30 @@ public class ContinuousSeparate<U : UnitsOfMeasurement, T : Amount<U>>(
         val limitingFactor = expectation.minOfOrNull { (key, value) ->
             (consumation[key] ?: Numeric.zero()).value / value.value
         } ?: 0.0
-        with(algebra) {
+        with(consumerAlgebra) {
             supply * limitingFactor to expectation.mapValues { (key, value) -> supply * limitingFactor }
         }
     }
 
     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] ?: algebra.zero }
+        mapState(production) { it[key] ?: consumerAlgebra.zero }
     }
 
     public val productionCapacity: DeviceState<Map<String, T>> = combineState(
         first = supplyRequest,
         second = jointConsumationRequest
     ) { supply: T, consumation: Map<String, Numeric<U>> ->
-        with(algebra) {
+        with(consumerAlgebra) {
             val productionLimit = rule.backward(consumation)
-            val expectedProduction = supply.coerceValueIn(zero.. productionLimit)
+            val expectedProduction = supply.coerceValueIn(zero..productionLimit)
             rule.forward(expectedProduction)
         }
     }
 
     public val individualProductionCapacity: Map<String, DeviceState<T>> = rule.productionKeys.associateWith { key ->
-        mapState(productionCapacity) { it[key] ?: algebra.zero }
+        mapState(productionCapacity) { it[key] ?: consumerAlgebra.zero }
     }
 
     override val consumation: DeviceState<T> = mapState(balance) { it.first }
@@ -100,6 +100,7 @@ public fun <U : UnitsOfMeasurement, T : Amount<U>> ContinuousSeparate<U, T>.asPr
     key: String
 ): ContinuousProducerInterface<U, T> = consumationRequest[key]?.let { specificConsumationRequest ->
     object : ContinuousProducerInterface<U, T> {
+        override val producerAlgebra: AmountAlgebra<U, T> get() = this@asProducer.consumerAlgebra
         override val production: DeviceState<T> get() = individualProduction[key]!!
         override val productionCapacity: DeviceState<T> = individualProductionCapacity[key]!!
         override val consumerRequest: LateBindDeviceState<Numeric<U>> get() = specificConsumationRequest