plum

import std/Bool
import std/Str
import std/Number

# Regression coverage for `plum-std/Number.plum` — the methods it now hosts
# for BOTH `Int` and `Float` (via `match self`), after `Int.plum`/`Float.plum`
# were folded into it and deleted. Every call below reaches its method
# through the primitive-to-wrapping-enum dispatch fallback (`Int`/`Float`
# have no method tables of their own any more).

fun toInt(n: Number) -> Int =
  match n
    Int(i) => i
    Float(f) => Int(f)

test "abs works for both Int and Float, wrapping back into the same variant"
  assert {-5}.abs().kind() == "Int"
  assert {-2.5}.abs().kind() == "Float"

test "sign returns -1/0/1 (or the matching Float) for both Int and Float"
  assert toInt({5}.sign()) == 1
  assert toInt({-5}.sign()) == -1
  assert toInt({0}.sign()) == 0

test "hash is identity for Int and truncating for Float"
  assert {5}.hash() == 5
  assert {5.9}.hash() == 5

test "trunc/floor/ceil/round agree with Int passthrough and real Float math"
  assert {5}.trunc() == 5.0f
  assert {2.7}.trunc() == 2.0f
  assert {-2.7}.trunc() == -2.0f
  assert {2.7}.floor() == 2.0f
  assert {-2.7}.floor() == -3.0f
  assert {2.3}.ceil() == 3.0f
  assert {-2.3}.ceil() == -2.0f
  assert {2.5}.round() == 3.0f
  assert {-2.5}.round() == -3.0f

test "sqrt works for Int (via Float conversion) and Float directly"
  assert {4}.sqrt() == 2.0f
  assert {2.25}.sqrt() == 1.5f

test "pow computes integer powers exactly for both Int and Float self"
  assert {2}.pow(10.0f) == 1024.0f
  assert {2.0}.pow(10.0f) == 1024.0f

test "log2/log10 agree between Int and the equivalent Float"
  # `log`/`log2`/`log10` are built on the Taylor-series `ln` approximation
  # (see `plum-std/Number.plum`'s `ln`), not exact libm — compare within a
  # small epsilon rather than requiring bit-exact equality.
  a := {8}.log2()
  b := {8.0}.log2()
  assert {a - b}.abs().toFloatValue() < 0.0001f
  c := {100}.log10()
  d := {100.0}.log10()
  assert {c - d}.abs().toFloatValue() < 0.0001f

test "isFinite/isInfinite/isNaN are always well-defined for Int, real for Float"
  assert {5}.isFinite()
  assert !{5}.isInfinite()
  assert !{5}.isNaN()
  assert {1.0f / 0.0f}.isInfinite()
  assert {0.0f / 0.0f}.isNaN()
  assert {1.5}.isFinite()

test "min/max compare across Int and Float without losing the original variant"
  assert {3}.min(5).kind() == "Int"
  assert {3}.max(2.5).kind() == "Int"
  assert {2.5}.min(3).kind() == "Float"

test "toStr renders Int and Float correctly, including negatives and fractions"
  assert {42}.toStr() == "42"
  assert {-7}.toStr() == "-7"
  assert {0}.toStr() == "0"
  assert {3.5}.toStr() == "3.5"
  assert {-3.5}.toStr() == "-3.5"

test "parseInt/parseFloat round-trip a rendered number"
  assert parseInt("123").unwrapOr(-1) == 123
  assert parseInt("-45").unwrapOr(1) == -45
  assert parseFloat("3.25").unwrapOr(-1.0f) == 3.25f

test "trig/hyperbolic/exp/ln free functions and Number methods still work post-migration"
  assert sin(0.0f) == 0.0f
  assert cos(0.0f) == 1.0f
  assert {0}.sinh() == 0.0f
  assert {0}.cosh() == 1.0f

test "string interpolation of a Float value works, via Number.toStr"
  x := 3.5f
  assert "value is {x}" == "value is 3.5"
  y := {8}.log2()
  assert "computed is {y}" == "computed is 3.0"

test "assert of two directly-chained Float method calls renders a real failure message"
  # Previously crashed the whole compile with "interpolating a Float value is
  # not yet supported" instead of a normal pass/fail report — `looksLikeFloat`
  # only caught an OBVIOUS float literal on either side of the comparison,
  # missing any Float-typed expression that wasn't written as one (like these
  # chained method calls). Fixed at the root: `"{expr}"` interpolation of a
  # Float now genuinely works (via `Number.toStr`), so the "Expected/Actual"
  # failure-message machinery no longer needs to special-case Float at all.
  assert {8}.log2() == {8.0}.log2()