fix: swap inverse interplote methods

Author: levinzonr

demo/src/main/java/io/monstarlab/mosaic/features/SliderDemo.kt

@@ -40,26 +40,17 @@ import androidx.compose.ui.unit.dp
 import io.monstarlab.mosaic.slider.Slider
 import io.monstarlab.mosaic.slider.SliderColors
 import io.monstarlab.mosaic.slider.SliderValueDistribution
-import io.monstarlab.mosaic.slider.rememberSliderState
 import kotlin.math.roundToInt
 import androidx.compose.material3.Slider as MaterialSlider
 
 @Composable
 fun SliderDemo() = Scaffold(modifier = Modifier) {
-    var materialSliderValue by remember { mutableFloatStateOf(50f) }
-
     Column(
         modifier = Modifier
             .padding(it)
             .padding(16.dp),
         verticalArrangement = Arrangement.spacedBy(32.dp),
     ) {
-        MaterialSlider(
-            value = materialSliderValue,
-            onValueChange = { materialSliderValue = it },
-            valueRange = 0f..100f,
-        )
-
         MosaicSliderDemo()
     }
 }
@@ -76,6 +67,14 @@ fun MosaicSliderDemo() {
         var isCustom by remember { mutableStateOf(false) }
         var linearDistribution by remember { mutableStateOf(false) }
 
+        var sliderValue by remember { mutableFloatStateOf(500f) }
+
+        MaterialSlider(
+            value = sliderValue,
+            onValueChange = { sliderValue = it },
+            valueRange = 0f..1000f,
+        )
+
         val modifier = if (isCustom) {
             Modifier
                 .clip(RoundedCornerShape(16.dp))
@@ -85,28 +84,21 @@ fun MosaicSliderDemo() {
         }
 
         val parabolic: SliderValueDistribution = remember {
-            SliderValueDistribution.parabolic(
-                a = (1000 - 100 * 0.1f) / (1000 * 1000),
-                b = 0.1f,
-                c = 1f,
-            )
+            SliderValueDistribution.parabolic(a = 0.005f)
         }
 
-        val state = rememberSliderState(
-            value = 500f,
+        Slider(
+            value = sliderValue,
+            onValueChange = { sliderValue = it },
+            modifier = modifier,
+            enabled = enabled,
+            colors = colors,
+            range = 0f..1000f,
             valueDistribution = if (linearDistribution) {
                 SliderValueDistribution.Linear
             } else {
                 parabolic
             },
-            range = 0f..1000f,
-        )
-
-        Slider(
-            modifier = modifier,
-            enabled = enabled,
-            state = state,
-            colors = colors,
             thumb = {
                 if (isCustom) {
                     val transition = rememberInfiniteTransition(label = "")
@@ -148,7 +140,7 @@ fun MosaicSliderDemo() {
         )
 
         Text(
-            text = "Current value: ${state.value.roundToInt()}",
+            text = "Current value: ${sliderValue.roundToInt()}",
             modifier = Modifier.align(Alignment.CenterHorizontally),
             textAlign = TextAlign.Center,
             style = MaterialTheme.typography.bodyLarge,

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

@@ -65,8 +65,9 @@ public class SliderState(
      */
     internal val valueAsFraction: Float
         get() {
-            val interpolated = valueDistribution.interpolate(value)
-            return calcFraction(range.start, range.endInclusive, interpolated)
+            val inverted = valueDistribution.inverse(value)
+            val invertedRange = valueDistribution.inverse(range)
+            return calcFraction(invertedRange.start, invertedRange.endInclusive, inverted)
         }
 
     internal val disabledRangeAsFractions: ClosedFloatingPointRange<Float>
@@ -114,22 +115,22 @@ public class SliderState(
      * Scales offset in to the value that user should see
      */
     private fun scaleToUserValue(offset: Float): Float {
-        val range = valueDistribution.interpolate(range)
-        val scaledUserValue = scale(0f, totalWidth, offset, range.start, range.endInclusive)
-        return coerceValue(valueDistribution.inverse(scaledUserValue))
+        val invertedRange = valueDistribution.inverse(range)
+        val value = scale(0f, totalWidth, offset, invertedRange.start, invertedRange.endInclusive)
+        return coerceValue(valueDistribution.interpolate(value))
     }
 
     /**
      * Converts value of the user into the raw offset on the track
      */
     private fun scaleToOffset(value: Float): Float {
         val coerced = coerceValue(value)
-        val interpolatedRange = valueDistribution.interpolate(range)
-        val interpolated = valueDistribution.interpolate(coerced)
+        val invertedRange = valueDistribution.inverse(range)
+        val invertedValue = valueDistribution.inverse(coerced)
         return scale(
-            interpolatedRange.start,
-            interpolatedRange.endInclusive,
-            interpolated,
+            invertedRange.start,
+            invertedRange.endInclusive,
+            invertedValue,
             0f,
             totalWidth,
         )

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

@@ -35,7 +35,11 @@ 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, c: Float): SliderValueDistribution {
+        public fun parabolic(
+            a: Float,
+            b: Float = 0f,
+            c: Float = 0f,
+        ): SliderValueDistribution {
             return ParabolicValueDistribution(a, b, c)
         }
 
@@ -61,6 +65,12 @@ internal fun SliderValueDistribution.interpolate(
     return interpolate(range.start)..interpolate(range.endInclusive)
 }
 
+internal fun SliderValueDistribution.inverse(
+    range: ClosedFloatingPointRange<Float>,
+): ClosedFloatingPointRange<Float> {
+    return inverse(range.start)..inverse(range.endInclusive)
+}
+
 /**
  * Represents a parabolic distribution strategy for slider values.
  *
@@ -79,13 +89,13 @@ public class ParabolicValueDistribution(
 ) : SliderValueDistribution {
 
     override fun inverse(value: Float): Float {
-        return a * (value * value) + b * value + c
-    }
-
-    override fun interpolate(value: Float): Float {
         if (value == 0f) return 0f
 
         val d = (b * b) - 4 * a * (c - value)
         return (-b + sqrt(d)) / (2 * a)
     }
+
+    override fun interpolate(value: Float): Float {
+        return a * (value * value) + b * value + c
+    }
 }