WeightNumbersRow

((2f - abs(number - currentValue).coerceAtMost(2f)).pow(2f) + 2f) / 6f

abs(number-currentValue)

distance.coerceAtMost(2f)

2f - limitedDistance

inversedValue.pow(2f)

parabolicValue + 2f

[0, 4]

baseFixedValue / 6f

[0.333f, 1f]

modifier.pointerInput(Unit) {
            val decay = splineBasedDecay<Float>(this)
            val velocityTracker = VelocityTracker()
            detectHorizontalDragGestures(
                onDragEnd = {
                    val velocity = velocityTracker.calculateVelocity().x
                    val target = decay.calculateTargetValue(state.value, velocity) / size.width * -3
                    state.roundToValue(state.value + target)
                },
            ) { change, dragAmount ->
                val scrolledValue = (dragAmount / size.width) * 3
                state.changeValueBy(scrolledValue)
                velocityTracker.addPosition(
                    change.uptimeMillis,
                    change.position
                )
                change.consumePositionChange()
            }

fun roundToValue(target: Float) {
        coroutineScope.launch {
            var boundedTarget = target
            if (target <= valueRange.start) {
                boundedTarget = valueRange.start
            } else if (target >= valueRange.endInclusive) {
                boundedTarget = valueRange.endInclusive
            }
            animatedValue.animateTo(boundedTarget.roundToInt().toFloat(), tween(500))
        }
    }

I simply added a fling  flingBehavior method to the WeightEntryState class
class WeightEntryState(
    initialValue: Float,
    var valueRange: ClosedFloatingPointRange<Float>,
    private val coroutineScope: CoroutineScope
) {
    private val animatedValue = Animatable(initialValue)

    val value: Float
        get() = animatedValue.value


    fun changeValueBy(number: Float) {
        animatedValue.updateBounds(valueRange.start, valueRange.endInclusive)
        coroutineScope.launch {
            animatedValue.snapTo((animatedValue.value - number).coerceIn(valueRange))
        }
    }

    fun flingBehavior(velocity: Float, decayRate: DecayAnimationSpec<Float>){
        coroutineScope.launch {
            animatedValue.animateDecay(velocity, decayRate)
        }
    }

    fun snapToValue(newValue: Float) {
        coroutineScope.launch {
            animatedValue.snapTo(newValue)
        }
    }
}

val velocity by remember { mutableStateOf(VelocityTracker()) }
        val animationDecay: DecayAnimationSpec<Float> = rememberSplineBasedDecay()

private val decay = exponentialDecay<Float>(
    frictionMultiplier = 0.4f,
    absVelocityThreshold = 0.05f
)