Restrict libmp exports to public API
This is following namespace:
```
{'BACKEND', 'ComplexResult', 'MPZ', 'MPZ_ONE', 'NoConvergence',
'catalan_fixed', 'dps_to_prec', 'euler_fixed', 'fhalf', 'finf',
'fnan', 'fninf', 'fnone', 'fone', 'from_float', 'from_int', 'from_man_exp',
'from_rational', 'from_str', 'fzero', 'giant_steps', 'ifac', 'ifib',
'int_types', 'isqrt', 'mpc_abs', 'mpc_exp', 'mpc_pow', 'mpc_pow_int',
'mpc_pow_mpf', 'mpc_sqrt', 'mpf_abs', 'mpf_add', 'mpf_atan', 'mpf_atan2',
'mpf_bernoulli', 'mpf_ceil', 'mpf_cmp', 'mpf_cos', 'mpf_cosh_sinh', 'mpf_div',
'mpf_e', 'mpf_eq', 'mpf_exp', 'mpf_floor', 'mpf_ge', 'mpf_gt', 'mpf_le',
'mpf_log', 'mpf_lt', 'mpf_mod', 'mpf_mul', 'mpf_neg', 'mpf_pi', 'mpf_pow',
'mpf_pow_int', 'mpf_shift', 'mpf_sign', 'mpf_sin', 'mpf_sqrt', 'mpf_sub',
'mpf_tan', 'normalize', 'phi_fixed', 'prec_to_dps', 'repr_dps',
'round_nearest', 'sqrtrem', 'to_float', 'to_int', 'to_man_exp', 'to_rational',
'to_str'}
```
Closes #704
This commit is contained in:
Sergey B Kirpichev
+5
-3
@@ -8,9 +8,11 @@ Run with:
|
||||
python manydigits.py
|
||||
|
||||
"""
|
||||
from mpmath import (mp, sin, tan, cos, sqrt, e, pi, exp, atanh, mpf, tanh,
|
||||
zeta, catalan, findroot, quadts, atan, asin, asinh)
|
||||
from mpmath.libmp import to_fixed, bin_to_radix
|
||||
from mpmath import (asin, asinh, atan, atanh, catalan, cos, e, exp, findroot,
|
||||
mp, mpf, pi, quadts, sin, sqrt, tan, tanh, zeta)
|
||||
from mpmath.libmp.libintmath import bin_to_radix
|
||||
from mpmath.libmp.libmpf import to_fixed
|
||||
|
||||
|
||||
dps = 100
|
||||
mp.dps = dps + 10
|
||||
|
||||
+4
-2
@@ -5,11 +5,13 @@ Calculate digits of pi. This module can be run interactively with
|
||||
|
||||
"""
|
||||
|
||||
import sys
|
||||
import math
|
||||
import sys
|
||||
from time import perf_counter
|
||||
|
||||
from mpmath.libmp import bin_to_radix, numeral, pi_fixed
|
||||
from mpmath.libmp.libelefun import pi_fixed
|
||||
from mpmath.libmp.libintmath import bin_to_radix, numeral
|
||||
|
||||
|
||||
def display_fraction(digits, skip=0, colwidth=10, columns=5):
|
||||
perline = colwidth * columns
|
||||
|
||||
+9
-9
@@ -1,5 +1,5 @@
|
||||
from operator import gt, lt
|
||||
import random
|
||||
from operator import gt, lt
|
||||
|
||||
from . import libmp
|
||||
from .calculus.calculus import CalculusMethods
|
||||
@@ -338,15 +338,15 @@ class StandardBaseContext(Context,
|
||||
def _default_hyper_maxprec(ctx, p):
|
||||
return int(1000 * p**0.25 + 4*p)
|
||||
|
||||
_gcd = staticmethod(libmp.gcd)
|
||||
list_primes = staticmethod(libmp.list_primes)
|
||||
isprime = staticmethod(libmp.isprime)
|
||||
bernfrac = staticmethod(libmp.bernfrac)
|
||||
moebius = staticmethod(libmp.moebius)
|
||||
_gcd = staticmethod(libmp.libintmath.gcd)
|
||||
list_primes = staticmethod(libmp.libintmath.list_primes)
|
||||
isprime = staticmethod(libmp.libintmath.isprime)
|
||||
bernfrac = staticmethod(libmp.gammazeta.bernfrac)
|
||||
moebius = staticmethod(libmp.libintmath.moebius)
|
||||
_ifac = staticmethod(libmp.ifac)
|
||||
_eulernum = staticmethod(libmp.eulernum)
|
||||
_stirling1 = staticmethod(libmp.stirling1)
|
||||
_stirling2 = staticmethod(libmp.stirling2)
|
||||
_eulernum = staticmethod(libmp.libintmath.eulernum)
|
||||
_stirling1 = staticmethod(libmp.libintmath.stirling1)
|
||||
_stirling2 = staticmethod(libmp.libintmath.stirling2)
|
||||
|
||||
def sum_accurately(ctx, terms, check_step=1):
|
||||
prec = ctx.prec
|
||||
|
||||
+38
-37
@@ -2,15 +2,16 @@ import inspect
|
||||
import numbers
|
||||
import sys
|
||||
|
||||
from . import function_docs
|
||||
from . import libmp
|
||||
from . import function_docs, libmp
|
||||
from .libmp import (MPZ_ONE, ComplexResult, dps_to_prec, finf, fnan, fninf,
|
||||
from_float, from_int, from_str, fzero, int_types, mpc_hash,
|
||||
mpci_abs, mpci_add, mpci_div, mpci_mul, mpci_neg, mpci_pos,
|
||||
mpci_pow, mpci_sub, mpf_hash, mpf_le, mpf_neg, mpf_pos,
|
||||
mpi_abs, mpi_add, mpi_delta, mpi_div, mpi_from_str,
|
||||
mpi_mid, mpi_mul, mpi_neg, mpi_pos, mpi_pow, mpi_str,
|
||||
mpi_sub, prec_to_dps, repr_dps, round_ceiling, round_floor)
|
||||
from_float, from_int, from_str, fzero, int_types, mpf_le,
|
||||
mpf_neg, prec_to_dps, repr_dps, round_ceiling, round_floor)
|
||||
from .libmp.libmpc import mpc_hash
|
||||
from .libmp.libmpf import mpf_hash, mpf_pos
|
||||
from .libmp.libmpi import (mpci_abs, mpci_add, mpci_div, mpci_mul, mpci_neg,
|
||||
mpci_pos, mpci_pow, mpci_sub, mpi_abs, mpi_add,
|
||||
mpi_delta, mpi_div, mpi_from_str, mpi_mid, mpi_mul,
|
||||
mpi_neg, mpi_pos, mpi_pow, mpi_str, mpi_sub)
|
||||
from .matrices.matrices import _matrix
|
||||
|
||||
|
||||
@@ -134,12 +135,12 @@ class ivmpf:
|
||||
return NotImplemented
|
||||
return cmpfun(s._mpi_, t._mpi_)
|
||||
|
||||
def __eq__(s, t): return s._compare(t, libmp.mpi_eq)
|
||||
def __ne__(s, t): return s._compare(t, libmp.mpi_ne)
|
||||
def __lt__(s, t): return s._compare(t, libmp.mpi_lt)
|
||||
def __le__(s, t): return s._compare(t, libmp.mpi_le)
|
||||
def __gt__(s, t): return s._compare(t, libmp.mpi_gt)
|
||||
def __ge__(s, t): return s._compare(t, libmp.mpi_ge)
|
||||
def __eq__(s, t): return s._compare(t, libmp.libmpi.mpi_eq)
|
||||
def __ne__(s, t): return s._compare(t, libmp.libmpi.mpi_ne)
|
||||
def __lt__(s, t): return s._compare(t, libmp.libmpi.mpi_lt)
|
||||
def __le__(s, t): return s._compare(t, libmp.libmpi.mpi_le)
|
||||
def __gt__(s, t): return s._compare(t, libmp.libmpi.mpi_gt)
|
||||
def __ge__(s, t): return s._compare(t, libmp.libmpi.mpi_ge)
|
||||
|
||||
def __abs__(self):
|
||||
return self.ctx.make_mpf(mpi_abs(self._mpi_, self.ctx.prec))
|
||||
@@ -329,29 +330,29 @@ class MPIntervalContext(StandardBaseContext):
|
||||
ctx.ninf = -ctx.inf
|
||||
ctx.nan = ctx.mpf('nan')
|
||||
ctx.j = ctx.mpc(0,1)
|
||||
ctx.exp = ctx._wrap_mpi_function(libmp.mpi_exp, libmp.mpci_exp)
|
||||
ctx.sqrt = ctx._wrap_mpi_function(libmp.mpi_sqrt)
|
||||
ctx.ln = ctx._wrap_mpi_function(libmp.mpi_log, libmp.mpci_log)
|
||||
ctx.cos = ctx._wrap_mpi_function(libmp.mpi_cos, libmp.mpci_cos)
|
||||
ctx.sin = ctx._wrap_mpi_function(libmp.mpi_sin, libmp.mpci_sin)
|
||||
ctx.tan = ctx._wrap_mpi_function(libmp.mpi_tan)
|
||||
ctx.gamma = ctx._wrap_mpi_function(libmp.mpi_gamma, libmp.mpci_gamma)
|
||||
ctx.loggamma = ctx._wrap_mpi_function(libmp.mpi_loggamma, libmp.mpci_loggamma)
|
||||
ctx.rgamma = ctx._wrap_mpi_function(libmp.mpi_rgamma, libmp.mpci_rgamma)
|
||||
ctx.factorial = ctx._wrap_mpi_function(libmp.mpi_factorial, libmp.mpci_factorial)
|
||||
ctx.exp = ctx._wrap_mpi_function(libmp.libmpi.mpi_exp, libmp.libmpi.mpci_exp)
|
||||
ctx.sqrt = ctx._wrap_mpi_function(libmp.libmpi.mpi_sqrt)
|
||||
ctx.ln = ctx._wrap_mpi_function(libmp.libmpi.mpi_log, libmp.libmpi.mpci_log)
|
||||
ctx.cos = ctx._wrap_mpi_function(libmp.libmpi.mpi_cos, libmp.libmpi.mpci_cos)
|
||||
ctx.sin = ctx._wrap_mpi_function(libmp.libmpi.mpi_sin, libmp.libmpi.mpci_sin)
|
||||
ctx.tan = ctx._wrap_mpi_function(libmp.libmpi.mpi_tan)
|
||||
ctx.gamma = ctx._wrap_mpi_function(libmp.libmpi.mpi_gamma, libmp.libmpi.mpci_gamma)
|
||||
ctx.loggamma = ctx._wrap_mpi_function(libmp.libmpi.mpi_loggamma, libmp.libmpi.mpci_loggamma)
|
||||
ctx.rgamma = ctx._wrap_mpi_function(libmp.libmpi.mpi_rgamma, libmp.libmpi.mpci_rgamma)
|
||||
ctx.factorial = ctx._wrap_mpi_function(libmp.libmpi.mpi_factorial, libmp.libmpi.mpci_factorial)
|
||||
ctx.fac = ctx.factorial
|
||||
|
||||
ctx.eps = ctx._constant(lambda prec, rnd: (0, MPZ_ONE, 1-prec, 1))
|
||||
ctx.pi = ctx._constant(libmp.mpf_pi)
|
||||
ctx.e = ctx._constant(libmp.mpf_e)
|
||||
ctx.ln2 = ctx._constant(libmp.mpf_ln2)
|
||||
ctx.ln10 = ctx._constant(libmp.mpf_ln10)
|
||||
ctx.phi = ctx._constant(libmp.mpf_phi)
|
||||
ctx.euler = ctx._constant(libmp.mpf_euler)
|
||||
ctx.catalan = ctx._constant(libmp.mpf_catalan)
|
||||
ctx.glaisher = ctx._constant(libmp.mpf_glaisher)
|
||||
ctx.khinchin = ctx._constant(libmp.mpf_khinchin)
|
||||
ctx.twinprime = ctx._constant(libmp.mpf_twinprime)
|
||||
ctx.ln2 = ctx._constant(libmp.libelefun.mpf_ln2)
|
||||
ctx.ln10 = ctx._constant(libmp.libelefun.mpf_ln10)
|
||||
ctx.phi = ctx._constant(libmp.libelefun.mpf_phi)
|
||||
ctx.euler = ctx._constant(libmp.gammazeta.mpf_euler)
|
||||
ctx.catalan = ctx._constant(libmp.gammazeta.mpf_catalan)
|
||||
ctx.glaisher = ctx._constant(libmp.gammazeta.mpf_glaisher)
|
||||
ctx.khinchin = ctx._constant(libmp.gammazeta.mpf_khinchin)
|
||||
ctx.twinprime = ctx._constant(libmp.gammazeta.mpf_twinprime)
|
||||
|
||||
def _wrap_mpi_function(ctx, f_real, f_complex=None):
|
||||
def g(x, **kwargs):
|
||||
@@ -444,17 +445,17 @@ class MPIntervalContext(StandardBaseContext):
|
||||
def nstr(ctx, x, n=5, **kwargs):
|
||||
x = ctx.convert(x)
|
||||
if hasattr(x, "_mpi_"):
|
||||
return libmp.mpi_to_str(x._mpi_, n, **kwargs)
|
||||
return libmp.libmpi.mpi_to_str(x._mpi_, n, **kwargs)
|
||||
if hasattr(x, "_mpci_"):
|
||||
re = libmp.mpi_to_str(x._mpci_[0], n, **kwargs)
|
||||
im = libmp.mpi_to_str(x._mpci_[1], n, **kwargs)
|
||||
re = libmp.libmpi.mpi_to_str(x._mpci_[0], n, **kwargs)
|
||||
im = libmp.libmpi.mpi_to_str(x._mpci_[1], n, **kwargs)
|
||||
return "(%s + %s*j)" % (re, im)
|
||||
|
||||
def mag(ctx, x):
|
||||
x = ctx.convert(x)
|
||||
if isinstance(x, ctx.mpc):
|
||||
return max(ctx.mag(x.real), ctx.mag(x.imag)) + 1
|
||||
a, b = libmp.mpi_abs(x._mpi_)
|
||||
a, b = libmp.libmpi.mpi_abs(x._mpi_)
|
||||
sign, man, exp, bc = b
|
||||
if man:
|
||||
return exp+bc
|
||||
@@ -495,7 +496,7 @@ class MPIntervalContext(StandardBaseContext):
|
||||
def atan2(ctx, y, x):
|
||||
y = ctx.convert(y)._mpi_
|
||||
x = ctx.convert(x)._mpi_
|
||||
return ctx.make_mpf(libmp.mpi_atan2(y,x,ctx.prec))
|
||||
return ctx.make_mpf(libmp.libmpi.mpi_atan2(y,x,ctx.prec))
|
||||
|
||||
def _convert_param(ctx, x):
|
||||
if isinstance(x, libmp.int_types):
|
||||
|
||||
+76
-71
@@ -9,16 +9,21 @@ import sys
|
||||
|
||||
from . import function_docs, libmp
|
||||
from .ctx_base import StandardBaseContext
|
||||
from .libmp import (MPQ, MPZ_ONE, ComplexResult, dps_to_prec, finf, fnan,
|
||||
fninf, fone, from_rational, fzero, int_types, mpc_add,
|
||||
mpc_add_mpf, mpc_div, mpc_div_mpf, mpc_mpf_div,
|
||||
mpc_mpf_sub, mpc_mul, mpc_mul_mpf, mpc_neg, mpc_sub,
|
||||
mpc_sub_mpf, mpc_to_str, mpf_add, mpf_apery, mpf_catalan,
|
||||
mpf_degree, mpf_div, mpf_e, mpf_euler, mpf_glaisher,
|
||||
mpf_khinchin, mpf_ln2, mpf_ln10, mpf_mertens, mpf_mul,
|
||||
mpf_neg, mpf_phi, mpf_pi, mpf_rand, mpf_sub, mpf_twinprime,
|
||||
repr_dps, round_nearest, to_man_exp, to_str)
|
||||
from .ctx_mp_python import PythonMPContext as BaseMPContext
|
||||
from .libmp import (MPZ_ONE, ComplexResult, dps_to_prec, finf, fnan, fninf,
|
||||
fone, from_rational, fzero, int_types, mpf_add, mpf_div,
|
||||
mpf_mul, mpf_neg, mpf_sub, repr_dps, round_nearest,
|
||||
to_man_exp, to_str)
|
||||
from .libmp.backend import MPQ
|
||||
from .libmp.gammazeta import (mpf_apery, mpf_catalan, mpf_euler, mpf_glaisher,
|
||||
mpf_khinchin, mpf_mertens, mpf_twinprime)
|
||||
from .libmp.libelefun import (mpf_degree, mpf_e, mpf_ln2, mpf_ln10, mpf_phi,
|
||||
mpf_pi)
|
||||
from .libmp.libmpc import (mpc_add, mpc_add_mpf, mpc_div, mpc_div_mpf,
|
||||
mpc_mpf_div, mpc_mpf_sub, mpc_mul, mpc_mul_mpf,
|
||||
mpc_neg, mpc_sub, mpc_sub_mpf, mpc_to_str)
|
||||
from .libmp.libmpf import mpf_rand
|
||||
|
||||
|
||||
get_complex = re.compile(r"""
|
||||
\(?
|
||||
@@ -99,50 +104,50 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
|
||||
# Standard functions
|
||||
ctx.sqrt = ctx._wrap_libmp_function(libmp.mpf_sqrt, libmp.mpc_sqrt)
|
||||
ctx.cbrt = ctx._wrap_libmp_function(libmp.mpf_cbrt, libmp.mpc_cbrt)
|
||||
ctx.ln = ctx._wrap_libmp_function(libmp.mpf_ln, libmp.mpc_ln)
|
||||
ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
|
||||
ctx.cbrt = ctx._wrap_libmp_function(libmp.libelefun.mpf_cbrt, libmp.libmpc.mpc_cbrt)
|
||||
ctx.ln = ctx._wrap_libmp_function(libmp.libelefun.mpf_ln, libmp.libmpc.mpc_ln)
|
||||
ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.libmpc.mpc_atan)
|
||||
ctx.exp = ctx._wrap_libmp_function(libmp.mpf_exp, libmp.mpc_exp)
|
||||
ctx.expj = ctx._wrap_libmp_function(libmp.mpf_expj, libmp.mpc_expj)
|
||||
ctx.expjpi = ctx._wrap_libmp_function(libmp.mpf_expjpi, libmp.mpc_expjpi)
|
||||
ctx.sin = ctx._wrap_libmp_function(libmp.mpf_sin, libmp.mpc_sin)
|
||||
ctx.cos = ctx._wrap_libmp_function(libmp.mpf_cos, libmp.mpc_cos)
|
||||
ctx.tan = ctx._wrap_libmp_function(libmp.mpf_tan, libmp.mpc_tan)
|
||||
ctx.sinh = ctx._wrap_libmp_function(libmp.mpf_sinh, libmp.mpc_sinh)
|
||||
ctx.cosh = ctx._wrap_libmp_function(libmp.mpf_cosh, libmp.mpc_cosh)
|
||||
ctx.tanh = ctx._wrap_libmp_function(libmp.mpf_tanh, libmp.mpc_tanh)
|
||||
ctx.asin = ctx._wrap_libmp_function(libmp.mpf_asin, libmp.mpc_asin)
|
||||
ctx.acos = ctx._wrap_libmp_function(libmp.mpf_acos, libmp.mpc_acos)
|
||||
ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
|
||||
ctx.asinh = ctx._wrap_libmp_function(libmp.mpf_asinh, libmp.mpc_asinh)
|
||||
ctx.acosh = ctx._wrap_libmp_function(libmp.mpf_acosh, libmp.mpc_acosh)
|
||||
ctx.atanh = ctx._wrap_libmp_function(libmp.mpf_atanh, libmp.mpc_atanh)
|
||||
ctx.sinpi = ctx._wrap_libmp_function(libmp.mpf_sin_pi, libmp.mpc_sin_pi)
|
||||
ctx.cospi = ctx._wrap_libmp_function(libmp.mpf_cos_pi, libmp.mpc_cos_pi)
|
||||
ctx.floor = ctx._wrap_libmp_function(libmp.mpf_floor, libmp.mpc_floor)
|
||||
ctx.ceil = ctx._wrap_libmp_function(libmp.mpf_ceil, libmp.mpc_ceil)
|
||||
ctx.nint = ctx._wrap_libmp_function(libmp.mpf_nint, libmp.mpc_nint)
|
||||
ctx.frac = ctx._wrap_libmp_function(libmp.mpf_frac, libmp.mpc_frac)
|
||||
ctx.fib = ctx.fibonacci = ctx._wrap_libmp_function(libmp.mpf_fibonacci, libmp.mpc_fibonacci)
|
||||
ctx.expj = ctx._wrap_libmp_function(libmp.libmpc.mpf_expj, libmp.libmpc.mpc_expj)
|
||||
ctx.expjpi = ctx._wrap_libmp_function(libmp.libmpc.mpf_expjpi, libmp.libmpc.mpc_expjpi)
|
||||
ctx.sin = ctx._wrap_libmp_function(libmp.mpf_sin, libmp.libmpc.mpc_sin)
|
||||
ctx.cos = ctx._wrap_libmp_function(libmp.mpf_cos, libmp.libmpc.mpc_cos)
|
||||
ctx.tan = ctx._wrap_libmp_function(libmp.mpf_tan, libmp.libmpc.mpc_tan)
|
||||
ctx.sinh = ctx._wrap_libmp_function(libmp.libelefun.mpf_sinh, libmp.libmpc.mpc_sinh)
|
||||
ctx.cosh = ctx._wrap_libmp_function(libmp.libelefun.mpf_cosh, libmp.libmpc.mpc_cosh)
|
||||
ctx.tanh = ctx._wrap_libmp_function(libmp.libelefun.mpf_tanh, libmp.libmpc.mpc_tanh)
|
||||
ctx.asin = ctx._wrap_libmp_function(libmp.libelefun.mpf_asin, libmp.libmpc.mpc_asin)
|
||||
ctx.acos = ctx._wrap_libmp_function(libmp.libelefun.mpf_acos, libmp.libmpc.mpc_acos)
|
||||
ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.libmpc.mpc_atan)
|
||||
ctx.asinh = ctx._wrap_libmp_function(libmp.libelefun.mpf_asinh, libmp.libmpc.mpc_asinh)
|
||||
ctx.acosh = ctx._wrap_libmp_function(libmp.libelefun.mpf_acosh, libmp.libmpc.mpc_acosh)
|
||||
ctx.atanh = ctx._wrap_libmp_function(libmp.libelefun.mpf_atanh, libmp.libmpc.mpc_atanh)
|
||||
ctx.sinpi = ctx._wrap_libmp_function(libmp.libelefun.mpf_sin_pi, libmp.libmpc.mpc_sin_pi)
|
||||
ctx.cospi = ctx._wrap_libmp_function(libmp.libelefun.mpf_cos_pi, libmp.libmpc.mpc_cos_pi)
|
||||
ctx.floor = ctx._wrap_libmp_function(libmp.mpf_floor, libmp.libmpc.mpc_floor)
|
||||
ctx.ceil = ctx._wrap_libmp_function(libmp.mpf_ceil, libmp.libmpc.mpc_ceil)
|
||||
ctx.nint = ctx._wrap_libmp_function(libmp.libmpf.mpf_nint, libmp.libmpc.mpc_nint)
|
||||
ctx.frac = ctx._wrap_libmp_function(libmp.libmpf.mpf_frac, libmp.libmpc.mpc_frac)
|
||||
ctx.fib = ctx.fibonacci = ctx._wrap_libmp_function(libmp.libelefun.mpf_fibonacci, libmp.libmpc.mpc_fibonacci)
|
||||
|
||||
ctx.gamma = ctx._wrap_libmp_function(libmp.mpf_gamma, libmp.mpc_gamma)
|
||||
ctx.rgamma = ctx._wrap_libmp_function(libmp.mpf_rgamma, libmp.mpc_rgamma)
|
||||
ctx.loggamma = ctx._wrap_libmp_function(libmp.mpf_loggamma, libmp.mpc_loggamma)
|
||||
ctx.fac = ctx.factorial = ctx._wrap_libmp_function(libmp.mpf_factorial, libmp.mpc_factorial)
|
||||
ctx.gamma = ctx._wrap_libmp_function(libmp.gammazeta.mpf_gamma, libmp.gammazeta.mpc_gamma)
|
||||
ctx.rgamma = ctx._wrap_libmp_function(libmp.gammazeta.mpf_rgamma, libmp.gammazeta.mpc_rgamma)
|
||||
ctx.loggamma = ctx._wrap_libmp_function(libmp.gammazeta.mpf_loggamma, libmp.gammazeta.mpc_loggamma)
|
||||
ctx.fac = ctx.factorial = ctx._wrap_libmp_function(libmp.gammazeta.mpf_factorial, libmp.gammazeta.mpc_factorial)
|
||||
|
||||
ctx.digamma = ctx._wrap_libmp_function(libmp.mpf_psi0, libmp.mpc_psi0)
|
||||
ctx.harmonic = ctx._wrap_libmp_function(libmp.mpf_harmonic, libmp.mpc_harmonic)
|
||||
ctx.ei = ctx._wrap_libmp_function(libmp.mpf_ei, libmp.mpc_ei)
|
||||
ctx.e1 = ctx._wrap_libmp_function(libmp.mpf_e1, libmp.mpc_e1)
|
||||
ctx._ci = ctx._wrap_libmp_function(libmp.mpf_ci, libmp.mpc_ci)
|
||||
ctx._si = ctx._wrap_libmp_function(libmp.mpf_si, libmp.mpc_si)
|
||||
ctx.ellipk = ctx._wrap_libmp_function(libmp.mpf_ellipk, libmp.mpc_ellipk)
|
||||
ctx._ellipe = ctx._wrap_libmp_function(libmp.mpf_ellipe, libmp.mpc_ellipe)
|
||||
ctx.agm1 = ctx._wrap_libmp_function(libmp.mpf_agm1, libmp.mpc_agm1)
|
||||
ctx._erf = ctx._wrap_libmp_function(libmp.mpf_erf, None)
|
||||
ctx._erfc = ctx._wrap_libmp_function(libmp.mpf_erfc, None)
|
||||
ctx._zeta = ctx._wrap_libmp_function(libmp.mpf_zeta, libmp.mpc_zeta)
|
||||
ctx._altzeta = ctx._wrap_libmp_function(libmp.mpf_altzeta, libmp.mpc_altzeta)
|
||||
ctx.digamma = ctx._wrap_libmp_function(libmp.gammazeta.mpf_psi0, libmp.gammazeta.mpc_psi0)
|
||||
ctx.harmonic = ctx._wrap_libmp_function(libmp.gammazeta.mpf_harmonic, libmp.gammazeta.mpc_harmonic)
|
||||
ctx.ei = ctx._wrap_libmp_function(libmp.libhyper.mpf_ei, libmp.libhyper.mpc_ei)
|
||||
ctx.e1 = ctx._wrap_libmp_function(libmp.libhyper.mpf_e1, libmp.libhyper.mpc_e1)
|
||||
ctx._ci = ctx._wrap_libmp_function(libmp.libhyper.mpf_ci, libmp.libhyper.mpc_ci)
|
||||
ctx._si = ctx._wrap_libmp_function(libmp.libhyper.mpf_si, libmp.libhyper.mpc_si)
|
||||
ctx.ellipk = ctx._wrap_libmp_function(libmp.libhyper.mpf_ellipk, libmp.libhyper.mpc_ellipk)
|
||||
ctx._ellipe = ctx._wrap_libmp_function(libmp.libhyper.mpf_ellipe, libmp.libhyper.mpc_ellipe)
|
||||
ctx.agm1 = ctx._wrap_libmp_function(libmp.libhyper.mpf_agm1, libmp.libhyper.mpc_agm1)
|
||||
ctx._erf = ctx._wrap_libmp_function(libmp.libhyper.mpf_erf, None)
|
||||
ctx._erfc = ctx._wrap_libmp_function(libmp.libhyper.mpf_erfc, None)
|
||||
ctx._zeta = ctx._wrap_libmp_function(libmp.gammazeta.mpf_zeta, libmp.gammazeta.mpc_zeta)
|
||||
ctx._altzeta = ctx._wrap_libmp_function(libmp.gammazeta.mpf_altzeta, libmp.gammazeta.mpc_altzeta)
|
||||
|
||||
def to_fixed(ctx, x, prec):
|
||||
return x.to_fixed(prec)
|
||||
@@ -153,7 +158,7 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real."""
|
||||
x = ctx.convert(x)
|
||||
y = ctx.convert(y)
|
||||
return ctx.make_mpf(libmp.mpf_hypot(x._mpf_, y._mpf_, *ctx._prec_rounding))
|
||||
return ctx.make_mpf(libmp.libmpf.mpf_hypot(x._mpf_, y._mpf_, *ctx._prec_rounding))
|
||||
|
||||
def _gamma_upper_int(ctx, n, z):
|
||||
n = int(ctx._re(n))
|
||||
@@ -162,7 +167,7 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
if not hasattr(z, '_mpf_'):
|
||||
raise NotImplementedError
|
||||
prec, rounding = ctx._prec_rounding
|
||||
real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding, gamma=True)
|
||||
real, imag = libmp.libhyper.mpf_expint(n, z._mpf_, prec, rounding, gamma=True)
|
||||
if imag is None:
|
||||
return ctx.make_mpf(real)
|
||||
else:
|
||||
@@ -175,7 +180,7 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
if not hasattr(z, '_mpf_'):
|
||||
raise NotImplementedError
|
||||
prec, rounding = ctx._prec_rounding
|
||||
real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding)
|
||||
real, imag = libmp.libhyper.mpf_expint(n, z._mpf_, prec, rounding)
|
||||
if imag is None:
|
||||
return ctx.make_mpf(real)
|
||||
else:
|
||||
@@ -184,27 +189,27 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
def _nthroot(ctx, x, n):
|
||||
if hasattr(x, '_mpf_'):
|
||||
try:
|
||||
return ctx.make_mpf(libmp.mpf_nthroot(x._mpf_, n, *ctx._prec_rounding))
|
||||
return ctx.make_mpf(libmp.libelefun.mpf_nthroot(x._mpf_, n, *ctx._prec_rounding))
|
||||
except ComplexResult:
|
||||
if ctx.trap_complex:
|
||||
raise
|
||||
x = (x._mpf_, libmp.fzero)
|
||||
else:
|
||||
x = x._mpc_
|
||||
return ctx.make_mpc(libmp.mpc_nthroot(x, n, *ctx._prec_rounding))
|
||||
return ctx.make_mpc(libmp.libmpc.mpc_nthroot(x, n, *ctx._prec_rounding))
|
||||
|
||||
def _besselj(ctx, n, z):
|
||||
prec, rounding = ctx._prec_rounding
|
||||
if hasattr(z, '_mpf_'):
|
||||
return ctx.make_mpf(libmp.mpf_besseljn(n, z._mpf_, prec, rounding))
|
||||
return ctx.make_mpf(libmp.libhyper.mpf_besseljn(n, z._mpf_, prec, rounding))
|
||||
elif hasattr(z, '_mpc_'):
|
||||
return ctx.make_mpc(libmp.mpc_besseljn(n, z._mpc_, prec, rounding))
|
||||
return ctx.make_mpc(libmp.libhyper.mpc_besseljn(n, z._mpc_, prec, rounding))
|
||||
|
||||
def _agm(ctx, a, b=1):
|
||||
prec, rounding = ctx._prec_rounding
|
||||
if hasattr(a, '_mpf_') and hasattr(b, '_mpf_'):
|
||||
try:
|
||||
v = libmp.mpf_agm(a._mpf_, b._mpf_, prec, rounding)
|
||||
v = libmp.libhyper.mpf_agm(a._mpf_, b._mpf_, prec, rounding)
|
||||
return ctx.make_mpf(v)
|
||||
except ComplexResult:
|
||||
pass
|
||||
@@ -212,13 +217,13 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
else: a = a._mpc_
|
||||
if hasattr(b, '_mpf_'): b = (b._mpf_, libmp.fzero)
|
||||
else: b = b._mpc_
|
||||
return ctx.make_mpc(libmp.mpc_agm(a, b, prec, rounding))
|
||||
return ctx.make_mpc(libmp.libhyper.mpc_agm(a, b, prec, rounding))
|
||||
|
||||
def bernoulli(ctx, n, plus=False):
|
||||
return ctx.make_mpf(libmp.mpf_bernoulli(int(n), *ctx._prec_rounding, plus=plus))
|
||||
|
||||
def _zeta_int(ctx, n):
|
||||
return ctx.make_mpf(libmp.mpf_zeta_int(int(n), *ctx._prec_rounding))
|
||||
return ctx.make_mpf(libmp.gammazeta.mpf_zeta_int(int(n), *ctx._prec_rounding))
|
||||
|
||||
def atan2(ctx, y, x):
|
||||
x = ctx.convert(x)
|
||||
@@ -229,19 +234,19 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
z = ctx.convert(z)
|
||||
m = int(m)
|
||||
if ctx._is_real_type(z):
|
||||
return ctx.make_mpf(libmp.mpf_psi(m, z._mpf_, *ctx._prec_rounding))
|
||||
return ctx.make_mpf(libmp.gammazeta.mpf_psi(m, z._mpf_, *ctx._prec_rounding))
|
||||
else:
|
||||
return ctx.make_mpc(libmp.mpc_psi(m, z._mpc_, *ctx._prec_rounding))
|
||||
return ctx.make_mpc(libmp.gammazeta.mpc_psi(m, z._mpc_, *ctx._prec_rounding))
|
||||
|
||||
def cos_sin(ctx, x, **kwargs):
|
||||
if type(x) not in ctx.types:
|
||||
x = ctx.convert(x)
|
||||
prec, rounding = ctx._parse_prec(kwargs)
|
||||
if hasattr(x, '_mpf_'):
|
||||
c, s = libmp.mpf_cos_sin(x._mpf_, prec, rounding)
|
||||
c, s = libmp.libelefun.mpf_cos_sin(x._mpf_, prec, rounding)
|
||||
return ctx.make_mpf(c), ctx.make_mpf(s)
|
||||
elif hasattr(x, '_mpc_'):
|
||||
c, s = libmp.mpc_cos_sin(x._mpc_, prec, rounding)
|
||||
c, s = libmp.libmpc.mpc_cos_sin(x._mpc_, prec, rounding)
|
||||
return ctx.make_mpc(c), ctx.make_mpc(s)
|
||||
else:
|
||||
return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
|
||||
@@ -251,10 +256,10 @@ class MPContext(BaseMPContext, StandardBaseContext):
|
||||
x = ctx.convert(x)
|
||||
prec, rounding = ctx._parse_prec(kwargs)
|
||||
if hasattr(x, '_mpf_'):
|
||||
c, s = libmp.mpf_cos_sin_pi(x._mpf_, prec, rounding)
|
||||
c, s = libmp.libelefun.mpf_cos_sin_pi(x._mpf_, prec, rounding)
|
||||
return ctx.make_mpf(c), ctx.make_mpf(s)
|
||||
elif hasattr(x, '_mpc_'):
|
||||
c, s = libmp.mpc_cos_sin_pi(x._mpc_, prec, rounding)
|
||||
c, s = libmp.libmpc.mpc_cos_sin_pi(x._mpc_, prec, rounding)
|
||||
return ctx.make_mpc(c), ctx.make_mpc(s)
|
||||
else:
|
||||
return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
|
||||
@@ -676,7 +681,7 @@ maxterms, or set zeroprec."""
|
||||
t /= (k+1)
|
||||
return t
|
||||
if key not in ctx.hyp_summators:
|
||||
ctx.hyp_summators[key] = libmp.make_hyp_summator(key)[1]
|
||||
ctx.hyp_summators[key] = libmp.libhyper.make_hyp_summator(key)[1]
|
||||
summator = ctx.hyp_summators[key]
|
||||
prec = ctx.prec
|
||||
maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(prec))
|
||||
@@ -773,7 +778,7 @@ maxterms, or set zeroprec."""
|
||||
|
||||
"""
|
||||
x = ctx.convert(x)
|
||||
y, n = libmp.mpf_frexp(x._mpf_)
|
||||
y, n = libmp.libmpf.mpf_frexp(x._mpf_)
|
||||
return ctx.make_mpf(y), n
|
||||
|
||||
def fneg(ctx, x, **kwargs):
|
||||
@@ -1279,9 +1284,9 @@ maxterms, or set zeroprec."""
|
||||
s = ctx.convert(s)
|
||||
prec, rounding = ctx._prec_rounding
|
||||
if hasattr(s, '_mpf_'):
|
||||
v = ctx.make_mpf(libmp.mpf_zetasum(s._mpf_, a, b, prec))
|
||||
v = ctx.make_mpf(libmp.gammazeta.mpf_zetasum(s._mpf_, a, b, prec))
|
||||
elif hasattr(s, '_mpc_'):
|
||||
v = ctx.make_mpc(libmp.mpc_zetasum(s._mpc_, a, b, prec))
|
||||
v = ctx.make_mpc(libmp.gammazeta.mpc_zetasum(s._mpc_, a, b, prec))
|
||||
return v
|
||||
'''
|
||||
|
||||
@@ -1290,7 +1295,7 @@ maxterms, or set zeroprec."""
|
||||
raise NotImplementedError
|
||||
a = int(a)
|
||||
prec = ctx._prec
|
||||
xs, ys = libmp.mpc_zetasum(s._mpc_, a, n, derivatives, reflect, prec)
|
||||
xs, ys = libmp.gammazeta.mpc_zetasum(s._mpc_, a, n, derivatives, reflect, prec)
|
||||
xs = [ctx.make_mpc(x) for x in xs]
|
||||
ys = [ctx.make_mpc(y) for y in ys]
|
||||
return xs, ys
|
||||
|
||||
+14
-12
@@ -3,19 +3,21 @@ import numbers
|
||||
import sys
|
||||
|
||||
from . import function_docs
|
||||
from .libmp import (MPQ, MPZ, ComplexResult, dps_to_prec, finf, fnan, fninf,
|
||||
format_mpc, format_mpf, from_Decimal, from_float, from_int,
|
||||
from_man_exp, from_npfloat, from_rational, from_str, fzero,
|
||||
int_types, mpc_abs, mpc_add, mpc_add_mpf, mpc_conjugate,
|
||||
mpc_div, mpc_div_mpf, mpc_hash, mpc_is_inf, mpc_is_nonzero,
|
||||
from .libmp import (MPZ, ComplexResult, dps_to_prec, finf, fnan, fninf,
|
||||
from_float, from_int, from_man_exp, from_rational,
|
||||
from_str, fzero, int_types, mpc_abs, mpc_pow, mpc_pow_int,
|
||||
mpc_pow_mpf, mpf_abs, mpf_add, mpf_div, mpf_eq, mpf_ge,
|
||||
mpf_gt, mpf_le, mpf_lt, mpf_mod, mpf_mul, mpf_neg, mpf_pow,
|
||||
mpf_sub, prec_to_dps, round_nearest, to_float, to_int,
|
||||
to_man_exp, to_rational, to_str)
|
||||
from .libmp.backend import MPQ
|
||||
from .libmp.libmpc import (mpc_add, mpc_add_mpf, mpc_conjugate, mpc_div,
|
||||
mpc_div_mpf, mpc_hash, mpc_is_inf, mpc_is_nonzero,
|
||||
mpc_mpf_div, mpc_mpf_sub, mpc_mul, mpc_mul_int,
|
||||
mpc_mul_mpf, mpc_neg, mpc_pos, mpc_pow, mpc_pow_int,
|
||||
mpc_pow_mpf, mpc_sub, mpc_sub_mpf, mpc_to_complex,
|
||||
mpc_to_str, mpf_abs, mpf_add, mpf_div, mpf_eq, mpf_ge,
|
||||
mpf_gt, mpf_hash, mpf_le, mpf_lt, mpf_mod, mpf_mul,
|
||||
mpf_neg, mpf_pos, mpf_pow, mpf_sub, mpf_sum, prec_to_dps,
|
||||
round_nearest, to_fixed, to_float, to_int, to_man_exp,
|
||||
to_rational, to_str)
|
||||
mpc_mul_mpf, mpc_neg, mpc_pos, mpc_sub, mpc_sub_mpf,
|
||||
mpc_to_complex, mpc_to_str)
|
||||
from .libmp.libmpf import (format_mpc, format_mpf, from_Decimal, from_npfloat,
|
||||
mpf_hash, mpf_pos, mpf_sum, to_fixed)
|
||||
|
||||
|
||||
new = object.__new__
|
||||
|
||||
@@ -3,7 +3,8 @@ Implements the PSLQ algorithm for integer relation detection,
|
||||
and derivative algorithms for constant recognition.
|
||||
"""
|
||||
|
||||
from .libmp import int_types, sqrt_fixed
|
||||
from .libmp import int_types
|
||||
from .libmp.libintmath import sqrt_fixed
|
||||
|
||||
|
||||
# round to nearest integer (can be done more elegantly...)
|
||||
|
||||
+16
-65
@@ -1,67 +1,18 @@
|
||||
from .backend import (BACKEND, MPQ, MPZ, MPZ_FIVE, MPZ_ONE, MPZ_THREE, MPZ_TWO,
|
||||
MPZ_ZERO, gmpy, int_types)
|
||||
from .gammazeta import (apery_fixed, bernfrac, catalan_fixed, euler_fixed,
|
||||
glaisher_fixed, khinchin_fixed, mertens_fixed,
|
||||
mpc_altzeta, mpc_factorial, mpc_gamma, mpc_harmonic,
|
||||
mpc_loggamma, mpc_psi, mpc_psi0, mpc_rgamma, mpc_zeta,
|
||||
mpc_zetasum, mpf_altzeta, mpf_apery, mpf_bernoulli,
|
||||
mpf_catalan, mpf_euler, mpf_factorial, mpf_gamma,
|
||||
mpf_gamma_int, mpf_glaisher, mpf_harmonic,
|
||||
mpf_khinchin, mpf_loggamma, mpf_mertens, mpf_psi,
|
||||
mpf_psi0, mpf_rgamma, mpf_twinprime, mpf_zeta,
|
||||
mpf_zeta_int, mpf_zetasum, twinprime_fixed)
|
||||
from .libelefun import (agm_fixed, degree_fixed, e_fixed, ln2_fixed,
|
||||
ln10_fixed, log_int_fixed, mpf_acos, mpf_acosh,
|
||||
mpf_asin, mpf_asinh, mpf_atan, mpf_atan2, mpf_atanh,
|
||||
mpf_cbrt, mpf_cos, mpf_cos_pi, mpf_cos_sin,
|
||||
mpf_cos_sin_pi, mpf_cosh, mpf_cosh_sinh, mpf_degree,
|
||||
mpf_e, mpf_exp, mpf_fibonacci, mpf_ln, mpf_ln2,
|
||||
mpf_ln10, mpf_log, mpf_log_hypot, mpf_nthroot, mpf_phi,
|
||||
mpf_pi, mpf_pow, mpf_sin, mpf_sin_pi, mpf_sinh,
|
||||
mpf_tan, mpf_tanh, phi_fixed, pi_fixed)
|
||||
from .libhyper import (NoConvergence, make_hyp_summator, mpc_agm, mpc_agm1,
|
||||
mpc_besseljn, mpc_ci, mpc_e1, mpc_ei, mpc_ellipe,
|
||||
mpc_ellipk, mpc_si, mpf_agm, mpf_agm1, mpf_besseljn,
|
||||
mpf_ci, mpf_ci_si, mpf_e1, mpf_ei, mpf_ellipe,
|
||||
mpf_ellipk, mpf_erf, mpf_erfc, mpf_expint, mpf_si)
|
||||
from .libintmath import (bin_to_radix, eulernum, gcd, giant_steps, ifac, ifib,
|
||||
isprime, isqrt, isqrt_fast, isqrt_small, list_primes,
|
||||
moebius, numeral, sqrt_fixed, sqrtrem, stirling1,
|
||||
stirling2)
|
||||
from .libmpc import (complex_int_pow, mpc_abs, mpc_acos, mpc_acosh, mpc_add,
|
||||
mpc_add_mpf, mpc_arg, mpc_asin, mpc_asinh, mpc_atan,
|
||||
mpc_atanh, mpc_cbrt, mpc_ceil, mpc_conjugate, mpc_cos,
|
||||
mpc_cos_pi, mpc_cos_sin, mpc_cos_sin_pi, mpc_cosh,
|
||||
mpc_div, mpc_div_mpf, mpc_exp, mpc_expj, mpc_expjpi,
|
||||
mpc_fibonacci, mpc_floor, mpc_frac, mpc_half, mpc_hash,
|
||||
mpc_is_inf, mpc_is_infnan, mpc_is_nonzero, mpc_ln,
|
||||
mpc_log, mpc_mpf_div, mpc_mpf_sub, mpc_mul, mpc_mul_int,
|
||||
mpc_mul_mpf, mpc_neg, mpc_nint, mpc_nthroot, mpc_one,
|
||||
mpc_pos, mpc_pow, mpc_pow_int, mpc_pow_mpf,
|
||||
mpc_reciprocal, mpc_shift, mpc_sin, mpc_sin_pi, mpc_sinh,
|
||||
mpc_sqrt, mpc_square, mpc_sub, mpc_sub_mpf, mpc_tan,
|
||||
mpc_tanh, mpc_to_complex, mpc_to_str, mpc_two, mpc_zero,
|
||||
mpf_expj, mpf_expjpi)
|
||||
from .backend import BACKEND, MPZ, MPZ_ONE, int_types
|
||||
from .gammazeta import catalan_fixed, euler_fixed, mpf_bernoulli
|
||||
from .libelefun import (mpf_atan, mpf_atan2, mpf_cos, mpf_cosh_sinh, mpf_e,
|
||||
mpf_exp, mpf_log, mpf_pi, mpf_pow, mpf_sin, mpf_tan,
|
||||
phi_fixed)
|
||||
from .libhyper import NoConvergence
|
||||
from .libintmath import giant_steps, ifac, ifib, isqrt, sqrtrem
|
||||
from .libmpc import (mpc_abs, mpc_exp, mpc_pow, mpc_pow_int, mpc_pow_mpf,
|
||||
mpc_sqrt)
|
||||
from .libmpf import (ComplexResult, dps_to_prec, fhalf, finf, fnan, fninf,
|
||||
fnone, fone, format_mpc, format_mpf, from_Decimal,
|
||||
from_float, from_int, from_man_exp, from_npfloat,
|
||||
from_rational, from_str, ften, ftwo, fzero, mpf_abs,
|
||||
mpf_add, mpf_ceil, mpf_cmp, mpf_div, mpf_eq, mpf_floor,
|
||||
mpf_frac, mpf_frexp, mpf_ge, mpf_gt, mpf_hash, mpf_hypot,
|
||||
mpf_le, mpf_lt, mpf_mod, mpf_mul, mpf_mul_int, mpf_neg,
|
||||
mpf_nint, mpf_perturb, mpf_pos, mpf_pow_int, mpf_rand,
|
||||
mpf_rdiv_int, mpf_shift, mpf_sign, mpf_sqrt, mpf_sub,
|
||||
mpf_sum, normalize, prec_to_dps, repr_dps, round_ceiling,
|
||||
round_down, round_floor, round_int, round_nearest,
|
||||
round_up, str_to_man_exp, to_digits_exp, to_fixed,
|
||||
fnone, fone, from_float, from_int, from_man_exp,
|
||||
from_rational, from_str, fzero, mpf_abs, mpf_add,
|
||||
mpf_ceil, mpf_cmp, mpf_div, mpf_eq, mpf_floor, mpf_ge,
|
||||
mpf_gt, mpf_le, mpf_lt, mpf_mod, mpf_mul, mpf_neg,
|
||||
mpf_pow_int, mpf_shift, mpf_sign, mpf_sqrt, mpf_sub,
|
||||
normalize, prec_to_dps, repr_dps, round_ceiling,
|
||||
round_down, round_floor, round_nearest, round_up,
|
||||
to_float, to_int, to_man_exp, to_rational, to_str)
|
||||
from .libmpi import (mpci_abs, mpci_add, mpci_cos, mpci_div, mpci_exp,
|
||||
mpci_factorial, mpci_gamma, mpci_log, mpci_loggamma,
|
||||
mpci_mul, mpci_neg, mpci_pos, mpci_pow, mpci_rgamma,
|
||||
mpci_sin, mpci_sub, mpi_abs, mpi_add, mpi_atan, mpi_atan2,
|
||||
mpi_cos, mpi_cos_sin, mpi_cot, mpi_delta, mpi_div, mpi_eq,
|
||||
mpi_exp, mpi_factorial, mpi_from_str, mpi_gamma, mpi_ge,
|
||||
mpi_gt, mpi_le, mpi_log, mpi_loggamma, mpi_lt, mpi_mid,
|
||||
mpi_mul, mpi_ne, mpi_neg, mpi_pos, mpi_pow, mpi_pow_int,
|
||||
mpi_rgamma, mpi_sin, mpi_sqrt, mpi_str, mpi_sub, mpi_tan,
|
||||
mpi_to_str)
|
||||
|
||||
@@ -14,10 +14,12 @@ import mpmath
|
||||
from mpmath import (ceil, fadd, fdiv, floor, fmul, fneg, fp, frac, fsub, inf,
|
||||
isinf, isint, isnan, isnormal, iv, monitor, mp, mpc, mpf,
|
||||
mpi, nan, ninf, nint, nint_distance, nstr, pi, workprec)
|
||||
from mpmath.libmp import (MPQ, MPZ, finf, fnan, fninf, fnone, fone, from_float,
|
||||
from_int, from_str, isprime, mpf_add, mpf_mul,
|
||||
mpf_sub, round_down, round_nearest, round_up,
|
||||
to_float, to_int, to_man_exp)
|
||||
from mpmath.libmp import (MPZ, finf, fnan, fninf, fnone, fone, from_float,
|
||||
from_int, from_str, mpf_add, mpf_mul, mpf_sub,
|
||||
round_down, round_nearest, round_up, to_float,
|
||||
to_int, to_man_exp)
|
||||
from mpmath.libmp.backend import MPQ
|
||||
from mpmath.libmp.libintmath import isprime
|
||||
|
||||
|
||||
def test_type_compare():
|
||||
|
||||
@@ -4,10 +4,10 @@ Test bit-level integer and mpf operations
|
||||
|
||||
from mpmath import eps, fadd, ldexp, mp, mpc, mpf
|
||||
from mpmath.libmp import (MPZ, fone, from_float, from_man_exp, fzero, mpf_add,
|
||||
mpf_neg, mpf_perturb, mpf_sub, round_ceiling,
|
||||
round_down, round_floor, round_nearest, round_up,
|
||||
to_float)
|
||||
mpf_neg, mpf_sub, round_ceiling, round_down,
|
||||
round_floor, round_nearest, round_up, to_float)
|
||||
from mpmath.libmp.libintmath import trailing
|
||||
from mpmath.libmp.libmpf import mpf_perturb
|
||||
|
||||
|
||||
def test_trailing():
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
from random import choice, randint, seed
|
||||
|
||||
from mpmath import mpf
|
||||
from mpmath.libmp import (from_int, from_str, mpf_div, mpf_mul, mpf_rdiv_int,
|
||||
round_ceiling, round_down, round_floor,
|
||||
round_nearest, round_up)
|
||||
from mpmath.libmp import (from_int, from_str, mpf_div, mpf_mul, round_ceiling,
|
||||
round_down, round_floor, round_nearest, round_up)
|
||||
from mpmath.libmp.libintmath import trailing
|
||||
from mpmath.libmp.libmpf import mpf_rdiv_int
|
||||
|
||||
|
||||
def test_div_1_3():
|
||||
|
||||
@@ -16,8 +16,9 @@ from mpmath import (acos, acosh, acot, acoth, acsc, acsch, arange, arg, asec,
|
||||
sec, sech, sign, sin, sinc, sincpi, sinh, sinpi, sqrt, tan,
|
||||
tanh, twinprime, unitroots)
|
||||
from mpmath.libmp import (MPZ, ComplexResult, from_int, mpf_gt, mpf_lt,
|
||||
mpf_mul, mpf_pow_int, mpf_rand, mpf_sqrt,
|
||||
round_ceiling, round_down, round_nearest, round_up)
|
||||
mpf_mul, mpf_pow_int, mpf_sqrt, round_ceiling,
|
||||
round_down, round_nearest, round_up)
|
||||
from mpmath.libmp.libmpf import mpf_rand
|
||||
|
||||
|
||||
def mpc_ae(a, b, eps=eps):
|
||||
|
||||
@@ -7,7 +7,8 @@ from mpmath import (altzeta, apery, barnesg, bell, bernfrac, bernoulli,
|
||||
j, log, loggamma, mp, mpc, mpf, mpmathify, nan, pi,
|
||||
polyexp, polylog, primezeta, psi, rf, rgamma, sech,
|
||||
secondzeta, siegelz, sinc, sqrt, stieltjes, superfac, zeta)
|
||||
from mpmath.libmp import from_float, mpf_zeta_int, round_up
|
||||
from mpmath.libmp import from_float, round_up
|
||||
from mpmath.libmp.gammazeta import mpf_zeta_int
|
||||
|
||||
|
||||
def test_zeta_int_bug():
|
||||
|
||||
Reference in New Issue
Block a user