Example #1
0
def field_isomorphism_pslq(a, b):
    """Construct field isomorphism using PSLQ algorithm."""
    if not all(_.domain.is_RationalField and _.ext.is_real for _ in (a, b)):
        raise NotImplementedError("PSLQ doesn't support complex coefficients")

    f = a.minpoly
    g = b.minpoly.replace(f.gen)
    m = b.minpoly.degree()

    for n in mpmath.libmp.libintmath.giant_steps(32, 256):  # pragma: no branch
        with mpmath.workdps(n):
            A = lambdify((), a.ext, "mpmath")()
            B = lambdify((), b.ext, "mpmath")()
            basis = [B**i for i in range(m)] + [A]
            coeffs = mpmath.pslq(basis, maxcoeff=int(1e10), maxsteps=1000)

        if coeffs is None:
            break

        coeffs = [QQ(c, coeffs[-1]) for c in coeffs[:-1]]
        while not coeffs[-1]:
            coeffs.pop()
        coeffs.reverse()

        h = Poly(coeffs, f.gen, domain='QQ')

        if f.compose(h).rem(g).is_zero or f.compose(-h).rem(g).is_zero:
            return [-c for c in coeffs]
def test_d():
    # Compare the d_{k, n} to the results in appendix F of [1].
    #
    # Sources
    # -------
    # [1] DiDonato and Morris, Computation of the Incomplete Gamma
    #     Function Ratios and their Inverse, ACM Transactions on
    #     Mathematical Software, 1986.

    with mp.workdps(50):
        dataset = [(0, 0, -mp.mpf('0.333333333333333333333333333333')),
                   (0, 12, mp.mpf('0.102618097842403080425739573227e-7')),
                   (1, 0, -mp.mpf('0.185185185185185185185185185185e-2')),
                   (1, 12, mp.mpf('0.119516285997781473243076536700e-7')),
                   (2, 0, mp.mpf('0.413359788359788359788359788360e-2')),
                   (2, 12, -mp.mpf('0.140925299108675210532930244154e-7')),
                   (3, 0, mp.mpf('0.649434156378600823045267489712e-3')),
                   (3, 12, -mp.mpf('0.191111684859736540606728140873e-7')),
                   (4, 0, -mp.mpf('0.861888290916711698604702719929e-3')),
                   (4, 12, mp.mpf('0.288658297427087836297341274604e-7')),
                   (5, 0, -mp.mpf('0.336798553366358150308767592718e-3')),
                   (5, 12, mp.mpf('0.482409670378941807563762631739e-7')),
                   (6, 0, mp.mpf('0.531307936463992223165748542978e-3')),
                   (6, 12, -mp.mpf('0.882860074633048352505085243179e-7')),
                   (7, 0, mp.mpf('0.344367606892377671254279625109e-3')),
                   (7, 12, -mp.mpf('0.175629733590604619378669693914e-6')),
                   (8, 0, -mp.mpf('0.652623918595309418922034919727e-3')),
                   (8, 12, mp.mpf('0.377358774161109793380344937299e-6')),
                   (9, 0, -mp.mpf('0.596761290192746250124390067179e-3')),
                   (9, 12, mp.mpf('0.870823417786464116761231237189e-6'))]
        d = compute_d(10, 13)
        res = [d[k][n] for k, n, std in dataset]
        std = map(lambda x: x[2], dataset)
        mp_assert_allclose(res, std)
def test_gth_solve_high_prec():
    n = 1e-100
    with mp.workdps(100):
        P = mp.matrix([[-3*(mp.exp(n)-1), 3*(mp.exp(n)-1)],
                       [mp.exp(n)-1     , -(mp.exp(n)-1) ]])

    run_gth_solve(P, verbose=VERBOSE)
def test_stoch_eig_high_prec():
    n = 1e-100
    with mp.workdps(100):
        P = mp.matrix([[1-3*(mp.exp(n)-1), 3*(mp.exp(n)-1)],
                       [mp.exp(n)-1      , 1-(mp.exp(n)-1)]])

    run_stoch_eig(P, verbose=VERBOSE)
def test_g():
    # Test data for the g_k. See DLMF 5.11.4.
    with mp.workdps(30):
        g = [mp.mpf(1), mp.mpf(1)/12, mp.mpf(1)/288,
             -mp.mpf(139)/51840, -mp.mpf(571)/2488320,
             mp.mpf(163879)/209018880, mp.mpf(5246819)/75246796800]
        mp_assert_allclose(compute_g(7), g)
Example #6
0
def _noncentral_chi_cdf(x, df, nc, dps=None):
    if dps is None:
        dps = mpmath.mp.dps
    x, df, nc = mpmath.mpf(x), mpmath.mpf(df), mpmath.mpf(nc)
    with mpmath.workdps(dps):
        res = mpmath.quad(lambda t: _noncentral_chi_pdf(t, df, nc), [0, x])
        return res
def test_alpha():
    # Test data for the alpha_k. See DLMF 8.12.14.
    with mp.workdps(30):
        alpha = [mp.mpf(0), mp.mpf(1), mp.mpf(1)/3, mp.mpf(1)/36,
                 -mp.mpf(1)/270, mp.mpf(1)/4320, mp.mpf(1)/17010,
                 -mp.mpf(139)/5443200, mp.mpf(1)/204120]
        mp_assert_allclose(compute_alpha(9), alpha)
Example #8
0
	def runTest(self):
		import math
		from .math import cos as pcos, sin as psin
		from .types import polynomial, kronecker_monomial, double, real
		self.assertEqual(math.cos(3),pcos(3))
		self.assertEqual(math.cos(3.1234),pcos(3.1234))
		self.assertEqual(math.sin(3),psin(3))
		self.assertEqual(math.sin(3.1234),psin(3.1234))
		pt = polynomial(double,kronecker_monomial())()
		self.assertEqual(math.cos(3),pcos(pt(3)))
		self.assertEqual(math.cos(-2.456),pcos(pt(2.456)))
		self.assertEqual(math.sin(3),psin(pt(3)))
		self.assertEqual(math.sin(-2.456),-psin(pt(2.456)))
		self.assertRaises(TypeError,lambda : pcos(""))
		self.assertRaises(TypeError,lambda : psin(""))
		try:
			from mpmath import mpf, workdps
			from mpmath import cos as mpcos, sin as mpsin
			pt = polynomial(real,kronecker_monomial())()
			self.assertEqual(mpcos(mpf("1.2345")),pcos(mpf("1.2345")))
			self.assertEqual(mpcos(mpf("3")),pcos(pt(mpf("3"))))
			self.assertEqual(mpcos(mpf("-2.456")),pcos(pt(mpf("-2.456"))))
			self.assertEqual(mpsin(mpf("1.2345")),psin(mpf("1.2345")))
			self.assertEqual(mpsin(mpf("3")),psin(pt(mpf("3"))))
			self.assertEqual(mpsin(mpf("-2.456")),psin(pt(mpf("-2.456"))))
			with workdps(500):
				self.assertEqual(mpcos(mpf("1.2345")),pcos(mpf("1.2345")))
				self.assertEqual(mpcos(mpf("3")),pcos(pt(mpf("3"))))
				self.assertEqual(mpcos(mpf("-2.456")),pcos(pt(mpf("-2.456"))))
				self.assertEqual(mpsin(mpf("1.2345")),psin(mpf("1.2345")))
				self.assertEqual(mpsin(mpf("3")),psin(pt(mpf("3"))))
				self.assertEqual(mpsin(mpf("-2.456")),psin(pt(mpf("-2.456"))))
		except ImportError:
			pass
Example #9
0
def taylor_series_at_1(N):
    coeffs = []
    with mpmath.workdps(100):
        coeffs.append(-mpmath.euler)
        for n in range(2, N + 1):
            coeffs.append((-1)**n*mpmath.zeta(n)/n)
    return coeffs
Example #10
0
def gammaincc(a, x, dps=50, maxterms=10**8):
    """Compute gammaincc exactly like mpmath does but allow for more
    terms in hypercomb. See

    mpmath/functions/expintegrals.py#L187

    in the mpmath github repository.

    """
    with mp.workdps(dps):
        z, a = a, x
        
        if mp.isint(z):
            try:
                # mpmath has a fast integer path
                return mpf2float(mp.gammainc(z, a=a, regularized=True))
            except mp.libmp.NoConvergence:
                pass
        nega = mp.fneg(a, exact=True)
        G = [z]
        # Use 2F0 series when possible; fall back to lower gamma representation
        try:
            def h(z):
                r = z-1
                return [([mp.exp(nega), a], [1, r], [], G, [1, -r], [], 1/nega)]
            return mpf2float(mp.hypercomb(h, [z], force_series=True))
        except mp.libmp.NoConvergence:
            def h(z):
                T1 = [], [1, z-1], [z], G, [], [], 0
                T2 = [-mp.exp(nega), a, z], [1, z, -1], [], G, [1], [1+z], a
                return T1, T2
            return mpf2float(mp.hypercomb(h, [z], maxterms=maxterms))
Example #11
0
def zetac_series(N):
    coeffs = []
    with mpmath.workdps(100):
        coeffs.append(-1.5)
        for n in range(1, N):
            coeff = mpmath.diff(mpmath.zeta, 0, n)/mpmath.factorial(n)
            coeffs.append(coeff)
    return coeffs
def logReg_ObjectiveFunction(X,Y,W,u,s,coef_transfer,b):
    w=np.array([W[1:]]).T
    w_0=W[0]
    A=np.dot(X,w)+float(w_0)
    B=-np.multiply(Y,A)
    with mp.workdps(30):
        NLL=sum(log_one_plus_exp(B))+coef_transfer*0.5*GPriorWeightRegTerm(W,u,s)#+(1/float(np.shape(Y)[0]))*np.dot(b.T,np.array([W]).T)[0,0]
    return NLL
Example #13
0
def test_logpdf():
    with mpmath.workdps(50):
        x = mpmath.mpf('1.5')
        p = benktander1.logpdf(x, 2, 3)
        # Expected value computed with Wolfram Alpha:
        #    log(PDF[BenktanderGibratDistribution[2, 3], 3/2])
        valstr = '0.086726919062697113736142804022160705324241157062981346304'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #14
0
def _student_t_cdf(df, t, dps=None):
    if dps is None:
        dps = mpmath.mp.dps
    with mpmath.workdps(dps):
        df, t = mpmath.mpf(df), mpmath.mpf(t)
        fac = mpmath.hyp2f1(0.5, 0.5*(df + 1), 1.5, -t**2/df)
        fac *= t*mpmath.gamma(0.5*(df + 1))
        fac /= mpmath.sqrt(mpmath.pi*df)*mpmath.gamma(0.5*df)
        return 0.5 + fac
Example #15
0
def _student_t_cdf(df, t, dps=None):
    if dps is None:
        dps = mpmath.mp.dps
    with mpmath.workdps(dps):
        df, t = mpmath.mpf(df), mpmath.mpf(t)
        fac = mpmath.hyp2f1(0.5, 0.5 * (df + 1), 1.5, -t**2 / df)
        fac *= t * mpmath.gamma(0.5 * (df + 1))
        fac /= mpmath.sqrt(mpmath.pi * df) * mpmath.gamma(0.5 * df)
        return 0.5 + fac
Example #16
0
def test_specific_values_from_wolfram():
    # The function is MarcumQ[m, a, b] in Wolfram.
    with mpmath.workdps(50):
        values = [
            [(1, 1, 2),
             mpmath.mpf(
                 '0.269012060035909996678516959220271087421337500744873384155')
             ],
            [(4, 2, 2),
             mpmath.mpf(
                 '0.961002639616864002974959310625974743642314730388958932865')
             ],
            [(10, 2, 7),
             mpmath.mpf(
                 '0.003419880268711142942584170929968429599523954396941827739')
             ],
            [(10, 2, 20),
             mpmath.mpf(
                 '1.1463968305097683198312254572377449552982286967700350e-63')
             ],
            [(25, 3, 1),
             mpmath.mpf(
                 '0.999999999999999999999999999999999985610186498600062604510')
             ],
            [(100, 5, 25),
             mpmath.mpf(
                 '6.3182094741234192918553754494227940871375208133861094e-36')
             ],
        ]
        for (m, a, b), expected in values:
            q = marcumq(m, a, b)
            assert mpmath.almosteq(q, expected)

        values = [
            [(0.5, 1, 2),
             mpmath.mpf(
                 '0.839994848036912854058580730864442945100083598568223741623')
             ],
            [(0.5, 5, 13),
             mpmath.mpf(
                 '0.99999999999999937790394257282158764840048274118115775113')
             ],
            [(0.5, 5, mpmath.mpf('1/13')),
             mpmath.mpf(
                 '2.3417168332795098320214996797055274037932802604709459e-7')],
            [(0.75, 5, mpmath.mpf('0.001')),
             mpmath.mpf(
                 '7.6243509472783061143887290663443105556790864676878435e-11')
             ],
            [(51 / 2, 5, mpmath.mpf('0.1')),
             mpmath.mpf(
                 '9.9527768099307883918427141035705197017192239618506806e-91')]
        ]
        for (m, a, b), expected in values:
            c = cmarcumq(m, a, b)
            assert mpmath.almosteq(c, expected)
Example #17
0
def test_skewness():
    with mpmath.workdps(50):
        k = mpmath.mpf(2)
        theta = mpmath.mpf(7)
        skew = loggamma.skewness(k, theta)
        # Expected value computed with Wolfram Alpha:
        #     Skewness[ExpGammaDistribution[2, 7, 0]]
        valstr = '-0.780244491437787061530103769675602605070996940757461555988'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(skew, expected)
Example #18
0
def decompose(x, gamma_pow, precision=40):
    with mp.workdps(2048):
        tail = x
        compressed = np.zeros(precision + 1)
        for i in xrange(precision + 1):
            if tail == 0:
                break
            tail, compressed[i] = mp.frac(tail), mp.floor(tail)
            tail = mp.ldexp(tail, gamma_pow)
        return compressed
Example #19
0
def test_mean():
    with mpmath.workdps(50):
        k = mpmath.mpf(2)
        theta = mpmath.mpf(7)
        mean = loggamma.mean(k, theta)
        # Expected value computed with Wolfram Alpha:
        #     Mean[ExpGammaDistribution[2, 7, 0]]
        valstr = '2.9594903456892699757544153694231829827048846484205348083596'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(mean, expected)
Example #20
0
 def idmap(self, *args):
     if self.spfunc_first:
         res = self.spfunc(*args)
         if np.isnan(res):
             return np.nan
         args = list(args)
         args[self.index] = res
         with mpmath.workdps(self.dps):
             res = self.mpfunc(*tuple(args))
             # Imaginary parts are spurious
             res = mpf2float(res.real)
     else:
         with mpmath.workdps(self.dps):
             res = self.mpfunc(*args)
             res = mpf2float(res.real)
         args = list(args)
         args[self.index] = res
         res = self.spfunc(*tuple(args))
     return res
Example #21
0
def cauchy_eigen(mu, dps):
    mu = np.atleast_1d(mu)
    n = len(mu)
    with mp.workdps(dps):
        mu = mp.matrix(mu)
        M = mp.zeros(n, n)
        for i, j in product(range(n), range(n)):
            M[i, j] = (mu[i] + mu[j].conjugate())**(-1)
        ewL, QL = mp.eighe(M)
        return ewL, QL
Example #22
0
def test_var():
    with mpmath.workdps(50):
        a = 2
        b = 3
        m = benktander1.var(a, b)
        # Expected value computed with Wolfram Alpha:
        #    Var[BenktanderGibratDistribution[2, 3]]
        valstr = '0.129886916731278610514259475545032373691162070980680465530'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(m, expected)
Example #23
0
def u_binom(N):
  out = np.zeros((len(x),len(t)))
  out = out + 0.5*W(0)[...,None]*np.ones(len(t))
  with mpmath.workdps(workdps):
    for n in range(1,N):
      coeff = np.zeros(len(x))    
      for m in range(n):     
        coeff = coeff + (-1)**((n-1)-m)*mpmath.binomial(n-1,m)*W(m+1)
      out = out + coeff[...,None]*((t/(2*tau))**n)/mpmath.factorial(n)       
  return out
Example #24
0
 def idmap(self, *args):
     if self.spfunc_first:
         res = self.spfunc(*args)
         if np.isnan(res):
             return np.nan
         args = list(args)
         args[self.index] = res
         with mpmath.workdps(self.dps):
             res = self.mpfunc(*tuple(args))
             # Imaginary parts are spurious
             res = mpf2float(res.real)
     else:
         with mpmath.workdps(self.dps):
             res = self.mpfunc(*args)
             res = mpf2float(res.real)
         args = list(args)
         args[self.index] = res
         res = self.spfunc(*tuple(args))
     return res
Example #25
0
def test_kurtosis():
    with mpmath.workdps(50):
        k = mpmath.mpf(2)
        theta = mpmath.mpf(7)
        kurt = loggamma.kurtosis(k, theta)
        # Expected value computed with Wolfram Alpha:
        #     ExcessKurtosis[ExpGammaDistribution[2, 7, 0]]
        valstr = '1.1875257511965620472368652875718220772212082979314426565409'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(kurt, expected)
Example #26
0
def test_var():
    with mpmath.workdps(50):
        k = mpmath.mpf(2)
        theta = mpmath.mpf(7)
        var = loggamma.var(k, theta)
        # Expected value computed with Wolfram Alpha:
        #     Variance[ExpGammaDistribution[2, 7, 0]]
        valstr = '31.601769275563095387148343165655234271728545159133123449042'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(var, expected)
Example #27
0
def test_bounds_for_Q1():
    """
    These bounds are from:

        Jiangping Wang and Dapeng Wu,
        "Tight bounds for the first order Marcum Q-function"
        Wireless Communications and Mobile Computing,
        Volume 12, Issue 4, March 2012, Pages 293-301.

    """
    with mpmath.workdps(50):
        sqrt2 = mpmath.sqrt(2)
        sqrthalfpi = mpmath.sqrt(mpmath.pi / 2)
        for b in [mpmath.mp.mpf(1), mpmath.mp.mpf(10)]:
            for a in [b / 16, 0.5 * b, 0.875 * b, b]:
                q1 = marcumq(1, a, b)

                sinhab = mpmath.sinh(a * b)
                i0ab = mpmath.besseli(0, a * b)

                # lower bound when 0 <= a <= b
                lb = (mpmath.sqrt(mpmath.pi / 8) * b * i0ab / sinhab *
                      (mpmath.erfc((b - a) / sqrt2) - mpmath.erfc(
                          (b + a) / sqrt2)))
                assert lb < q1

                # upper bound when 0 <= a <= b
                ub = ((i0ab + 3) / (mpmath.exp(a * b) + 3) * (
                    mpmath.exp(-(b - a)**2 / 2) + a * sqrthalfpi * mpmath.erfc(
                        (b - a) / sqrt2) + 3 * mpmath.exp(-(a**2 + b**2) / 2)))
                assert q1 < ub, ("marcumq(1, a, b) < ub for a = %s,  b = %s" %
                                 (a, b))

        for a in [mpmath.mp.mpf(1), mpmath.mp.mpf(10)]:
            for b in [b / 16, 0.5 * b, 0.875 * b, b]:
                q1 = marcumq(1, a, b)

                sinhab = mpmath.sinh(a * b)
                i0ab = mpmath.besseli(0, a * b)

                # lower bound when 0 <= b <= a
                lb = (1 - sqrthalfpi * b * i0ab / sinhab *
                      (mpmath.erf(a / sqrt2) - mpmath.erf(
                          (a - b) / sqrt2) / 2 - mpmath.erf(
                              (a + b) / sqrt2) / 2))
                assert lb < q1

                # upper bound when 0 <= b <= a
                ub = (
                    1 - i0ab / (mpmath.exp(a * b) + 3) *
                    (4 * mpmath.exp(-a**2 / 2) - mpmath.exp(-(b - a)**2 / 2) -
                     3 * mpmath.exp(-(a**2 + b**2) / 2) + a * sqrthalfpi *
                     (mpmath.erfc(-a / sqrt2) - mpmath.erfc((b - a) / sqrt2))))
                assert q1 < ub, ("marcumq(1, a, b) < ub for a = %s,  b = %s" %
                                 (a, b))
Example #28
0
def test_sf():
    with mpmath.workdps(50):
        x = mpmath.mpf(1.0)
        loc = mpmath.mp.zero
        scale = mpmath.mpf(3.0)
        p = gumbel_min.sf(x, loc, scale)
        # Expected value computed with Wolfram Alpha:
        #     1 - CDF[GumbelDistribution[0, 3], 1]
        valstr = '0.24768130366579455342390646303215371545090605136653835'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #29
0
def test_cdf():
    with mpmath.workdps(50):
        x = mpmath.mpf(1.0)
        loc = mpmath.mp.zero
        scale = mpmath.mpf(3.0)
        p = gumbel_min.cdf(x, loc, scale)
        # Expected value computed with Wolfram Alpha:
        #     CDF[GumbelDistribution[0, 3], 1]
        valstr = '0.75231869633420544657609353696784628454909394863346165'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #30
0
def test_pdf():
    with mpmath.workdps(50):
        x = mpmath.mpf(1.0)
        loc = mpmath.mp.zero
        scale = mpmath.mpf('0.1')
        p = gumbel_min.pdf(x, loc, scale)
        # Expected value was computed with Wolfram Alpha:
        #     PDF[GumbelDistribution[0, 1/10], 1]
        valstr = '2.3463581492019736117406984253693582114273335082428261e-9561'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #31
0
def logReg_ObjectiveFunction(X, Y, W, u, s, coef_transfer, b):
    w = np.array([W[1:]]).T
    w_0 = W[0]
    A = np.dot(X, w) + float(w_0)
    B = -np.multiply(Y, A)
    with mp.workdps(30):
        NLL = sum(
            log_one_plus_exp(B)) + coef_transfer * 0.5 * GPriorWeightRegTerm(
                W, u, s
            )  #+(1/float(np.shape(Y)[0]))*np.dot(b.T,np.array([W]).T)[0,0]
    return NLL
Example #32
0
def test_skewness(dist, sign):
    with mpmath.workdps(50):
        k = 1.25
        loc = 1
        scale = 3
        skew = dist.skewness(k, loc, scale)
        # Expected value computed with Wolfram Alpha:
        #   Skewness[WeibullDistribution[5/4, 3, 1]]
        valstr = '1.429545236590974853525527387620583784997166374292021040338'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(skew, sign * expected)
Example #33
0
def test_kurtosis(dist):
    with mpmath.workdps(50):
        k = 1.25
        loc = 1
        scale = 3
        kurt = dist.kurtosis(k, loc, scale)
        # Expected value computed with Wolfram Alpha:
        #   ExcessKurtosis[WeibullDistribution[5/4, 3, 1]]
        valstr = '2.8021519350984650074697694858304410798423229238041266467027'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(kurt, expected)
def test_g():
    # Test data for the g_k. See DLMF 5.11.4.
    with mp.workdps(30):
        g = [
            mp.mpf(1),
            mp.mpf(1) / 12,
            mp.mpf(1) / 288, -mp.mpf(139) / 51840, -mp.mpf(571) / 2488320,
            mp.mpf(163879) / 209018880,
            mp.mpf(5246819) / 75246796800
        ]
        mp_assert_allclose(compute_g(7), g)
Example #35
0
def test_sf_invsf():
    with mpmath.workdps(50):
        x = mpmath.mpf('1.5')
        p = benktander1.sf(x, 2, 3)
        # Expected value computed with Wolfram Alpha:
        #    SurvivalFunction[BenktanderGibratDistribution[2, 3], 3/2]
        valstr = '0.40103000157608789634710325190011195010750064239976147223'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
        x1 = benktander1.invsf(expected, 2, 3)
        assert mpmath.almosteq(x1, x)
Example #36
0
def test_logpdf():
    with mpmath.workdps(50):
        x = mpmath.mpf('1.5')
        a = 2
        b = mpmath.mpf('0.75')
        p = benktander2.logpdf(x, a, b)
        # Expected value computed with Wolfram Alpha:
        #    log(PDF[BenktanderWeibullDistribution[2, 3/4], 3/2])
        valstr = '-0.369111200683201817345059066451331575064497370791420217397'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #37
0
def test_pdf():
    with mpmath.workdps(50):
        x = mpmath.mpf('1.5')
        a = 2
        b = mpmath.mpf('0.75')
        p = benktander2.pdf(x, a, b)
        # Expected value computed with Wolfram Alpha:
        #    PDF[BenktanderWeibullDistribution[2, 3/4], 3/2]
        valstr = '0.6913485277470671248347955016586714957100372820095067311673'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
Example #38
0
def test_cdf_invcdf():
    with mpmath.workdps(50):
        x = mpmath.mpf('1.5')
        p = benktander1.cdf(x, 2, 3)
        # Expected value computed with Wolfram Alpha:
        #    CDF[BenktanderGibratDistribution[2, 3], 3/2]
        valstr = '0.59896999842391210365289674809988804989249935760023852777'
        expected = mpmath.mpf(valstr)
        assert mpmath.almosteq(p, expected)
        x1 = benktander1.invcdf(expected, 2, 3)
        assert mpmath.almosteq(x1, x)
Example #39
0
    def check_support(x, shape, loc, scale, dx='1e-10', precision=100):
        """
        Verify that passed parameters are valid.
        Returns np.nan in place of invalid inputs (if array, replaces invalid values with np.nan's).
        """

        with mpmath.workdps(precision):
            if not np.isscalar(x):
                x = np.array(x)

            # Parameters constraint
            if scale <= 0:
                raise ValueError('Scale parameter must be larger than 0')

            # Support constraint
            if np.isscalar(x):
                # Shape > 0
                if mpmath.mpf(shape) > mpmath.mpf(dx):
                    condition = x >= loc - scale / shape
                # Shape < 0
                elif mpmath.mpf(shape) < -mpmath.mpf(dx):
                    condition = x <= loc - scale / shape
                # Shape == 0
                else:
                    condition = True
            else:
                # Shape > 0
                if mpmath.mpf(shape) > mpmath.mpf(dx):
                    condition = np.all(x >= loc - scale / shape)
                # Shape < 0
                elif mpmath.mpf(shape) < -mpmath.mpf(dx):
                    condition = np.all(x <= loc - scale / shape)
                # Shape == 0
                else:
                    condition = True

            # Test conditions - replace invalid x's with np.nan
            if condition:
                return x
            else:
                if np.isscalar(x):
                    return np.nan
                else:
                    truncated_x = x
                    # Shape > 0
                    if mpmath.mpf(shape) > mpmath.mpf(dx):
                        truncated_x[truncated_x < loc - scale / shape] = np.nan
                    # Shape < 0
                    elif mpmath.mpf(shape) < -mpmath.mpf(dx):
                        truncated_x[truncated_x > loc - scale / shape] = np.nan
                    # Shape == 0
                    else:
                        pass
                    return truncated_x
Example #40
0
 def __call__(self, x):
     with workdps(self.dps):
         indices, qs_mask = self.cube_dispatcher.index_search(x)
         q_forbidden = np.where(qs_mask == False)[0]
         sum_for_q = mpf('0.0')
         for i, q in indices:
             sum_for_q += self.exact_on_cube(i, q)
         for q in q_forbidden:
             idx, mlt = self.cube_dispatcher.forbidden_index_search(x, q)
             sum_for_q += self.average_between_cubes(idx, mlt, q)
         return self.f(x) - sum_for_q
Example #41
0
 def __call__(self, x):
     with workdps(self.dps):
         bits = strong_decompose(math.fabs(x), self.gamma, self.max_precision)
         ps = self.representation(bits)
         gammas = [mpf(self.gamma)]*bits.size
         """print '-'*80
         print np.sum([c * gamma **(-power) for (c, gamma, power) in zip(ps, gammas, self.betas[:bits.size])]), x
         print bits
         print ps
         print gammas"""
         return math.copysign(np.sum([c * gamma **(-power) for (c, gamma, power) in zip(ps, gammas, self.betas[:bits.size])]), x)
    def __init__(
        self,
        sym_constants,
        lhs_search_limit,
        saved_hash,
        an_generator: SeriesGeneratorClass = CartesianProductAnGenerator(),
        bn_generator: SeriesGeneratorClass = CartesianProductBnGenerator()):
        """
        initialize search engine.
        basically, this is a 3 step procedure:
        1) load / initialize lhs hash table.
        2) first enumeration - enumerate over all rhs combinations, find hits in lhs hash table.
        3) refine results - take results from (2) and validate them to 100 decimal digits.
        :param sym_constants: sympy constants
        :param lhs_search_limit: range of coefficients for left hand side.
        :param saved_hash: path to saved hash.
        :param an_generator: generating function for {an} series
        :param bn_generator: generating function for {bn} series
        """
        self.threshold = 1 * 10**(-g_N_initial_key_length)  # key length
        self.enum_dps = g_N_initial_search_dps  # working decimal precision for first enumeration
        self.verify_dps = g_N_verify_dps  # working decimal precision for validating results.
        self.lhs_limit = lhs_search_limit
        self.const_sym = sym_constants
        self.constants_generator = []
        for i in range(len(sym_constants)):
            try:
                self.constants_generator.append(
                    lambdify((), sym_constants[i], modules="mpmath"))
            except AttributeError:  # Hackish constant
                self.constants_generator.append(sym_constants[i].mpf_val)

        self.create_an_series = an_generator.get_function()
        self.get_an_length = an_generator.get_num_iterations
        self.get_an_iterator = an_generator.get_iterator
        self.create_bn_series = bn_generator.get_function()
        self.get_bn_length = bn_generator.get_num_iterations
        self.get_bn_iterator = bn_generator.get_iterator

        if not os.path.isfile(saved_hash):
            print('no previous hash table given, initializing hash table...')
            with mpmath.workdps(self.enum_dps):
                constants = [const() for const in self.constants_generator]
                start = time()
                self.hash_table = LHSHashTable(
                    saved_hash,
                    self.lhs_limit,
                    constants,  # constant
                    self.threshold)  # length of key
                end = time()
                print(f'that took {end - start}s')
        else:
            self.hash_table = LHSHashTable.load_from(saved_hash)
Example #43
0
def test_mean():
    mu = 2.0
    sigma = 3.0
    # Wolfram Alpha:
    #     Mean[LogNormalDistribution[2, 3]]
    # returns
    #     665.141633044361840693961494242634383221132254094828803184906532...
    s = '665.141633044361840693961494242634383221132254094828803184906532'
    with mpmath.workdps(len(s) - 1):
        expected = mpmath.mpf(s)
        mean = lognormal.mean(mu, sigma)
        assert mpmath.almosteq(mean, expected)
Example #44
0
def test_Q1_identities():
    with mpmath.workdps(50):
        for a in [mpmath.mp.mpf(1), mpmath.mp.mpf(13)]:
            q1 = marcumq(1, a, a)
            expected = 0.5 * (1 + mpmath.exp(-a**2) * mpmath.besseli(0, a**2))
            assert mpmath.almosteq(q1, expected)

        for a, b in [(1, 2), (10, 3.5)]:
            total = marcumq(1, a, b) + marcumq(1, b, a)
            expected = 1 + mpmath.exp(-(a**2 + b**2) / 2) * mpmath.besseli(
                0, a * b)
            assert mpmath.almosteq(total, expected)
Example #45
0
	def runTest(self):
		try:
			from mpmath import workdps, mpf, pi
		except ImportError:
			return
		from .types import polynomial, real, short
		pt = polynomial(real,short)()
		self.assertEqual(pt(mpf("4.5667")),mpf("4.5667"))
		self.assertEqual(pt(mpf("4.5667")) ** mpf("1.234567"),mpf("4.5667") ** mpf("1.234567"))
		for n in [11,21,51,101,501]:
			with workdps(n):
				self.assertEqual(pt(mpf("4.5667")),mpf("4.5667"))
				self.assertEqual(pt(mpf("4.5667")) ** mpf("1.234567"),mpf("4.5667") ** mpf("1.234567"))
				self.assertEqual(pt(mpf(pi)),mpf(pi))
Example #46
0
def main():
    print(__doc__)
    with mpmath.workdps(50):
        p, q = lambertw_pade()
        p, q = p[::-1], q[::-1]
        print("p = {}".format(p))
        print("q = {}".format(q))

    x, y = np.linspace(-1.5, 1.5, 75), np.linspace(-1.5, 1.5, 75)
    x, y = np.meshgrid(x, y)
    z = x + 1j*y
    lambertw_std = []
    for z0 in z.flatten():
        lambertw_std.append(complex(mpmath.lambertw(z0)))
    lambertw_std = np.array(lambertw_std).reshape(x.shape)

    fig, axes = plt.subplots(nrows=3, ncols=1)
    # Compare Pade approximation to true result
    p = np.array([float(p0) for p0 in p])
    q = np.array([float(q0) for q0 in q])
    pade_approx = np.polyval(p, z)/np.polyval(q, z)
    pade_err = abs(pade_approx - lambertw_std)
    axes[0].pcolormesh(x, y, pade_err)
    # Compare two terms of asymptotic series to true result
    asy_approx = np.log(z) - np.log(np.log(z))
    asy_err = abs(asy_approx - lambertw_std)
    axes[1].pcolormesh(x, y, asy_err)
    # Compare two terms of the series around the branch point to the
    # true result
    p = np.sqrt(2*(np.exp(1)*z + 1))
    series_approx = -1 + p - p**2/3
    series_err = abs(series_approx - lambertw_std)
    im = axes[2].pcolormesh(x, y, series_err)

    fig.colorbar(im, ax=axes.ravel().tolist())
    plt.show()

    fig, ax = plt.subplots(nrows=1, ncols=1)
    pade_better = pade_err < asy_err
    im = ax.pcolormesh(x, y, pade_better)
    t = np.linspace(-0.3, 0.3)
    ax.plot(-2.5*abs(t) - 0.2, t, 'r')
    fig.colorbar(im, ax=ax)
    plt.show()
def multinomial(n,m,multiplePrecision=False,decimalPlaces=40):
    '''
    n = int
    m = list of integers summing to n
    '''
    mybinom = binom
    if multiplePrecision: #use multiple-precision arithmetics
        with mp.workdps(decimalPlaces):
            if sum(m) != n:
                return mp.mpf('0.0')
            else:
                return np.prod([mp.mpf(mybinom(sum(m[i:]),m[i])) for i in xrange(len(m)-1)])
    else: #use floating-point arithmetics
        if sum(m) != n:
            return 0.0
        else:
    #        if len(m)==1: m = list(m)+[0] #else the reduce statement does not work
    #        return reduce(lambda x,y:x*y,[mybinom(sum(m[i:]),m[i]) for i in xrange(len(m)-1)])
            return np.prod([mybinom(sum(m[i:]),m[i]) for i in xrange(len(m)-1)])
Example #48
0
def main():
    print(__doc__)
    K = 25
    N = 25
    with mp.workdps(50):
        d = compute_d(K, N)
    fn = os.path.join(os.path.dirname(__file__), '..', 'cephes', 'igam.h')
    with open(fn + '.new', 'w') as f:
        f.write(header.format(K, N))
        for k, row in enumerate(d):
            row = map(lambda x: mp.nstr(x, 17, min_fixed=0, max_fixed=0), row)
            f.write('{')
            f.write(", ".join(row))
            if k < K - 1:
                f.write('},\n')
            else:
                f.write('}};\n')
        f.write(footer)
    os.rename(fn + '.new', fn)
Example #49
0
def main():
    print(__doc__)
    K = 25
    N = 25
    with mp.workdps(50):
        d = compute_d(K, N)
    fn = os.path.join(os.path.dirname(__file__), "..", "cephes", "igam.h")
    with open(fn + ".new", "w") as f:
        f.write(header.format(K, N))
        for k, row in enumerate(d):
            row = map(lambda x: mp.nstr(x, 17, min_fixed=0, max_fixed=0), row)
            f.write("{")
            f.write(", ".join(row))
            if k < K - 1:
                f.write("},\n")
            else:
                f.write("}};\n")
        f.write(footer)
    os.rename(fn + ".new", fn)
Example #50
0
	def runTest(self):
		import math
		from .math import cos as pcos, sin as psin
		from .types import polynomial, k_monomial, double, real
		# NOTE: according to
		# https://docs.python.org/3/library/math.html
		# the CPython math functions are wrappers around the corresponding
		# C functions. The results should thus be the same.
		self.assertEqual(math.cos(3.),pcos(3.))
		self.assertEqual(math.cos(3.1234),pcos(3.1234))
		self.assertEqual(math.sin(3.),psin(3.))
		self.assertEqual(math.sin(3.1234),psin(3.1234))
		pt = polynomial(double,k_monomial)()
		self.assertEqual(math.cos(3),pcos(pt(3)))
		self.assertEqual(math.cos(2.456),pcos(pt(2.456)))
		self.assertEqual(math.sin(3),psin(pt(3)))
		self.assertEqual(math.sin(-2.456),psin(pt(-2.456)))
		self.assertRaises(TypeError,lambda : pcos(""))
		self.assertRaises(TypeError,lambda : psin(""))
		try:
			from mpmath import mpf, workdps
			from mpmath import cos as mpcos, sin as mpsin
			pt = polynomial(real,k_monomial)()
			self.assertEqual(mpcos(mpf("1.2345")),pcos(mpf("1.2345")))
			self.assertEqual(mpcos(mpf("3")),pcos(pt(mpf("3"))))
			self.assertEqual(mpcos(mpf("-2.456")),pcos(pt(mpf("-2.456"))))
			self.assertEqual(mpsin(mpf("1.2345")),psin(mpf("1.2345")))
			self.assertEqual(mpsin(mpf("3")),psin(pt(mpf("3"))))
			self.assertEqual(mpsin(mpf("-2.456")),psin(pt(mpf("-2.456"))))
			with workdps(500):
				self.assertEqual(mpcos(mpf("1.2345")),pcos(mpf("1.2345")))
				self.assertEqual(mpcos(mpf("3")),pcos(pt(mpf("3"))))
				self.assertEqual(mpcos(mpf("-2.456")),pcos(pt(mpf("-2.456"))))
				self.assertEqual(mpsin(mpf("1.2345")),psin(mpf("1.2345")))
				self.assertEqual(mpsin(mpf("3")),psin(pt(mpf("3"))))
				self.assertEqual(mpsin(mpf("-2.456")),psin(pt(mpf("-2.456"))))
		except ImportError:
			pass
		self.binomialTest()
		self.sincosTest()
		self.evaluateTest()
		self.subsTest()
		self.invertTest()
Example #51
0
def gammainc(a, x, dps=50, maxterms=10**8):
    """Compute gammainc exactly like mpmath does but allow for more
    summands in hypercomb. See

    mpmath/functions/expintegrals.py#L134
    
    in the mpmath github repository.

    """
    with mp.workdps(dps):
        z, a, b = mp.mpf(a), mp.mpf(x), mp.mpf(x)
        G = [z]
        negb = mp.fneg(b, exact=True)

        def h(z):
            T1 = [mp.exp(negb), b, z], [1, z, -1], [], G, [1], [1+z], b
            return (T1,)

        res = mp.hypercomb(h, [z], maxterms=maxterms)
        return mpf2float(res)
def mc_compute_stationary_mpmath(P, precision=17, irreducible=False, ltol=0, utol=None):
    """
    Computes the stationary distributions of Markov matrix P.

    Parameters
    ----------
    P : array_like(float, ndim=2)
        A discrete Markov transition matrix.

    precision : scalar(int), optional(default: 17)
        Decimal precision in float-point arithemetic with mpmath.
        mpmath.mp.dps is set to *precision*.

    irreducible : bool, optional(default: False)
        Set True if P is known a priori to be irreducible
        (for any i, j, (P^k)_{ij} > 0 for some k).
        If True, the eigenvector for the maximum eigenvalue is returned.

    ltol, utol: scalar(float), optional(default: ltol=0, utol=None)
        Lower and upper tolerance levels.
        Find eigenvectors for eigenvalues in [1-ltol, 1+utol]
        (where [1-ltol, 1+utol] = [1-ltol, +inf) when utol=None).

    Returns
    -------
    vecs : list of numpy.arrays of mpmath.ctx_mp_python.mpf
        A list of the eigenvectors of whose eigenvalues in [1-ltol, 1+utol].

    Notes
    -----
    mpmath 0.18 or above is required.

    References
    ----------

        http://mpmath.org/doc/current

    """
    LTOL = ltol  # Lower tolerance level
    if utol is None:  # Upper tolerance level
        UTOL = 'inf'
    else:
        UTOL = utol

    with mp.workdps(precision):  # Temporarily change the working precision
        E, EL = mp.eig(mp.matrix(P), left=True, right=False)
        # E  : a list of length n containing the eigenvalues of A
        # EL : a matrix whose rows contain the left eigenvectors of A
        # See: github.com/fredrik-johansson/mpmath/blob/master/mpmath/matrices/eigen.py
        E, EL = mp.eig_sort(E, EL)  # Sorted in a descending order

        if irreducible:
            num_eigval_one = 1
        else:
            num_eigval_one = sum(
                mp.mpf(1) - mp.mpf(LTOL) <= val <= mp.mpf(1) + mp.mpf(UTOL)
                for val in E
                )

        vecs = [np.array((EL[i, :]/sum(EL[i, :])).tolist()[0])
                for i in range(EL.rows-num_eigval_one, EL.rows)]

    return vecs


a =mpm.mpf (9.999999999)
b= mpm.mpf (0.0000000001)

print (a, b)

c=a+b
print (c)




deltam=1
with mpm.workdps(mpm.mp.dps+deltam):
    c=a+b
    print (c)

print (c)










#
Example #54
0
	def runTest(self):
		import sys
		from .types import polynomial, short, integer, rational, real, monomial
		from fractions import Fraction as F
		# Context for the temporary monkey-patching of type t to return bogus
		# string bad_str for representation via str.
		class patch_str(object):
			def __init__(self,t,bad_str):
				self.t = t
				self.bad_str = bad_str
			def __enter__(self):
				self.old_str = self.t.__str__
				self.t.__str__ = lambda s: self.bad_str
			def __exit__(self, type, value, traceback):
				self.t.__str__ = self.old_str
		# Same for repr.
		class patch_repr(object):
			def __init__(self,t,bad_repr):
				self.t = t
				self.bad_repr = bad_repr
			def __enter__(self):
				self.old_repr = self.t.__repr__
				self.t.__repr__ = lambda s: self.bad_repr
			def __exit__(self, type, value, traceback):
				self.t.__repr__ = self.old_repr
		# Start with plain integers.
		pt = polynomial(integer,monomial(short))()
		# Use small integers to make it work both on Python 2 and Python 3.
		self.assertEqual(int,type(pt(4).list[0][0]))
		self.assertEqual(pt(4).list[0][0],4)
		self.assertEqual(int,type(pt("x").evaluate({"x":5})))
		self.assertEqual(pt("x").evaluate({"x":5}),5)
		# Specific for Python 2.
		if sys.version_info[0] == 2:
			self.assertEqual(int,type(pt(sys.maxint).list[0][0]))
			self.assertEqual(pt(sys.maxint).list[0][0],sys.maxint)
			self.assertEqual(long,type((pt(sys.maxint) + 1).list[0][0]))
			self.assertEqual((pt(sys.maxint) + 1).list[0][0],sys.maxint+1)
			self.assertEqual(int,type(pt("x").evaluate({"x":sys.maxint})))
			self.assertEqual(pt("x").evaluate({"x":sys.maxint}),sys.maxint)
			self.assertEqual(long,type(pt("x").evaluate({"x":sys.maxint + 1})))
			self.assertEqual(pt("x").evaluate({"x":sys.maxint + 1}),sys.maxint + 1)
		# Now rationals.
		pt = polynomial(rational,monomial(short))()
		self.assertEqual(F,type((pt(4)/3).list[0][0]))
		self.assertEqual((pt(4)/3).list[0][0],F(4,3))
		self.assertEqual(F,type(pt("x").evaluate({"x":F(5,6)})))
		self.assertEqual(pt("x").evaluate({"x":F(5,6)}),F(5,6))
		# NOTE: if we don't go any more through str for the conversion, these types
		# of tests can go away.
		with patch_str(F,"boo"):
			self.assertRaises(ValueError,lambda: pt(F(5,6)))
		with patch_str(F,"5/0"):
			self.assertRaises(ZeroDivisionError,lambda: pt(F(5,6)))
		# Reals, if possible.
		try:
			from mpmath import mpf, mp, workdps, binomial as bin, fabs
		except ImportError:
			return
		pt = polynomial(real,monomial(short))()
		self.assertEqual(mpf,type(pt(4).list[0][0]))
		self.assertEqual(pt(4).list[0][0],mpf(4))
		self.assertEqual(mpf,type(pt("x").evaluate({"x":mpf(5)})))
		self.assertEqual(pt("x").evaluate({"x":mpf(5)}),mpf(5))
		# Test various types of bad repr.
		with patch_repr(mpf,"foo"):
			self.assertRaises(RuntimeError,lambda: pt(mpf(5)))
		with patch_repr(mpf,"'1.23445"):
			self.assertRaises(RuntimeError,lambda: pt(mpf(5)))
		with patch_repr(mpf,"'foobar'"):
			self.assertRaises(ValueError,lambda: pt(mpf(5)))
		# Check the handling of the precision.
		from .math import binomial
		# Original number of decimal digits.
		orig_dps = mp.dps
		tmp = binomial(mpf(5.1),mpf(3.2))
		self.assertEqual(tmp.context.dps,orig_dps)
		with workdps(100):
			# Check that the precision is maintained on output
			# and that the values computed with our implementation and
			# mpmath are close.
			tmp = binomial(mpf(5.1),mpf(3.2))
			self.assertEqual(tmp.context.dps,100)
			self.assert_(fabs(tmp - bin(mpf(5.1),mpf(3.2))) < mpf('5e-100'))
		# This will create a coefficient with dps equal to the current value.
		tmp = 3*pt('x')
		self.assertEqual(tmp.evaluate({'x':mpf(1)}).context.dps,orig_dps)
		self.assertEqual(tmp.list[0][0].context.dps,orig_dps)
		with workdps(100):
			# When we extract the coefficient with increased temporary precision, we get
			# an object with increased precision.
			self.assertEqual(tmp.list[0][0].context.dps,100)
 def test_sin(self):
     with mp.workdps(30):
         sincoeffs = mp.taylor(mp.sin, 0, 10)
         asincoeffs = mp.taylor(mp.asin, 0, 10)
         invsincoeffs = lagrange_inversion(sincoeffs)
         mp_assert_allclose(invsincoeffs, asincoeffs, atol=1e-30)
 def test_log(self):
     with mp.workdps(30):
         logcoeffs = mp.taylor(lambda x: mp.log(1 + x), 0, 10)
         expcoeffs = mp.taylor(lambda x: mp.exp(x) - 1, 0, 10)
         invlogcoeffs = lagrange_inversion(logcoeffs)
         mp_assert_allclose(invlogcoeffs, expcoeffs)
Example #57
0
def stirling_series(N):
    with mpmath.workdps(100):
        coeffs = [mpmath.bernoulli(2*n)/(2*n*(2*n - 1))
                  for n in range(1, N + 1)]
    return coeffs
Example #58
0
def stirling_series(N):
    coeffs = []
    with mpmath.workdps(100):
        for n in range(1, N + 1):
            coeffs.append(mpmath.bernoulli(2 * n) / (2 * n * (2 * n - 1)))
    return coeffs
def extraction_Diode_In_mpmath():
    """
    пробуем экстрагировать коэффициенты из модели диода
    коэффициенты модели: Ток утечки Is, коэффициент неидеальности N, омическое сопротивление, параллельное диоду R
    входные параметры: напряжение, приложенное источником к системе резистор-диод
    +-----------|||||---------->|--------- -
    Резистор подключен до диода
    :return:
    """
    btrue=[mpm.mpf('1.238e-14'), mpm.mpf('1.3'), mpm.mpf('10')]
    c=None
    global FT
    funcf=solver_Diode_In_mpmath
    jacf = jac_Diode_In_mpmath
    #теперь попробуем сделать эксперимент.
    Ve=np.array([ [1e-7] ]  )
    bstart=[mpm.mpf('1.0e-14'), mpm.mpf('1.0'), mpm.mpf('9')]
    bend=[mpm.mpf('1.5e-14'), mpm.mpf('1.5'), mpm.mpf('14')]
    #binit=[mpm.mpf('1.1e-14'), mpm.mpf('1.1'), mpm.mpf('11')]

    binit=mpm.matrix([['1.1e-14', '1.1', '11.1']]).T

    xstart=[mpm.mpf('0.0001')]
    xend=[mpm.mpf('2')]

    N=100
    NAprior=20

    unifplan = o_pmpm.makeUniformExpPlan(xstart, xend, N)
    unifmeasdata = o_pmpm.makeMeasAccToPlan_lognorm(funcf, unifplan, btrue, c, Ve)
    #print (unifmeasdata[0]['y'][0])


    import Fianora.Fianora_static_functions as f_sf

    for dps in [20,10,7]:

        with f_sf.Profiler():
            print()
            print ('mantissa', dps)
            gknux = o_empm.grandCountGN_UltraX1_mpmath_mantissa(funcf, jacf, unifmeasdata, binit,c, NSIG=dps,implicit=True, verbose=False, mantissa=[dps])

            with mpm.workdps(dps):
                print ('b', gknux[0])

                print ('numiter', gknux[1])
                print ('log', gknux[2])
                print ('Sk', gknux[4])



    for f**k in range (10):
        with f_sf.Profiler():
            print()
            print ('mantissa', 'variable')
            gknux = o_empm.grandCountGN_UltraX1_mpmath_mantissa(funcf, jacf, unifmeasdata, binit,c, NSIG=7,implicit=True, verbose=False, mantissa=[4,5,6,7])
            with mpm.workdps(dps):
                print ('b', gknux[0])
                print ('numiter', gknux[1])
                print ('log', gknux[2])
                print ('Sk', gknux[4])
def grandCountGN_UltraX1_mpmath (funcf, jacf,  measdata:list, binit:list, c, NSIG=3, implicit=False, verbose=False):
    """
    Производит оценку коэффициентов по методу Гаусса-Ньютона с переменным шагом
    В стандартный поток вывода выводит отладочную информацию по каждой итерации
    :param funcf callable функция, параметры по формату x,b,c, на выходе вектор (pure Python)
    :param jacf callable функция, параметры по формату x,b,c,y, на выходе матрица mpmath.matrix
    :param measdata:list список словарей экспериментальных данных [{'x': [] 'y':[])},{'x': [] 'y':[])}]
    :param binit:list начальное приближение b
    :param c словарь дополнительных постоянных
    :param NSIG=3 точность (кол-во знаков после запятой)
    :param sign - если  1, то b=b+deltab*mu, иначе b=b-deltab*mu. При неявной функции надо ставить sign=0
    :returns b, numiter, log - вектор оценки коэффициентов, число итераций, сообщения
    РАБОЧАЯ GEPRUFT!
    """

    Sklist=list()
    b=binit
    log=""
    numiter=0
    condition=True

    def throwError (msg):
        #global b, numiter, log, Sklist, Sk
        log+=msg
        return b, numiter, log, Sklist, Sk

    while (condition):
        m=len(b) #число коэффициентов
        #G=np.zeros((m,m))
        G=mpm.matrix(m)
        #B5=mpm.matrix(1,m)
        B5=None
        bpriv=copy.copy(b)
        Sk=mpm.mpf(0)
        for point in measdata:
            jac=jacf(point['x'],b,c,point['y'])

            if jac is None:
                 throwError ("Jac is None")

            #G+=np.dot(jac.T,jac)
            G+=jac.T*jac
            #dif=np.array(point['y'])-np.array(funcf(point['x'],b,c))
            fxbc=funcf(point['x'],b,c)

            if fxbc is None:
                throwError ("Funcf is None")
            dif=point['y']-fxbc

            if B5 is None:
            #if B5==mpm.matrix(1,m):
                B5=dif*jac
            else:
                B5+=dif*jac
            Sk+=(dif.T*dif)[0]
        try:
            with mpm.workdps(30):
                deltab=(G**-1)*B5.T
        except BaseException as e:
            print('G=',G)
            print('B5=',B5)
            throwError('Error in G:'+e.__str__())

        #mu counting
        mu=mpm.mpf(4)
        cond2=True
        it=0
        while (cond2):
            Skmu=mpm.mpf(0)
            mu/=mpm.mpf(2)
            for point in measdata:
                dif=point['y']-funcf(point['x'],b-deltab*mu,c) if implicit else point['y']-funcf(point['x'],b+deltab*mu,c)
                Skmu+=(dif.T*dif)[0]
            it+=1
            if (it>100):
                log+="Mu counting: break due to max number of iteration exceed"
                break
            cond2=Skmu>Sk
        b=b-deltab*mu if implicit else b+deltab*mu
        Sklist.append(Sk)
        if verbose:
            print ("Sk:",Sk)
            print ("Iteration {0} mu={1} delta={2} deltamu={3} resb={4}".format(numiter, mu, deltab, deltab*mu, b))

        numiter+=1

        condition=False
        for i in range (len(b)):
            if mpm.fabs ((b[i]-bpriv[i])/bpriv[i])>math.pow(10,-1*NSIG):
                condition=True

        if numiter>500: #max number of iterations
            throwError("Break due to max number of iteration exceed")

    return b, numiter, log, Sklist, Sk