Add generic TickDataType

CHANGELOG.md

@@ -12,6 +12,10 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 0.3 - tba
+### Added
+- Generic `TickUnit` and `TickDifference` instead of `Double` identifier.
+
 ## [0.2.2] - 13.02.2024
 ### Added
 - Add missing documentation

HACKING.md

@@ -43,7 +43,7 @@ perform additional quality checks on Kotlin files, but will not fail the build o
 
 ### `publish-conventions`
 
-The publish conventions handle publication of artifacts via Maven Central. Most of the process is automated, but each
+The publish-conventions handle publication of artifacts via Maven Central. Most of the process is automated, but each
 module must provide a name and description for the generated POM file. This is done using the (custom) `MavenMetadata`
 extension:
 

stars-core/src/main/kotlin/tools/aqua/stars/core/ListExtensions.kt

@@ -19,17 +19,27 @@
 
 package tools.aqua.stars.core
 
-/** Creates TxT cross product. */
+/**
+ * Creates TxT cross product.
+ *
+ * @return The TxT cross product of the current [List].
+ */
 fun <T> List<T>.x2(): List<Pair<T, T>> = this.flatMap { a -> this.map { b -> a to b } }
 
-/** Creates TxTxT cross product. */
+/**
+ * Creates TxTxT cross product.
+ *
+ * @return The TxTxT cross product of the current [List].
+ */
 fun <T> List<T>.x3(): List<Triple<T, T, T>> =
     this.flatMap { a -> this.flatMap { b -> this.map { c -> Triple(a, b, c) } } }
 
 /**
  * Adaption of com.marcinmoskala.math.powerset for lists while preserving the order of the original
  * list, going from small to big subsets see
  * https://github.com/MarcinMoskala/KotlinDiscreteMathToolkit/blob/master/src/main/java/com/marcinmoskala/math/PowersetExt.kt
+ *
+ * @return The power list of the current [List].
  */
 fun <T> List<T>.powerlist(): List<List<T>> =
     when {
@@ -56,6 +66,8 @@ fun <T> List<T>.powerlist(): List<List<T>> =
  *        listOf(listOf("a", "x", "1"), listOf("a", "x", "2"), /*...*/ listOf("c", "y", "4"))
  *    )
  * ```
+ *
+ * @return The cross product of the current [List].
  */
 fun <T> List<List<List<T>>>.crossProduct(): List<List<T>> {
   require(size >= 2) { "List for cross-product building must at least contain two elements." }
@@ -70,7 +82,5 @@ fun <T> List<List<List<T>>>.crossProduct(): List<List<T>> {
     }
   }
 
-  // val monitorFunction: (PredicateContext, Segment) -> Boolean = { _, _ -> true }
-
   return if (size == 2) nextLevelList else (listOf(nextLevelList) + subList(2, size)).crossProduct()
 }

stars-core/src/main/kotlin/tools/aqua/stars/core/evaluation/BinaryPredicate.kt

@@ -18,9 +18,7 @@
 package tools.aqua.stars.core.evaluation
 
 import kotlin.reflect.KClass
-import tools.aqua.stars.core.types.EntityType
-import tools.aqua.stars.core.types.SegmentType
-import tools.aqua.stars.core.types.TickDataType
+import tools.aqua.stars.core.types.*
 
 /**
  * Binary predicate.
@@ -30,39 +28,53 @@
  * @param E [EntityType].
  * @param T [TickDataType].
  * @param S [SegmentType].
+ * @param U [TickUnit].
+ * @param D [TickDifference].
+ * @property kClasses The [KClass]es of the [EntityType]s that are evaluated by this predicate.
  * @property eval The evaluation function on the [PredicateContext].
- * @property kClasses The actors.
  */
 class BinaryPredicate<
-    E1 : E, E2 : E, E : EntityType<E, T, S>, T : TickDataType<E, T, S>, S : SegmentType<E, T, S>>(
-    val eval: (PredicateContext<E, T, S>, E1, E2) -> Boolean,
-    val kClasses: Pair<KClass<E1>, KClass<E2>>
+    E1 : E,
+    E2 : E,
+    E : EntityType<E, T, S, U, D>,
+    T : TickDataType<E, T, S, U, D>,
+    S : SegmentType<E, T, S, U, D>,
+    U : TickUnit<U, D>,
+    D : TickDifference<D>>(
+    val kClasses: Pair<KClass<E1>, KClass<E2>>,
+    val eval: (PredicateContext<E, T, S, U, D>, E1, E2) -> Boolean,
 ) {
 
   /**
    * Checks if this predicate holds (i.e. is true) in the given context.
    *
    * @param ctx The context this predicate is evaluated in.
-   * @param tickId The time stamp to evaluate this predicate in. default: first tick in context.
-   * @param entityId1 The ID of the first entity to evaluate this predicate for. default: ego
-   * vehicle.
+   * @param tick The time stamp to evaluate this predicate in. default: first tick in context.
+   * @param entityId1 The ID of the first entity to evaluate this predicate for. default: primary
+   * entity.
    * @param entityId2 The ID of the second entity to evaluate this predicate for.
+   *
+   * @return Whether the predicate holds in the given [PredicateContext] at the given [tick] for the
+   * given [entityId1] and [entityId2].
    */
   fun holds(
-      ctx: PredicateContext<E, T, S>,
-      tickId: Double = ctx.segment.firstTickId,
+      ctx: PredicateContext<E, T, S, U, D>,
+      tick: U = ctx.segment.ticks.keys.first(),
       entityId1: Int = ctx.primaryEntityId,
       entityId2: Int
-  ): Boolean = ctx.holds(this, tickId, entityId1, entityId2)
+  ): Boolean = ctx.holds(this, tick, entityId1, entityId2)
 
   /**
    * Checks if this predicate holds (i.e. is true) in the given context on current tick.
    *
    * @param ctx The context this predicate is evaluated in.
-   * @param entity1 The first entity to evaluate this predicate for. default: ego vehicle.
+   * @param entity1 The first entity to evaluate this predicate for.
    * @param entity2 The second entity to evaluate this predicate for.
+   *
+   * @return Whether the predicate holds in the given [PredicateContext] for the given [entity1] and
+   * [entity2].
    */
-  fun holds(ctx: PredicateContext<E, T, S>, entity1: E1, entity2: E2): Boolean =
+  fun holds(ctx: PredicateContext<E, T, S, U, D>, entity1: E1, entity2: E2): Boolean =
       holds(
           ctx,
           entity1.tickData.currentTick.apply {
@@ -72,15 +84,32 @@
           entity2.id)
 
   companion object {
-    /** Creates a binary tick predicate in this context. */
+    /**
+     * Creates a binary tick predicate in this context.
+     *
+     * @param E1 [EntityType].
+     * @param E2 [EntityType].
+     * @param E [EntityType].
+     * @param T [TickDataType].
+     * @param S [SegmentType].
+     * @param U [TickUnit].
+     * @param D [TickDifference].
+     * @param kClasses The [KClass]es of the [EntityType]s that are evaluated by this predicate.
+     * @param eval The evaluation function on the [PredicateContext].
+     *
+     * @return The created [UnaryPredicate] with the given [eval] function and the [KClass]es of the
+     * entities for which the predicate should be evaluated.
+     */
     fun <
         E1 : E,
         E2 : E,
-        E : EntityType<E, T, S>,
-        T : TickDataType<E, T, S>,
-        S : SegmentType<E, T, S>> predicate(
+        E : EntityType<E, T, S, U, D>,
+        T : TickDataType<E, T, S, U, D>,
+        S : SegmentType<E, T, S, U, D>,
+        U : TickUnit<U, D>,
+        D : TickDifference<D>> predicate(
         kClasses: Pair<KClass<E1>, KClass<E2>>,
-        eval: (PredicateContext<E, T, S>, E1, E2) -> Boolean
-    ): BinaryPredicate<E1, E2, E, T, S> = BinaryPredicate(eval, kClasses)
+        eval: (PredicateContext<E, T, S, U, D>, E1, E2) -> Boolean,
+    ): BinaryPredicate<E1, E2, E, T, S, U, D> = BinaryPredicate(kClasses, eval)
   }
 }

stars-core/src/main/kotlin/tools/aqua/stars/core/evaluation/NullaryPredicate.kt

@@ -17,39 +17,66 @@
 
 package tools.aqua.stars.core.evaluation
 
-import tools.aqua.stars.core.types.EntityType
-import tools.aqua.stars.core.types.SegmentType
-import tools.aqua.stars.core.types.TickDataType
+import tools.aqua.stars.core.types.*
 
 /**
  * Nullary predicate.
  *
  * @param E [EntityType].
  * @param T [TickDataType].
  * @param S [SegmentType].
+ * @param U [TickUnit].
+ * @param D [TickDifference].
  * @property eval The evaluation function on the [PredicateContext].
  */
 class NullaryPredicate<
-    E : EntityType<E, T, S>, T : TickDataType<E, T, S>, S : SegmentType<E, T, S>>(
-    val eval: (PredicateContext<E, T, S>, T) -> Boolean,
+    E : EntityType<E, T, S, U, D>,
+    T : TickDataType<E, T, S, U, D>,
+    S : SegmentType<E, T, S, U, D>,
+    U : TickUnit<U, D>,
+    D : TickDifference<D>>(
+    val eval: (PredicateContext<E, T, S, U, D>, T) -> Boolean,
 ) {
 
-  /** Evaluates predicate on [PredicateContext]. */
-  fun evaluate(ctx: PredicateContext<E, T, S>): List<Double> = ctx.evaluate(this)
+  /**
+   * Evaluates predicate on the given [PredicateContext].
+   *
+   * @param ctx The context this predicate is evaluated in.
+   *
+   * @return Whether the predicate holds in the given [PredicateContext].
+   */
+  fun holds(ctx: PredicateContext<E, T, S, U, D>): List<U> = ctx.holds(this)
 
   /**
    * Checks if this predicate holds (i.e. is true) in the given context and tick identifier.
    *
    * @param ctx The context this predicate is evaluated in.
-   * @param tickId The time stamp to evaluate this predicate in. default: first tick in context.
+   * @param tick The tick to evaluate this predicate in. default: first tick in context.
+   *
+   * @return Whether the predicate holds in the given [PredicateContext] and at the given [tick].
    */
-  fun holds(ctx: PredicateContext<E, T, S>, tickId: Double): Boolean =
-      evaluate(ctx).contains(tickId)
+  fun holds(ctx: PredicateContext<E, T, S, U, D>, tick: U): Boolean = holds(ctx).contains(tick)
 
   companion object {
-    /** Creates a nullary tick predicate. */
-    fun <E : EntityType<E, T, S>, T : TickDataType<E, T, S>, S : SegmentType<E, T, S>> predicate(
-        eval: (PredicateContext<E, T, S>, T) -> Boolean
-    ): NullaryPredicate<E, T, S> = NullaryPredicate(eval)
+    /**
+     * Creates a nullary tick predicate.
+     *
+     * @param E [EntityType].
+     * @param T [TickDataType].
+     * @param S [SegmentType].
+     * @param U [TickUnit].
+     * @param D [TickDifference].
+     * @param eval The evaluation function on the [PredicateContext].
+     *
+     * @return The created [NullaryPredicate] with the given [eval] function.
+     */
+    fun <
+        E : EntityType<E, T, S, U, D>,
+        T : TickDataType<E, T, S, U, D>,
+        S : SegmentType<E, T, S, U, D>,
+        U : TickUnit<U, D>,
+        D : TickDifference<D>> predicate(
+        eval: (PredicateContext<E, T, S, U, D>, T) -> Boolean
+    ): NullaryPredicate<E, T, S, U, D> = NullaryPredicate(eval)
   }
 }