# -*- coding: utf-8 -*-

from ..syntax import macros, test, test_raises, warn, the # noqa: F401

from ..test.fixtures import session, testset

from itertools import count, takewhile

from math import cos, sqrt

import sys

from ..numutil import (almosteq, fixpoint, ulp,

partition_int, partition_int_triangular, partition_int_custom)

from ..it import rev

def runtests():

with testset("ulp (unit in the last place; float utility)"):

test[ulp(1.0) == sys.float_info.epsilon]

# test also at some base-2 exponent switch points

test[ulp(2.0) == 2 * sys.float_info.epsilon]

test[ulp(0.5) == 0.5 * sys.float_info.epsilon]

with testset("almosteq"):

# For anything but floating-point inputs, it's exact equality.

test[almosteq("abc", "abc")]

test[not almosteq("ab", "abc")]

test[almosteq(1.0, 1.0 + ulp(1.0))]

# TODO: counterintuitively, need a large tolerance here, because when one operand is zero,

# TODO: the final tolerance is actually tol*min_normal.

min_normal = sys.float_info.min

test[almosteq(min_normal / 2, 0, tol=1.0)]

too_large = 2**int(1e6)

test_raises[OverflowError, float(too_large), "UPDATE THIS, need a float overflow here."]

test[almosteq(too_large, too_large + 1)] # works, because 1/too_large is very small.

try:

from mpmath import mpf

except ImportError: # pragma: no cover

warn["mpmath not installed in this Python, skipping arbitrary precision input tests."]

else:

test[almosteq(mpf(1.0), mpf(1.0 + ulp(1.0)))]

test[almosteq(1.0, mpf(1.0 + ulp(1.0)))]

test[almosteq(mpf(1.0), 1.0 + ulp(1.0))]

# Arithmetic fixed points.

with testset("fixpoint (arithmetic fixed points)"):

c = fixpoint(cos, x0=1)

test[the[c] == the[cos(c)]] # 0.7390851332151607

# Actually "Newton's" algorithm for the square root was already known to the

# ancient Babylonians, ca. 2000 BCE. (Carl Boyer: History of mathematics)

# Concerning naming, see also https://en.wikipedia.org/wiki/Stigler's_law_of_eponymy

def sqrt_newton(n):

def sqrt_iter(x): # has an attractive fixed point at sqrt(n)

return (x + n / x) / 2

return fixpoint(sqrt_iter, x0=n / 2)

# different algorithm, so not necessarily equal down to the last bit

# (caused by the fixpoint update becoming smaller than the ulp, so it

# stops there, even if the limit is still one ulp away).

test[abs(the[sqrt_newton(2)] - the[sqrt(2)]) <= the[ulp(1.414)]]

# partition_int: split a small positive integer, in all possible ways, into smaller integers that sum to it

with testset("partition_int"):

test[tuple(partition_int(4)) == ((4,), (3, 1), (2, 2), (2, 1, 1), (1, 3), (1, 2, 1), (1, 1, 2), (1, 1, 1, 1))]

test[tuple(partition_int(5, lower=2)) == ((5,), (3, 2), (2, 3))]

test[tuple(partition_int(5, lower=2, upper=3)) == ((3, 2), (2, 3))]

test[tuple(partition_int(10, lower=3, upper=5)) == ((5, 5), (4, 3, 3), (3, 4, 3), (3, 3, 4))]

test[all(sum(terms) == 10 for terms in partition_int(10))]

test[all(sum(terms) == 10 for terms in partition_int(10, lower=3))]

test[all(sum(terms) == 10 for terms in partition_int(10, lower=3, upper=5))]

test_raises[TypeError, partition_int("not a number")]

test_raises[TypeError, partition_int(4, lower="not a number")]

test_raises[TypeError, partition_int(4, upper="not a number")]

test_raises[ValueError, partition_int(-3)]

test_raises[ValueError, partition_int(4, lower=-1)]

test_raises[ValueError, partition_int(4, lower=5)]

test_raises[ValueError, partition_int(4, upper=-1)]

test_raises[ValueError, partition_int(4, upper=5)]

test_raises[ValueError, partition_int(4, lower=3, upper=2)]

# partition_int_triangular: like partition_int, but in the output, allow triangular numbers only.

# Triangular numbers are 1, 3, 6, 10, ...

with testset("partition_int_triangular"):

test[frozenset(tuple(sorted(c)) for c in partition_int_triangular(78, lower=10)) ==

frozenset({(10, 10, 10, 10, 10, 28),

(10, 10, 15, 15, 28),

(15, 21, 21, 21),

(21, 21, 36),

(78,)})]

# partition_int_custom: like partition_int, but lets you specify allowed components manually.

# Can be used to build other functions like `partition_int` and `partition_int_triangular`.

with testset("partition_int_custom"):

test[tuple(partition_int_custom(4, [1])) == ((1, 1, 1, 1),)]

test[tuple(partition_int_custom(4, [1, 3])) == ((1, 1, 1, 1), (1, 3), (3, 1))]

evens_upto_n = lambda n: takewhile(lambda m: m <= n, count(start=2, step=2))

test[tuple(partition_int_custom(4, rev(evens_upto_n(4)))) == ((4,), (2, 2))]

test[tuple(partition_int_custom(6, rev(evens_upto_n(6)))) == ((6,), (4, 2), (2, 4), (2, 2, 2))]

test_raises[TypeError, partition_int_custom("not a number", evens_upto_n("blah"))]

test_raises[TypeError, tuple(partition_int_custom(4, [2.0]))]

test_raises[ValueError, partition_int_custom(-3, evens_upto_n(-3))]

test_raises[ValueError, tuple(partition_int_custom(4, [-1]))]

test_raises[ValueError, tuple(partition_int_custom(4, [1, -1]))]

if __name__ == '__main__': # pragma: no cover

with session(__file__):

runtests()