Quadratic Equation Solver

import kotlin.math.sqrt

sealed interface EquationResult {
    data class TwoRoots(val first: Double, val second: Double) : EquationResult
    data class RepeatedRoot(val root: Double) : EquationResult
    data class Linear(val root: Double) : EquationResult
    data object NoRealRoots : EquationResult
    data object InfiniteSolutions : EquationResult
    data object NoSolution : EquationResult
    data class Error(val message: String) : EquationResult
}

fun solveEquation(aText: String, bText: String, cText: String): EquationResult {
    val a = aText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    val b = bText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    val c = cText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    if (a == null || b == null || c == null) {
        return EquationResult.Error("Enter a finite number for every coefficient.")
    }
    if (a == 0.0) {
        if (b == 0.0) return if (c == 0.0) EquationResult.InfiniteSolutions else EquationResult.NoSolution
        val root = -c / b
        return if (root.isFinite()) EquationResult.Linear(root) else rangeError()
    }

    // Scaling preserves the roots and avoids overflowing b*b for large coefficients.

}

fun solveEquation(aText: String, bText: String, cText: String): EquationResult {
    val a = aText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    val b = bText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    val c = cText.trim().toDoubleOrNull()?.takeIf { it.isFinite() }
    if (a == null || b == null || c == null) {
        return EquationResult.Error("Enter a finite number for every coefficient.")
    }
    if (a == 0.0) {
        if (b == 0.0) return if (c == 0.0) EquationResult.InfiniteSolutions else EquationResult.NoSolution
        val root = -c / b
        return if (root.isFinite()) EquationResult.Linear(root) else rangeError()
    }

    // Scaling preserves the roots and avoids overflowing b*b for large coefficients.
    val scale = max(abs(a), max(abs(b), abs(c)))
    val normalizedA = a / scale
    val normalizedB = b / scale
    val normalizedC = c / scale
    if (normalizedA == 0.0 || (b != 0.0 && normalizedB == 0.0) || (c != 0.0 && normalizedC == 0.0)) {
        return rangeError()
    }
    val discriminant = normalizedB * normalizedB - 4.0 * normalizedA * normalizedC
    if (discriminant < 0.0) return EquationResult.NoRealRoots
    if (discriminant == 0.0) {

        return EquationResult.Error("Enter a finite number for every coefficient.")
    }
    if (a == 0.0) {
        if (b == 0.0) return if (c == 0.0) EquationResult.InfiniteSolutions else EquationResult.NoSolution
        val root = -c / b
        return if (root.isFinite()) EquationResult.Linear(root) else rangeError()
    }

    // Scaling preserves the roots and avoids overflowing b*b for large coefficients.
    val scale = max(abs(a), max(abs(b), abs(c)))
    val normalizedA = a / scale
    val normalizedB = b / scale
    val normalizedC = c / scale
    if (normalizedA == 0.0 || (b != 0.0 && normalizedB == 0.0) || (c != 0.0 && normalizedC == 0.0)) {
        return rangeError()
    }
    val discriminant = normalizedB * normalizedB - 4.0 * normalizedA * normalizedC
    if (discriminant < 0.0) return EquationResult.NoRealRoots
    if (discriminant == 0.0) {
        val root = -normalizedB / (2.0 * normalizedA)
        return if (root.isFinite()) EquationResult.RepeatedRoot(root) else rangeError()
    }

    // This equivalent form avoids subtracting nearly equal numbers for the smaller root.
    val squareRoot = sqrt(discriminant)
    val signedRoot = if (normalizedB >= 0.0) squareRoot else -squareRoot

        return rangeError()
    }
    val discriminant = normalizedB * normalizedB - 4.0 * normalizedA * normalizedC
    if (discriminant < 0.0) return EquationResult.NoRealRoots
    if (discriminant == 0.0) {
        val root = -normalizedB / (2.0 * normalizedA)
        return if (root.isFinite()) EquationResult.RepeatedRoot(root) else rangeError()
    }

    // This equivalent form avoids subtracting nearly equal numbers for the smaller root.
    val squareRoot = sqrt(discriminant)
    val signedRoot = if (normalizedB >= 0.0) squareRoot else -squareRoot
    val q = -0.5 * (normalizedB + signedRoot)
    val first = q / normalizedA
    val second = normalizedC / q
    if (!first.isFinite() || !second.isFinite()) return rangeError()
    return EquationResult.TwoRoots(minOf(first, second), maxOf(first, second))
}

private fun rangeError() = EquationResult.Error("These coefficients exceed the reliable numeric range. Try values closer in size.")

fun normalizedDiscriminant(aText: String, bText: String, cText: String): Double? {
    val a = aText.trim().toDoubleOrNull()?.takeIf { it.isFinite() && it != 0.0 } ?: return null
    val b = bText.trim().toDoubleOrNull()?.takeIf { it.isFinite() } ?: return null
    val c = cText.trim().toDoubleOrNull()?.takeIf { it.isFinite() } ?: return null
    val scale = max(abs(a), max(abs(b), abs(c)))

    // This equivalent form avoids subtracting nearly equal numbers for the smaller root.
    val squareRoot = sqrt(discriminant)
    val signedRoot = if (normalizedB >= 0.0) squareRoot else -squareRoot
    val q = -0.5 * (normalizedB + signedRoot)
    val first = q / normalizedA
    val second = normalizedC / q
    if (!first.isFinite() || !second.isFinite()) return rangeError()
    return EquationResult.TwoRoots(minOf(first, second), maxOf(first, second))
}

private fun rangeError() = EquationResult.Error("These coefficients exceed the reliable numeric range. Try values closer in size.")

fun normalizedDiscriminant(aText: String, bText: String, cText: String): Double? {
    val a = aText.trim().toDoubleOrNull()?.takeIf { it.isFinite() && it != 0.0 } ?: return null
    val b = bText.trim().toDoubleOrNull()?.takeIf { it.isFinite() } ?: return null
    val c = cText.trim().toDoubleOrNull()?.takeIf { it.isFinite() } ?: return null
    val scale = max(abs(a), max(abs(b), abs(c)))
    val normalizedA = a / scale
    val normalizedB = b / scale
    val normalizedC = c / scale
    return normalizedB * normalizedB - 4.0 * normalizedA * normalizedC
}

@Composable
fun QuadraticSolver() {
    var a by rememberSaveable { mutableStateOf("1") }
    var b by rememberSaveable { mutableStateOf("-3") }
    var c by rememberSaveable { mutableStateOf("2") }
    var showResult by rememberSaveable { mutableStateOf(false) }
    val result = solveEquation(a, b, c)

    Text("Solve ax² + bx + c = 0 for real x.", style = MaterialTheme.typography.titleMedium)
    Text("Enter positive, negative, or zero coefficients. Use a dot for decimals.")
    CoefficientField(label = "a", value = a, onChange = { a = it; showResult = false })
    CoefficientField(label = "b", value = b, onChange = { b = it; showResult = false })
    CoefficientField(label = "c", value = c, onChange = { c = it; showResult = false })
    Text("Current equation: (${a.ifBlank { "?" }})x² + (${b.ifBlank { "?" }})x + (${c.ifBlank { "?" }}) = 0")
    Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
        Button(onClick = { showResult = true }) { Text("Solve") }
        OutlinedButton(onClick = { a = ""; b = ""; c = ""; showResult = false }) { Text("Clear") }
    }
    val message = when (result) {
        is EquationResult.TwoRoots -> "Two real roots: x₁ = ${number(result.first)}, x₂ = ${number(result.second)}"
        is EquationResult.RepeatedRoot -> "One repeated real root: x = ${number(result.root)}"
        is EquationResult.Linear -> "Linear equation: x = ${number(result.root)}"
        EquationResult.NoRealRoots -> "No real roots. The discriminant is negative."
        EquationResult.InfiniteSolutions -> "Infinitely many solutions: every real x works."
        EquationResult.NoSolution -> "No solution: a nonzero constant cannot equal zero."
        is EquationResult.Error -> result.message

        OutlinedButton(onClick = { a = ""; b = ""; c = ""; showResult = false }) { Text("Clear") }
    }
    val message = when (result) {
        is EquationResult.TwoRoots -> "Two real roots: x₁ = ${number(result.first)}, x₂ = ${number(result.second)}"
        is EquationResult.RepeatedRoot -> "One repeated real root: x = ${number(result.root)}"
        is EquationResult.Linear -> "Linear equation: x = ${number(result.root)}"
        EquationResult.NoRealRoots -> "No real roots. The discriminant is negative."
        EquationResult.InfiniteSolutions -> "Infinitely many solutions: every real x works."
        EquationResult.NoSolution -> "No solution: a nonzero constant cannot equal zero."
        is EquationResult.Error -> result.message
    }
    if (!showResult) Text("Tap Solve to calculate the current equation.")
    if (showResult) Text(
        message,
        style = MaterialTheme.typography.titleLarge,
        color = if (result is EquationResult.Error) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface
    )
    val discriminant = normalizedDiscriminant(a, b, c)
    if (showResult && result !is EquationResult.Error && discriminant != null) {
        Text("Normalized discriminant D′ = ${number(discriminant)}")
        Text("D′ = (b/s)² − 4(a/s)(c/s), with s = max(|a|, |b|, |c|). Its sign matches D = b² − 4ac; scaling avoids overflow for large coefficients.")
    }
    Text("Results use floating-point arithmetic and are rounded to six significant digits. Complex roots are outside this exercise.")
}

@Composable

    }

    @Test fun handlesEveryDegenerateEquation() {
        assertEquals(2.0, (solveEquation("0", "2", "-4") as EquationResult.Linear).root, 0.0)
        assertEquals(EquationResult.InfiniteSolutions, solveEquation("0", "0", "0"))
        assertEquals(EquationResult.NoSolution, solveEquation("0", "0", "5"))
    }

    @Test fun acceptsZeroAndNegativeCoefficients() {
        val result = solveEquation("-1", "0", "4") as EquationResult.TwoRoots
        assertEquals(-2.0, result.first, 0.000001)
        assertEquals(2.0, result.second, 0.000001)
        val zeroRoot = solveEquation("1", "-2", "0") as EquationResult.TwoRoots
        assertEquals(0.0, zeroRoot.first, 0.0)
        assertEquals(2.0, zeroRoot.second, 0.0)
    }

    @Test fun scalesLargeCoefficientsAndPreservesSmallRoot() {
        val large = solveEquation("1e200", "-3e200", "2e200") as EquationResult.TwoRoots
        assertEquals(1.0, large.first, 0.000001)
        assertEquals(2.0, large.second, 0.000001)
        val imbalanced = solveEquation("1", "1e16", "1") as EquationResult.TwoRoots
        assertEquals(-1e16, imbalanced.first, 1.0)
        assertEquals(-1e-16, imbalanced.second, 1e-25)
    }