path: root/tests/stdlib/tmath.nim

discard """
  targets: "c cpp js"
  matrix:"; -d:danger"
"""

# xxx: there should be a test with `-d:nimTmathCase2 -d:danger --passc:-ffast-math`,
# but it requires disabling certain lines with `when not defined(nimTmathCase2)`

import std/[math, random, os]
import std/[unittest]
import std/[sets, tables]


# Function for approximate comparison of floats
proc `==~`(x, y: float): bool = (abs(x-y) < 1e-9)

block: # random int
  block: # there might be some randomness
    var set = initHashSet[int](128)

    for i in 1..1000:
      incl(set, rand(high(int)))
    check len(set) == 1000

  block: # single number bounds work
    var rand: int
    for i in 1..1000:
      rand = rand(1000)
      check rand < 1000
      check rand > -1

  block: # slice bounds work
    var rand: int
    for i in 1..1000:
      rand = rand(100..1000)
      when defined(js): # xxx bug: otherwise fails
        check rand <= 1000
      else:
        check rand < 1000
      check rand >= 100

  block: # again gives new numbers
    var rand1 = rand(1000000)
    when not defined(js):
      os.sleep(200)

    var rand2 = rand(1000000)
    check rand1 != rand2


block: # random float
  block: # there might be some randomness
    var set = initHashSet[float](128)

    for i in 1..100:
      incl(set, rand(1.0))
    check len(set) == 100

  block: # single number bounds work
    var rand: float
    for i in 1..1000:
      rand = rand(1000.0)
      check rand < 1000.0
      check rand > -1.0

  block: # slice bounds work
    var rand: float
    for i in 1..1000:
      rand = rand(100.0..1000.0)
      check rand < 1000.0
      check rand >= 100.0

  block: # again gives new numbers

    var rand1:float = rand(1000000.0)
    when not defined(js):
      os.sleep(200)

    var rand2:float = rand(1000000.0)
    check rand1 != rand2

block: # cumsum
  block: # cumsum int seq return
    let counts = [ 1, 2, 3, 4 ]
    check counts.cumsummed == [ 1, 3, 6, 10 ]

  block: # cumsum float seq return
    let counts = [ 1.0, 2.0, 3.0, 4.0 ]
    check counts.cumsummed == [ 1.0, 3.0, 6.0, 10.0 ]

  block: # cumsum int in-place
    var counts = [ 1, 2, 3, 4 ]
    counts.cumsum
    check counts == [ 1, 3, 6, 10 ]

  block: # cumsum float in-place
    var counts = [ 1.0, 2.0, 3.0, 4.0 ]
    counts.cumsum
    check counts == [ 1.0, 3.0, 6.0, 10.0 ]

block: # random sample
  block: # "non-uniform array sample unnormalized int CDF
    let values = [ 10, 20, 30, 40, 50 ] # values
    let counts = [ 4, 3, 2, 1, 0 ]      # weights aka unnormalized probabilities
    var histo = initCountTable[int]()
    let cdf = counts.cumsummed          # unnormalized CDF
    for i in 0 ..< 5000:
      histo.inc(sample(values, cdf))
    check histo.len == 4                # number of non-zero in `counts`
    # Any one bin is a binomial random var for n samples, each with prob p of
    # adding a count to k; E[k]=p*n, Var k=p*(1-p)*n, approximately Normal for
    # big n.  So, P(abs(k - p*n)/sqrt(p*(1-p)*n))>3.0) =~ 0.0027, while
    # P(wholeTestFails) =~ 1 - P(binPasses)^4 =~ 1 - (1-0.0027)^4 =~ 0.01.
    for i, c in counts:
      if c == 0:
        check values[i] notin histo
        continue
      let p = float(c) / float(cdf[^1])
      let n = 5000.0
      let expected = p * n
      let stdDev = sqrt(n * p * (1.0 - p))
      check abs(float(histo[values[i]]) - expected) <= 3.0 * stdDev

  block: # non-uniform array sample normalized float CDF
    let values = [ 10, 20, 30, 40, 50 ]     # values
    let counts = [ 0.4, 0.3, 0.2, 0.1, 0 ]  # probabilities
    var histo = initCountTable[int]()
    let cdf = counts.cumsummed              # normalized CDF
    for i in 0 ..< 5000:
      histo.inc(sample(values, cdf))
    check histo.len == 4                    # number of non-zero in ``counts``
    for i, c in counts:
      if c == 0:
        check values[i] notin histo
        continue
      let p = float(c) / float(cdf[^1])
      let n = 5000.0
      let expected = p * n
      let stdDev = sqrt(n * p * (1.0 - p))
      # NOTE: like unnormalized int CDF test, P(wholeTestFails) =~ 0.01.
      check abs(float(histo[values[i]]) - expected) <= 3.0 * stdDev

block: # ^
  block: # compiles for valid types
    check: compiles(5 ^ 2)
    check: compiles(5.5 ^ 2)
    check: compiles(5.5 ^ 2.int8)
    check: compiles(5.5 ^ 2.uint)
    check: compiles(5.5 ^ 2.uint8)
    check: not compiles(5.5 ^ 2.2)

block:
  when not defined(js):
    # Check for no side effect annotation
    proc mySqrt(num: float): float {.noSideEffect.} =
      # xxx unused
      return sqrt(num)

    # check gamma function
    doAssert(gamma(5.0) == 24.0) # 4!
    doAssert(lgamma(1.0) == 0.0) # ln(1.0) == 0.0
    doAssert(erf(6.0) > erf(5.0))
    doAssert(erfc(6.0) < erfc(5.0))

    block: # prod
      doAssert prod([1, 2, 3, 4]) == 24
      doAssert prod([1.5, 3.4]).almostEqual 5.1
      let x: seq[float] = @[]
      doAssert prod(x) == 1.0

    block: # splitDecimal() tests
      doAssert splitDecimal(54.674).intpart == 54.0
      doAssert splitDecimal(54.674).floatpart ==~ 0.674
      doAssert splitDecimal(-693.4356).intpart == -693.0
      doAssert splitDecimal(-693.4356).floatpart ==~ -0.4356
      doAssert splitDecimal(0.0).intpart == 0.0
      doAssert splitDecimal(0.0).floatpart == 0.0

    block: # trunc tests for vcc
      doAssert(trunc(-1.1) == -1)
      doAssert(trunc(1.1) == 1)
      doAssert(trunc(-0.1) == -0)
      doAssert(trunc(0.1) == 0)

      #special case
      doAssert(classify(trunc(1e1000000)) == fcInf)
      doAssert(classify(trunc(-1e1000000)) == fcNegInf)
      when not defined(nimTmathCase2):
        doAssert(classify(trunc(0.0/0.0)) == fcNan)
      doAssert(classify(trunc(0.0)) == fcZero)

      #trick the compiler to produce signed zero
      let
        f_neg_one = -1.0
        f_zero = 0.0
        f_nan = f_zero / f_zero

      doAssert(classify(trunc(f_neg_one*f_zero)) == fcNegZero)

      doAssert(trunc(-1.1'f32) == -1)
      doAssert(trunc(1.1'f32) == 1)
      doAssert(trunc(-0.1'f32) == -0)
      doAssert(trunc(0.1'f32) == 0)
      doAssert(classify(trunc(1e1000000'f32)) == fcInf)
      doAssert(classify(trunc(-1e1000000'f32)) == fcNegInf)
      when not defined(nimTmathCase2):
        doAssert(classify(trunc(f_nan.float32)) == fcNan)
      doAssert(classify(trunc(0.0'f32)) == fcZero)

    block: # sgn() tests
      doAssert sgn(1'i8) == 1
      doAssert sgn(1'i16) == 1
      doAssert sgn(1'i32) == 1
      doAssert sgn(1'i64) == 1
      doAssert sgn(1'u8) == 1
      doAssert sgn(1'u16) == 1
      doAssert sgn(1'u32) == 1
      doAssert sgn(1'u64) == 1
      doAssert sgn(-12342.8844'f32) == -1
      doAssert sgn(123.9834'f64) == 1
      doAssert sgn(0'i32) == 0
      doAssert sgn(0'f32) == 0
      doAssert sgn(NegInf) == -1
      doAssert sgn(Inf) == 1
      doAssert sgn(NaN) == 0

    block: # fac() tests
      try:
        discard fac(-1)
      except AssertionDefect:
        discard

      doAssert fac(0) == 1
      doAssert fac(1) == 1
      doAssert fac(2) == 2
      doAssert fac(3) == 6
      doAssert fac(4) == 24

    block: # floorMod/floorDiv
      doAssert floorDiv(8, 3) == 2
      doAssert floorMod(8, 3) == 2

      doAssert floorDiv(8, -3) == -3
      doAssert floorMod(8, -3) == -1

      doAssert floorDiv(-8, 3) == -3
      doAssert floorMod(-8, 3) == 1

      doAssert floorDiv(-8, -3) == 2
      doAssert floorMod(-8, -3) == -2

      doAssert floorMod(8.0, -3.0) == -1.0
      doAssert floorMod(-8.5, 3.0) == 0.5

    block: # euclDiv/euclMod
      doAssert euclDiv(8, 3) == 2
      doAssert euclMod(8, 3) == 2

      doAssert euclDiv(8, -3) == -2
      doAssert euclMod(8, -3) == 2

      doAssert euclDiv(-8, 3) == -3
      doAssert euclMod(-8, 3) == 1

      doAssert euclDiv(-8, -3) == 3
      doAssert euclMod(-8, -3) == 1

      doAssert euclMod(8.0, -3.0) == 2.0
      doAssert euclMod(-8.5, 3.0) == 0.5

      doAssert euclDiv(9, 3) == 3
      doAssert euclMod(9, 3) == 0

      doAssert euclDiv(9, -3) == -3
      doAssert euclMod(9, -3) == 0

      doAssert euclDiv(-9, 3) == -3
      doAssert euclMod(-9, 3) == 0

      doAssert euclDiv(-9, -3) == 3
      doAssert euclMod(-9, -3) == 0

    block: # log
      doAssert log(4.0, 3.0) ==~ ln(4.0) / ln(3.0)
      doAssert log2(8.0'f64) == 3.0'f64
      doAssert log2(4.0'f64) == 2.0'f64
      doAssert log2(2.0'f64) == 1.0'f64
      doAssert log2(1.0'f64) == 0.0'f64
      doAssert classify(log2(0.0'f64)) == fcNegInf

      doAssert log2(8.0'f32) == 3.0'f32
      doAssert log2(4.0'f32) == 2.0'f32
      doAssert log2(2.0'f32) == 1.0'f32
      doAssert log2(1.0'f32) == 0.0'f32
      doAssert classify(log2(0.0'f32)) == fcNegInf

template main =
  # xxx wrap all under `main` so it also gets tested in vm.
  block: # signbit
    doAssert not signbit(0.0)
    doAssert signbit(-0.0)
    doAssert signbit(-0.1)
    doAssert not signbit(0.1)

    doAssert not signbit(Inf)
    doAssert signbit(-Inf)
    doAssert not signbit(NaN)

  block: # isNaN
    doAssert NaN.isNaN
    doAssert not Inf.isNaN
    doAssert isNaN(Inf - Inf)

  block: # signbit
    let x1 = NaN
    let x2 = -NaN
    let x3 = -x1

    doAssert isNaN(x1)
    doAssert isNaN(x2)
    doAssert isNaN(x3)
    doAssert not signbit(x1)
    doAssert signbit(x2)
    doAssert signbit(x3)

  block: # copySign
    doAssert copySign(10.0, -1.0) == -10.0
    doAssert copySign(-10.0, -1.0) == -10.0
    doAssert copySign(-10.0, 1.0) == 10.0
    doAssert copySign(float(10), -1.0) == -10.0

    doAssert copySign(10.0'f64, -1.0) == -10.0
    doAssert copySign(-10.0'f64, -1.0) == -10.0
    doAssert copySign(-10.0'f64, 1.0) == 10.0
    doAssert copySign(10'f64, -1.0) == -10.0

    doAssert copySign(10.0'f32, -1.0) == -10.0
    doAssert copySign(-10.0'f32, -1.0) == -10.0
    doAssert copySign(-10.0'f32, 1.0) == 10.0
    doAssert copySign(10'f32, -1.0) == -10.0

    doAssert copySign(Inf, -1.0) == -Inf
    doAssert copySign(-Inf, 1.0) == Inf
    doAssert copySign(Inf, 1.0) == Inf
    doAssert copySign(-Inf, -1.0) == -Inf
    doAssert copySign(Inf, 0.0) == Inf
    doAssert copySign(Inf, -0.0) == -Inf
    doAssert copySign(-Inf, 0.0) == Inf
    doAssert copySign(-Inf, -0.0) == -Inf
    doAssert copySign(1.0, -0.0) == -1.0
    doAssert copySign(0.0, -0.0) == -0.0
    doAssert copySign(-1.0, 0.0) == 1.0
    doAssert copySign(10.0, 0.0) == 10.0
    doAssert copySign(-1.0, NaN) == 1.0
    doAssert copySign(10.0, NaN) == 10.0

    doAssert copySign(NaN, NaN).isNaN
    doAssert copySign(-NaN, NaN).isNaN
    doAssert copySign(NaN, -NaN).isNaN
    doAssert copySign(-NaN, -NaN).isNaN
    doAssert copySign(NaN, 0.0).isNaN
    doAssert copySign(NaN, -0.0).isNaN
    doAssert copySign(-NaN, 0.0).isNaN
    doAssert copySign(-NaN, -0.0).isNaN

    block: # round() tests
      block: # Round to 0 decimal places
        doAssert round(54.652) == 55.0
        doAssert round(54.352) == 54.0
        doAssert round(-54.652) == -55.0
        doAssert round(-54.352) == -54.0
        doAssert round(0.0) == 0.0
        doAssert 1 / round(0.0) == Inf
        doAssert 1 / round(-0.0) == -Inf
        doAssert round(Inf) == Inf
        doAssert round(-Inf) == -Inf
        doAssert round(NaN).isNaN
        doAssert round(-NaN).isNaN
        doAssert round(-0.5) == -1.0
        doAssert round(0.5) == 1.0
        doAssert round(-1.5) == -2.0
        doAssert round(1.5) == 2.0
        doAssert round(-2.5) == -3.0
        doAssert round(2.5) == 3.0
        doAssert round(2.5'f32) == 3.0'f32
        doAssert round(2.5'f64) == 3.0'f64
      block: # func round*[T: float32|float64](x: T, places: int): T
        doAssert round(54.345, 0) == 54.0
        template fn(x) =
          doAssert round(x, 2).almostEqual 54.35
          doAssert round(x, 2).almostEqual 54.35
          doAssert round(x, -1).almostEqual 50.0
          doAssert round(x, -2).almostEqual 100.0
          doAssert round(x, -3).almostEqual 0.0
        fn(54.346)
        fn(54.346'f32)

    when nimvm:
      discard
    else:
      when not defined(js):
        doAssert copySign(-1.0, -NaN) == -1.0
        doAssert copySign(10.0, -NaN) == -10.0
        doAssert copySign(1.0, copySign(NaN, -1.0)) == -1.0 # fails in VM

  block:
    doAssert 1.0 / abs(-0.0) == Inf
    doAssert 1.0 / abs(0.0) == Inf
    doAssert -1.0 / abs(-0.0) == -Inf
    doAssert -1.0 / abs(0.0) == -Inf
    doAssert abs(0.0) == 0.0
    doAssert abs(0.0'f32) == 0.0'f32

    doAssert abs(Inf) == Inf
    doAssert abs(-Inf) == Inf
    doAssert abs(NaN).isNaN
    doAssert abs(-NaN).isNaN

static: main()
main()