Exemplo n.º 1
0
    def speed_test(self):
        '''Over all speed test'''
        N = int(2e3)
        xmax = 5
        x = xmax * (np.random.rand(N) - 0.5)

        T = {}

        tic = time.perf_counter()
        erfcx(x)
        T['Benchmark (erfcx)'] = time.perf_counter() - tic

        tic = time.perf_counter()
        self.int_brute_force(x)
        T['Brute force integration'] = time.perf_counter() - tic

        tic = time.perf_counter()
        self.int_exact(x)
        T['Simplified integration'] = time.perf_counter() - tic

        tic = time.perf_counter()
        self.int_fast(x)
        T['Fast approximation'] = time.perf_counter() - tic

        rep = [
            'Speed Test Result', 'Number of samples: {}'.format(N),
            'Sample Range: [-{},{}]'.format(xmax, xmax)
        ]
        rep += ['Time Elapsed | Relative to benchmark']
        for k in T:
            rep.append('{}: {:.1e} | {:.1e}'.format(
                k, T[k], T[k] / T['Benchmark (erfcx)']))

        print('\n'.join(rep))
Exemplo n.º 2
0
def _bemg(x_in, la, lb, u, s, A):
    a = math.exp(la)  #la,lb default 2
    b = math.exp(lb)
    x = (x_in - u) / s
    Ea = (a / 2 + x)
    Eb = (b / 2 - x)
    Ea[Ea < -25] = -25
    Eb[Eb < -25] = -25
    return A * a * b / (a + b) * np.exp(-x**2) * (
        erfcx(Eb) + erfcx(Ea)) / 1.1273434771994788
Exemplo n.º 3
0
 def __call__(self, w):
     sigma = self.p[3]
     x0 = self.p[1]
     g = self.p[2]
     a = sqrt(w**2 - 1j*g*w) 
     a = a.real - 1j*a.imag #we want the imaginary part to the root to be positive
     prefac = 1j*sqrt(3.14149)*self.p[0]*x0**2/(sqrt(22)*sigma)
     eps = prefac*exp(-.5)*(1/a)*( sp.erfcx(-1j*(a-x0)/sigma) +  sp.erfcx(-1j*(a+x0)/sigma) )
     #self.f = 2*prefac*exp(-x0**2/(2*sigma**2))*(1 + sp.erf(1j*x0/sigma))
     self.f = eps.real[1]
     return (eps.real, eps.imag)
 def func_dawson(self, x: Tensor) -> Tensor:
     if x.is_cuda:
         if x.numel() > mnn_config.get_value('cpu_or_gpu'):
             return self._gpu_dawson(x)
         else:
             device = x.device
             return torch.from_numpy(
                 scipy.erfcx(-x.cpu().numpy()) * math.sqrt(math.pi) /
                 2).to(device=device)
     else:
         return torch.from_numpy(
             scipy.erfcx(-x.numpy()) * math.sqrt(math.pi) / 2)
Exemplo n.º 5
0
 def __call__(self, w):
     sigma = self.p[3]
     x0 = self.p[1]
     g = self.p[2]
     a = sqrt(w**2 - 1j * g * w)
     a = a.real - 1j * a.imag  #we want the imaginary part to the root to be positive
     prefac = 1j * sqrt(3.14149) * self.p[0] * x0**2 / (sqrt(22) * sigma)
     eps = prefac * exp(-.5) * (1 / a) * (sp.erfcx(-1j * (a - x0) / sigma) +
                                          sp.erfcx(-1j * (a + x0) / sigma))
     #self.f = 2*prefac*exp(-x0**2/(2*sigma**2))*(1 + sp.erf(1j*x0/sigma))
     self.f = eps.real[1]
     return (eps.real, eps.imag)
Exemplo n.º 6
0
 def int_exact(self, X):
     q = np.zeros(X.size)
     i = 0
     fun1 = lambda x: np.power(erfcx(-x), 2) * dawsn(x)
     fun2 = lambda x: np.exp(-x * x) * np.power(erfcx(-x), 2)
     for x in X:
         y1, _ = quad(fun1, -np.inf, x)
         y2, _ = quad(fun2, -np.inf, x)
         q[i] = -np.pi / 4 * y1 + np.power(np.sqrt(np.pi) / 2,
                                           3) * erfi(x) * y2
         i += 1
     return q
Exemplo n.º 7
0
def test():
    relative_error = 0
    for i in range(100):
        x = -1 + i * (10 - (-1)) / 100
        my_erfcx = erfcx(torch.FloatTensor([x]))
        relative_error = relative_error + np.abs(
            my_erfcx.item() - special.erfcx(x)) / special.erfcx(x)

    average_error = relative_error / 100
    print(average_error)
    normal = Normal(loc=torch.Tensor([0.0]), scale=torch.Tensor([1.0]))

    # cdf from 0 to x
    print(normal.cdf(1.6449))
    print(normal.icdf(torch.Tensor([0.95])))
Exemplo n.º 8
0
 def int_exact(self, X):
     '''Integral of the 2nd order Dawson function (with a change of order of integration)'''
     q = np.zeros(X.size)
     i = 0
     fun1 = lambda x: np.power(erfcx(-x), 2) * dawsn(x)
     fun2 = lambda x: np.exp(-x * x) * np.power(erfcx(-x), 2)
     for x in X:
         if x < -25:  #== -np.inf:
             q[i] = self.int_asym_neginf(x)
         else:
             y1, _ = quad(fun1, -np.inf, x)
             y2, _ = quad(fun2, -np.inf, x)
             q[i] = -np.pi / 4 * y1 + np.power(np.sqrt(np.pi) / 2,
                                               3) * erfi(x) * y2
         i += 1
     return q
Exemplo n.º 9
0
def mushroom_math(x, delta=.1, vf=.1):
    """
    new method, rewrite for numerical stability at high delta
    delta=0 causes divide by zero error!! Compensate elsewhere.
    http://ab-initio.mit.edu/wiki/index.php/Faddeeva_Package
    """
    from scipy.special import erfc, erfcx

    x_half = x / 2.0
    delta_double = 2.0 * delta
    return (
        (erfc(x_half) - erfcx(delta_double + x_half) / exp(x_half * x_half) -
         erfc(x) +
         ((.25 - delta *
           (x + delta_double)) * erfcx(delta_double + x) + delta / SQRT_PI) *
         4.0 / exp(x * x)) * vf / (delta_double * erfcx(delta_double)))
 def kai(model, altmp):  #approximated 1/Psi
     M = model.M
     kaitmp = np.where(altmp / sqrt(2.0) < -10.0, -altmp, np.zeros((M)))
     kaitmp2 = np.where(
         abs(altmp / sqrt(2.0)) < 10.0,
         sqrt(2.0 / pi) / scisp.erfcx(-altmp / sqrt(2.0)), kaitmp)
     return kaitmp2
Exemplo n.º 11
0
def _erfcx_integral(a, b, order):
    """Fixed order Gauss-Legendre quadrature of erfcx from a to b."""
    assert np.all(a >= 0) and np.all(b >= 0)
    x, w = roots_legendre(order)
    x = x[:, np.newaxis]
    w = w[:, np.newaxis]
    return (b - a) * np.sum(w * erfcx((b - a) * x / 2 +
                                      (b + a) / 2), axis=0) / 2
def score_sum(sum_u, k, l, data):
    m, n = data.shape
    cnr = gammaln(m + 1) - gammaln(k + 1) - gammaln(m - k + 1)
    cnc = gammaln(n + 1) - gammaln(l + 1) - gammaln(n - l + 1)
    ar = sum_u / np.sqrt(k * l)
    rest2 = -(ar * ar) / 2.0 + np.log(erfcx(ar / np.sqrt(2)) * 0.5)
    sc = -rest2 - cnr - cnc
    return sc
def log_erfc(x):
    fx = np.zeros(x.shape)
    ind = (x > 8)
    fx[ind] = np.log(erfcx(x[ind])) - x[ind]**2
    ind = (x <= 8)
    fx[ind] = np.log(erfc(x[ind]))

    return fx
Exemplo n.º 14
0
def cvoigt(omega, cent, delta, gamma=0.0):
    """Complex normalized Voigt line shape
    
    """
    a = (delta**2) / (4.0 * numpy.log(2))
    z = (gamma - 1j * (omega - cent)) / (2.0 * numpy.sqrt(a))

    return numpy.real(special.erfcx(z)) * numpy.sqrt(numpy.pi / a) / 2.0
Exemplo n.º 15
0
def channel(y, w, v, var_noise):
    """Compute g and g' for probit channel"""

    phi = -y * w / np.sqrt(2 * (v + var_noise))
    g = 2 * y / (np.sqrt(2 * np.pi * (v + var_noise)) * erfcx(phi))
    dg = -g * (w / (v + var_noise) + g)

    return g, dg
Exemplo n.º 16
0
 def forward_cpu(self, x):
     if not available_cpu:
         raise ImportError('SciPy is not available. Forward computation'
                           ' of erfcx in CPU cannot be done. ' +
                           str(_import_error))
     self.retain_inputs((0,))
     self.retain_outputs((0,))
     return utils.force_array(special.erfcx(x[0]), dtype=x[0].dtype),
Exemplo n.º 17
0
 def forward_cpu(self, x):
     if not available_cpu:
         raise ImportError('SciPy is not available. Forward computation'
                           ' of erfcx in CPU cannot be done. ' +
                           str(_import_error))
     self.retain_inputs((0, ))
     self.retain_outputs((0, ))
     return utils.force_array(special.erfcx(x[0]), dtype=x[0].dtype),
Exemplo n.º 18
0
def cvoigt(omega, cent, delta, gamma=0.0):
    """Complex normalized Voigt line shape
    
    """
    a = (delta**2)/(4.0*numpy.log(2))
    z = (gamma - 1j*(omega - cent))/(2.0*numpy.sqrt(a))
    
    
    return numpy.real(special.erfcx(z))*numpy.sqrt(numpy.pi/a)/2.0
Exemplo n.º 19
0
def lnDifErf(z1, z2):
    #Z2 is always positive
    logdiferf = np.zeros(z1.shape)
    ind = np.where(z1 > 0.)
    ind2 = np.where(z1 <= 0.)
    if ind[0].shape > 0:
        z1i = z1[ind]
        z12 = z1i * z1i
        z2i = z2[ind]
        logdiferf[ind] = -z12 + np.log(
            erfcx(z1i) - erfcx(z2i) * np.exp(z12 - z2i**2))

    if ind2[0].shape > 0:
        z1i = z1[ind2]
        z2i = z2[ind2]
        logdiferf[ind2] = np.log(erf(z2i) - erf(z1i))

    return logdiferf
Exemplo n.º 20
0
    def testLogErfcx(self, dtype):
        x = tf.random.uniform(shape=[int(1e5)],
                              minval=-3.,
                              maxval=3.,
                              dtype=dtype,
                              seed=test_util.test_seed())

        x_, logerfcx_ = self.evaluate([x, tfp.math.logerfcx(x)])
        self.assertAllClose(np.log(scipy_special.erfcx(x_)), logerfcx_)
Exemplo n.º 21
0
    def testErfcxLargeNegative(self, dtype):
        x = tf.random.uniform(shape=[int(1e5)],
                              minval=-100.,
                              maxval=-20.,
                              dtype=dtype,
                              seed=test_util.test_seed())

        x_, erfcx_ = self.evaluate([x, tfp.math.erfcx(x)])
        self.assertAllClose(scipy_special.erfcx(x_), erfcx_)
Exemplo n.º 22
0
 def int_brute_force(self, X):
     '''2nd order Dawson function (direct integration)'''
     q = np.zeros(X.size)
     i = 0
     for x in X:
         q[i], _ = quad(lambda x: erfcx(-x), 0, x)
         i += 1
     q = q * np.sqrt(np.pi) / 2
     return q
Exemplo n.º 23
0
def dbl_dawson(x):
    assert isinstance(x, np.ndarray)
    # assert x.ndim == 1
    length = x.size
    shape = x.shape
    x_flatten = x.flatten()
    res = np.empty([length], dtype=np.float)
    for i in range(length):
        res[i] = pi / 4 * quad(lambda u: np.exp(x_flatten[i]**2 - u**2) * erfcx(-u) ** 2, - np.inf, x_flatten[i])[0]
    return res.reshape(shape)
def g_prec(I,theta,sigm):
    
	range_grid = np.meshgrid(np.linspace(0,1,nint),xrange(len(I)))[0]

	dint = (theta-V_r)/(sigm*nint)
	#int_mesh = np.ndarray((480,nint))
	diff_grid = np.meshgrid(xrange(nint),(theta-V_r)/sigm)[1]
	low_value_grid = np.meshgrid(xrange(nint),(V_r-E_l-I*tau_m)/sigm)[1]
	int_mesh = erfcx(-(low_value_grid + range_grid*diff_grid))
	return 1./(pi_sqrt_tau*dint*int_mesh.sum(axis=1))
Exemplo n.º 25
0
def compute_F( t, x_bar, h ):
    if x_bar < 1e-30:
        return math.sqrt(h)*sp.erf( np.pi/(2*h*t) )
    else:
        z = np.complex( np.pi/(2*h*t), t*x_bar )
        w_iz = sp.erfcx( z )
        f = math.exp( -t**2 * x_bar**2 )
        f = f - np.real( np.exp(-t**2 * x_bar**2 - z*z)*w_iz )
        f = f*math.sqrt(h)
        return f
Exemplo n.º 26
0
def phi_noise(I,V_t,V_r,E_l,tau_m,sigm,nint):
	
	range_grid = np.meshgrid(np.linspace(0,1,nint),xrange(len(I)))[0]
	
	dint = (V_t-V_r)/(sigm*nint)
	#int_mesh = np.ndarray((480,nint))
	diff_grid = np.meshgrid(xrange(nint),(V_t-V_r)/sigm)[1]
	low_value_grid = np.meshgrid(xrange(nint),(V_r-E_l-I*tau_m)/sigm)[1]
	int_mesh = erfcx(-(low_value_grid + range_grid*diff_grid))
	return 1./(np.sqrt(np.pi)*tau_m*dint*int_mesh.sum(axis=1))
Exemplo n.º 27
0
def compute_F( t, x_bar, h ):
    if x_bar < 1e-30:
        return sqrt(h)*sp.erf( pi/(2*h*t) )
    else:
        z = np.complex( pi/(2*h*t), t*x_bar )
        w_iz = sp.erfcx( z )
        f = exp( -t**2 * x_bar**2 )
        f = f - np.real( np.exp(-t**2 * x_bar**2 - z*z)*w_iz )
        f = f*sqrt(h)
        return f
Exemplo n.º 28
0
 def integrand(u_arr):
     """Integrand of self-consistency equation"""
     integrand_all = erfcx(-u_arr)
     #integrand_all = np.zeros(u_arr.shape)
     #u_mask = u_arr < -4.0
     #u = u_arr[u_mask]
     #integrand_all[u_mask] = -1. / np.sqrt(np.pi) * (1.0 / u - 1.0 / (2.0 * u**3) + 
                                     #3.0 / (4.0 * u**5) - 
                                     #15.0 / (8.0 * u**7))
     #integrand_all[~u_mask] = np.exp(u_arr[~u_mask]**2) * (1. + erf(u_arr[~u_mask]))
     return integrand_all
Exemplo n.º 29
0
def compute_expectation_spec(beta, mu, sigma):
    """compute \int(exp(-beta*x)*phi(x;mu,sigma^2)) from mu to infty"""
    print beta, mu, sigma
    # we do this because the first term is liable to overflow
    u = beta*sigma/sqrt(2)
    prefactor = 1/2.0 * exp(-beta*mu)
    # first_term_ref = exp(u**2)
    # second_term_ref = erfc(u)
    # ans_ref = prefactor * first_term * second_term
    ans = prefactor * erfcx(u)
    # print ans_ref, ans
    return ans
Exemplo n.º 30
0
def mushroom_math(x, delta=0.1, vf=0.1):
    """
    new method, rewrite for numerical stability at high delta
    delta=0 causes divide by zero error!! Compensate elsewhere.
    http://ab-initio.mit.edu/wiki/index.php/Faddeeva_Package
    """

    from scipy.special import erfc, erfcx

    x_half = x / 2.0
    delta_double = 2.0 * delta
    return (
        (
            erfc(x_half)
            - erfcx(delta_double + x_half) / exp(x_half * x_half)
            - erfc(x)
            + ((0.25 - delta * (x + delta_double)) * erfcx(delta_double + x) + delta / SQRT_PI) * 4.0 / exp(x * x)
        )
        * vf
        / (delta_double * erfcx(delta_double))
    )
Exemplo n.º 31
0
def compute_expectation_spec(beta, mu, sigma):
    """compute \int(exp(-beta*x)*phi(x;mu,sigma^2)) from mu to infty"""
    print beta, mu, sigma
    # we do this because the first term is liable to overflow
    u = beta * sigma / sqrt(2)
    prefactor = 1 / 2.0 * exp(-beta * mu)
    # first_term_ref = exp(u**2)
    # second_term_ref = erfc(u)
    # ans_ref = prefactor * first_term * second_term
    ans = prefactor * erfcx(u)
    # print ans_ref, ans
    return ans
Exemplo n.º 32
0
def CreateData(y_range=(0., 2.), npoints=1000000, filename='erfcxinv.h5'):
    # Create a table of values for erfc(x), so that we can numerically estimate the inverse.
    # We're only interested in a limited range of values.
    x = np.flip(
        np.linspace(*y_range, npoints)
    )  # function monotonically decreases, we want f(x) to increase with index, thus perform flip
    y = spec.erfcx(x)
    result = np.column_stack((y, x))
    f = h5.File(filename, 'w')
    dset = f.create_dataset('erfcxinv',
                            data=result,
                            compression='gzip',
                            compression_opts=7)
    f.close()
Exemplo n.º 33
0
def sigmoid_lif(i0,
                tau=1.0,
                sigma=1.0,
                vr=-68.0,
                vth=-48.0,
                vrevers=-50.0,
                dt=10E-3):
    x1 = (vr - vrevers - i0) / sigma
    x2 = (vth - vrevers - i0) / sigma
    dx = (x2 - x1) / 2000.0
    x = np.arange(x1, x2 + dx, dx, dtype=np.float64)
    fx = erfcx(-x)
    t = tau * np.sqrt(pi) * np.sum(fx * dx) + dt * tau
    return 1.0 / t
Exemplo n.º 34
0
    def test_erfc(self):
        # in the application in STO-GTO integration,
        # the argument of erfcx becomes a/(2.0*sqrt(b)),
        # where a and b is orbital exponent of STO and GTO.
        # a ~ 1.0, 0.5 or 1/3
        # b ~ 0.01 ~ 30.0
        # So argument becomes
        # 5 ~ 0.027

        for theta in [0, 1, 45, 90, 270]:
            t = theta * np.pi / 180.0
            for a in [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]:
                z = a * np.exp(1.0j * a)
                self.assertAlmostEqual(sp.erfc(z),  erfc(z),  places=15)
                self.assertAlmostEqual(sp.erfcx(z), erfcx(z), places=15)
Exemplo n.º 35
0
def xGaussFn(mode, x, h, mu, sig, tau):
    if mode == 1:
        return (h * sig * np.sqrt(np.pi / 2.) /
                tau) * np.exp((sig / tau)**2. / 2. - (x - mu) / tau) * sp.erfc(
                    (sig / tau - (x - mu) / sig) / np.sqrt(2.))
    elif mode == 2:
        return (h * sig * np.sqrt(np.pi / 2.) / tau) * np.exp(
            (-1. / 2.) * ((x - mu) / sig)**2.) * sp.erfcx(
                (sig / tau - (x - mu) / sig) / np.sqrt(2.))
    elif mode == 3:
        return (h / (1 - (x - mu) * tau / sig**2.)) * np.exp(
            (-1. / 2.) * ((x - mu) / sig)**2.)
    else:
        print "unknown mode!"
        return -1
Exemplo n.º 36
0
    def test_erfc(self):
        # in the application in STO-GTO integration,
        # the argument of erfcx becomes a/(2.0*sqrt(b)),
        # where a and b is orbital exponent of STO and GTO.
        # a ~ 1.0, 0.5 or 1/3
        # b ~ 0.01 ~ 30.0
        # So argument becomes
        # 5 ~ 0.027

        for theta in [0, 1, 45, 90, 270]:
            t = theta * np.pi / 180.0
            for a in [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]:
                z = a * np.exp(1.0j * a)
                self.assertAlmostEqual(sp.erfc(z), erfc(z), places=15)
                self.assertAlmostEqual(sp.erfcx(z), erfcx(z), places=15)
Exemplo n.º 37
0
def analyticDistribution(x, args):
    #args[0]= time  args[1]=absorption coefficient
    t = args[0]
    alpha = args[1]
    mat = args[2]
    z = mat.D * t

    x1 = alpha * np.sqrt(z) - x / (2 * np.sqrt(z))
    x2 = alpha * np.sqrt(z) + x / (2 * np.sqrt(z))
    x3 = mat.s * np.sqrt(t / mat.D) + x / 2. / np.sqrt(z)


    phi=np.array(0.5*(erfcx(x1)+\
                      (alpha*mat.D+mat.s)/(alpha*mat.D-mat.s)*erfcx(x2))\
                 -mat.s*erfcx(x3)/(alpha*mat.D-mat.s))
    phi[phi == inf] = 0

    np.seterr(under='ignore')
    dat = phi * np.exp(-x * x / (4 * z) - t / mat.tau)
    np.seterr(under='raise')

    dat[np.where(dat == 0)] = np.exp(-alpha * x[np.where(dat == 0)])

    return dat
Exemplo n.º 38
0
    def trunc_norm_param_residuals(params):
        mean = params[:d]
        chol = params[d:]

        alpha = -mean * chol
        erf_term = 1 / erfcx(alpha / 2**0.5)
        std = 1 / chol
        var = std**2
        const = (2 / np.pi)**0.5

        trunc_mean = mean + const * erf_term * std
        trunc_var = var * (1 + const * alpha * erf_term - (const * erf_term)**2)

        mean_res = sample_mean - trunc_mean  # (d, )
        var_res = sample_var - trunc_var  # (d, )
        return np.concatenate((mean_res, var_res))
Exemplo n.º 39
0
    def _npcr(self, x):
        """
        Return the pdf/cdf ratio of a standard normal RV evaluated at x.

        Parameters
        ----------
        x : ndarray
            The values to evaluate the ratio at.

        Returns
        -------
        npcr_values : ndarray
            The evaluated ratios.

        """

        convert = x.dtype.type
        npcr_values = (2 / np.sqrt(2 * np.pi)) / convert(
            special.erfcx(-np.float_(x / np.sqrt(2))))

        return npcr_values
Exemplo n.º 40
0
def ln_diff_erfs(x1, x2, return_sign=False):
    """Function for stably computing the log of difference of two erfs in a numerically stable manner.
    :param x1 : argument of the positive erf
    :type x1: ndarray
    :param x2 : argument of the negative erf
    :type x2: ndarray
    :return: tuple containing (log(abs(erf(x1) - erf(x2))), sign(erf(x1) - erf(x2)))

    Based on MATLAB code that was written by Antti Honkela and modified by David Luengo and originally derived from code by Neil Lawrence.
    """
    x1 = np.require(x1).real
    x2 = np.require(x2).real
    if x1.size==1:
        x1 = np.reshape(x1, (1, 1))
    if x2.size==1:
        x2 = np.reshape(x2, (1, 1))

    if x1.shape==x2.shape:
        v = np.zeros_like(x1)
    else:
        if x1.size==1:
            v = np.zeros(x2.shape)
        elif x2.size==1:
            v = np.zeros(x1.shape)
        else:
            raise ValueError("This function does not broadcast unless provided with a scalar.")

    if x1.size == 1:
        x1 = np.tile(x1, x2.shape)

    if x2.size == 1:
        x2 = np.tile(x2, x1.shape)

    sign = np.sign(x1 - x2)
    if x1.size == 1:
        if sign== -1:
            swap = x1
            x1 = x2
            x2 = swap
    else:
        I = sign == -1
        swap = x1[I]
        x1[I] = x2[I]
        x2[I] = swap

    with np.errstate(divide='ignore'):
        # switch off log of zero warnings.

        # Case 0: arguments of different sign, no problems with loss of accuracy
        I0 = np.logical_or(np.logical_and(x1>0, x2<0), np.logical_and(x2>0, x1<0)) # I1=(x1*x2)<0

        # Case 1: x1 = x2 so we have log of zero.
        I1 = (x1 == x2)

        # Case 2: Both arguments are non-negative
        I2 = np.logical_and(x1 > 0, np.logical_and(np.logical_not(I0),
                                                   np.logical_not(I1)))
        # Case 3: Both arguments are non-positive
        I3 = np.logical_and(np.logical_and(np.logical_not(I0),
                                           np.logical_not(I1)),
                            np.logical_not(I2))
        _x2 = x2.flatten()
        _x1 = x1.flatten()
        for group, flags in zip((0, 1, 2, 3), (I0, I1, I2, I3)):

            if np.any(flags):
                if not x1.size==1:
                    _x1 = x1[flags]
                if not x2.size==1:
                    _x2 = x2[flags]
                if group==0:
                    v[flags] = np.log( erf(_x1) - erf(_x2) )
                elif group==1:
                    v[flags] = -np.inf
                elif group==2:
                    v[flags] = np.log(erfcx(_x2)
                                   -erfcx(_x1)*np.exp(_x2**2
                                                      -_x1**2)) - _x2**2
                elif group==3:
                    v[flags] = np.log(erfcx(-_x1)
                                   -erfcx(-_x2)*np.exp(_x1**2
                                                          -_x2**2))-_x1**2

    # TODO: switch back on log of zero warnings.

    if return_sign:
        return v, sign
    else:
        if v.size==1:
            if sign==-1:
                v = v.view('complex64')
                v += np.pi*1j
        else:
            # Need to add in a complex part because argument is negative.
            v = v.view('complex64')
            v[I] += np.pi*1j

    return v
Exemplo n.º 41
0
def differfln(x0, x1):
    # this is a, hopefully!, a numerically more stable variant of log(erf(x0)-erf(x1)) = log(erfc(x1)-erfc(x0)).
    return np.where(x0>x1, -x1*x1 + np.log(erfcx(x1)-np.exp(-x0**2+x1**2)*erfcx(x0)), -x0*x0 + np.log(np.exp(-x1**2+x0**2)*erfcx(x1) - erfcx(x0)))
Exemplo n.º 42
0
def _erfcx_cpu(x, dtype):
    from scipy import special
    return special.erfcx(x).astype(dtype)
Exemplo n.º 43
0
def normcdfln(x):
    return np.where(x < 0, -.5*x*x + np.log(.5) + np.log(erfcx(-x/np.sqrt(2))), np.log(normcdf(x)))
Exemplo n.º 44
0
 def integrand(u):
     """Integrand of self-consistency equation"""
     return erfcx(-u)