refactor: move math things to the separate package

Author: levinzonr

slider/src/main/java/io/monstarlab/mosaic/slider/SliderState.kt

@@ -12,6 +12,8 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.geometry.Offset
 import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
+import io.monstarlab.mosaic.slider.math.fractionToValue
+import io.monstarlab.mosaic.slider.math.valueToFraction
 import kotlinx.coroutines.coroutineScope
 
 /**

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/CheckPointsValueDistribution.kt

@@ -1,6 +1,9 @@
 package io.monstarlab.mosaic.slider.distribution
 
-import io.monstarlab.mosaic.slider.valueToFraction
+import io.monstarlab.mosaic.slider.math.LinearEquation
+import io.monstarlab.mosaic.slider.math.Point
+import io.monstarlab.mosaic.slider.math.RangedLinearEquation
+import io.monstarlab.mosaic.slider.math.valueToFraction
 
 public class CheckPointsValueDistribution(
     valuesMap: List<Pair<Float, Float>>,
@@ -16,32 +19,30 @@ public class CheckPointsValueDistribution(
 
         val offsetRange = valuesMap.minOf { it.first }..valuesMap.maxOf { it.first }
         val valueRange = valuesMap.minOf { it.second }..valuesMap.maxOf { it.second }
-        val zipped = valuesMap.sortedBy { it.first }
+
+        equations = valuesMap.sortedBy { it.first }
             .zipWithNext()
-        // make sure all values are increasing, otherwise throw an exception
-        zipped.firstOrNull { it.first.second >= it.second.second }
-            ?.let {
-                throw DecreasingValueException(it.first)
+            .checkIncreasingValues() // check if values are always increasing
+            .map {
+                val x1Fraction = it.first.first.valueToFraction(offsetRange)
+                val x2Fraction = it.second.first.valueToFraction(offsetRange)
+                val y1Fraction = it.first.second.valueToFraction(valueRange)
+                val y2Fraction = it.second.second.valueToFraction(valueRange)
+                val equation = LinearEquation.fromTwoPoints(
+                    x1 = x1Fraction,
+                    x2 = x2Fraction,
+                    y1 = y1Fraction,
+                    y2 = y2Fraction,
+                )
+                RangedLinearEquation(
+                    equation = equation,
+                    offsetRange = x1Fraction..x2Fraction,
+                    valueRange = y1Fraction..y2Fraction,
+                )
             }
-        equations = zipped.map {
-            val x1Fraction = it.first.first.valueToFraction(offsetRange)
-            val x2Fraction = it.second.first.valueToFraction(offsetRange)
-            val y1Fraction = it.first.second.valueToFraction(valueRange)
-            val y2Fraction = it.second.second.valueToFraction(valueRange)
-            val equation = LinearEquation.fromTwoPoints(
-                x1 = x1Fraction,
-                x2 = x2Fraction,
-                y1 = y1Fraction,
-                y2 = y2Fraction,
-            )
-            RangedLinearEquation(
-                equation = equation,
-                offsetRange = x1Fraction..x2Fraction,
-                valueRange = y1Fraction..y2Fraction,
-            )
-        }
     }
 
+
     override fun interpolate(value: Float): Float {
         val equation = equations.firstOrNull { it.offsetRange.contains(value) }?.equation
         checkNotNull(equation) { "No equation found for value $value during interpolate" }
@@ -54,10 +55,17 @@ public class CheckPointsValueDistribution(
         return equation.offsetFromValue(value)
     }
 
-    public class DecreasingValueException(progressValuePair: Pair<Float, Float>) :
+    private fun List<Pair<Point, Point>>.checkIncreasingValues(): List<Pair<Point, Point>> {
+        find { it.first.second >= it.second.second }?.let {
+                throw DecreasingValueException(it.first)
+        }
+        return this
+    }
+
+    public class DecreasingValueException(progressValuePair: Point) :
         IllegalStateException(
             "Values must be always increasing with increasing progress," +
-                " item at progress ${progressValuePair.first}  with value " +
-                "${progressValuePair.second} is breaking this rule ",
+                    " item at progress ${progressValuePair.first}  with value " +
+                    "${progressValuePair.second} is breaking this rule ",
         )
 }

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/LinearEquation.kt

@@ -0,0 +1,14 @@
+package io.monstarlab.mosaic.slider.distribution
+
+/**
+ * Represents a linear distribution strategy for slider values.
+ */
+public object LinearValueDistribution: SliderValueDistribution {
+    override fun interpolate(value: Float): Float {
+        return value
+    }
+
+    override fun inverse(value: Float): Float {
+        return value
+    }
+}

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/LinearValueDistribution.kt

@@ -35,22 +35,18 @@ public interface SliderValueDistribution {
          * @param c constant term in the parabolic equation
          * @return a [SliderValueDistribution] instance with a parabolic distribution strategy
          */
-        public fun parabolic(a: Float, b: Float = 0f, c: Float = 0f): SliderValueDistribution {
+        public fun parabolic(
+            a: Float,
+            b: Float = 0f,
+            c: Float = 0f
+        ): SliderValueDistribution {
             return ParabolicValueDistribution(a, b, c)
         }
 
         /**
          * A linear distribution strategy where the input value is directly mapped to the output value.
          * Used in [Slider] by default
          */
-        public val Linear: SliderValueDistribution = object : SliderValueDistribution {
-            override fun interpolate(value: Float): Float {
-                return value
-            }
-
-            override fun inverse(value: Float): Float {
-                return value
-            }
-        }
+        public val Linear: SliderValueDistribution = LinearValueDistribution
     }
 }

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/SliderValueDistribution.kt

@@ -0,0 +1,19 @@
+package io.monstarlab.mosaic.slider.math
+
+internal data class LinearEquation(
+    private val m: Float,
+    private val c: Float,
+) {
+    internal fun valueFromOffset(offset: Float): Float = m * offset + c
+
+    internal fun offsetFromValue(value: Float): Float = (value - c) / m
+
+    internal companion object {
+        internal fun fromTwoPoints(x1: Float, y1: Float, x2: Float, y2: Float): LinearEquation {
+            require(x2 != x1) { "can't calc equation from points with similar x value" }
+            val slope = (y2 - y1) / (x2 - x1)
+            val c = y2 - slope * x2
+            return LinearEquation(slope, c)
+        }
+    }
+}

slider/src/main/java/io/monstarlab/mosaic/slider/math/LinearEquation.kt

@@ -1,4 +1,4 @@
-package io.monstarlab.mosaic.slider
+package io.monstarlab.mosaic.slider.math
 
 import androidx.compose.ui.util.lerp
 
@@ -15,7 +15,7 @@ internal fun Float.valueToFraction(range: ClosedFloatingPointRange<Float>) =
     valueToFraction(range.start, range.endInclusive)
 
 internal fun Float.fractionToValue(rangeStart: Float, rangeEnd: Float): Float =
-    scale(0f, 1f, this.coerceIn(0f, 1f), rangeStart, rangeEnd)
+    scale(0f, 1f, coerceIn(0f, 1f), rangeStart, rangeEnd)
 
 internal fun Float.fractionToValue(range: ClosedFloatingPointRange<Float>): Float =
-    scale(0f, 1f, this, range.start, range.endInclusive)
+    fractionToValue(range.start, range.endInclusive)

slider/src/main/java/io/monstarlab/mosaic/slider/MathUtils.kt renamed to slider/src/main/java/io/monstarlab/mosaic/slider/math/MathUtils.kt

@@ -0,0 +1,3 @@
+package io.monstarlab.mosaic.slider.math
+
+internal typealias Point = Pair<Float, Float>

slider/src/main/java/io/monstarlab/mosaic/slider/math/Point.kt

@@ -1,6 +1,7 @@
-package io.monstarlab.mosaic.slider.distribution
+package io.monstarlab.mosaic.slider.math
 
-public data class RangedLinearEquation(
+
+internal data class RangedLinearEquation(
     val equation: LinearEquation,
     val offsetRange: ClosedFloatingPointRange<Float>,
     val valueRange: ClosedFloatingPointRange<Float>,