Ejemplo n.º 1
0
 def BK(xip, nr):
     r"""Return BK_nr."""
     if np.isrealobj(xip):
         # To keep it real in Laplace-domain [exp(-1j*0) = 1-0j].
         return special.kve(nr, xip)
     else:
         return np.exp(-1j * np.imag(xip)) * special.kve(nr, xip)
Ejemplo n.º 2
0
def Rlam(x, lam=None):
    v1 = kve(lam + 1, x) * np.exp(x)
    v0 = kve(lam, x) * np.exp(x)
    val = v1 / v0

    if np.isinf(v1) or np.isinf(v0) or v0 == 0 or v1 == 0:
        lv1 = np.log(sympy.Float(mpmath.besselk(np.abs(lam + 1), x)))
        lv0 = np.log(sympy.Float(mpmath.besselk(np.abs(lam), x)))
        val = np.exp(lv1 - lv0)

    return val
Ejemplo n.º 3
0
def gigGH(x=None, par=None, invS=None):
    """
        Calculate expectation of W, 1/W and log(W) (E-Step)
        W is assumed to follow Generalized Inverse Gaussian W~GIG(psi, chi, lambda)
        Refer to p9 A Mixture of Generalized Hyperbolic Distributions
        Params:
            a, v: numerical values
            b : numpy 2d array

        # Calculate a, b, c - expectations of w, 1/w, log(w) given x
        # w      : a = a_ig = E[W_ig | x_i, Z_ig = 1]
        # 1/w    : b = b_ig = E[1 / W_ig | x_i, Z_ig = 1]
        # log(w) : c = c_ig = E[log W_ig | x_i, Z_ig = 1]
        # abc is a MATRIX
        # returns a matrix with dim length(a) x 3 stima

        # a = omega_g + (beta_g)' * sigma_inverse * beta_g
        # b = omega + delta(x_i, mu_g | sigma_inverse)
        # kv1 is the denominator BesselK
        # kv is the numerator BesselK
        Input
        x: 2d array
            data
        par: ClusterParam object

        Return:
            tuple contains 3 values: E[W], E[1/W] and E[log(W)]
    """
    if invS is None:
        invS = np.linalg.inv(par.sigma)
    omega = par.omega

    a = omega + np.matmul(np.matmul(par.alpha, invS), par.alpha)
    delta = np.array(
        [mahalanobis(x[i, :], par.mu, invS)**2 for i in range(x.shape[0])])
    b = omega + delta
    v = par.lamda - par.mu.shape[0] / 2

    sab = np.sqrt(a * b)
    kvv = kve(v + 1, sab) / kve(v, sab)
    sb_a = np.sqrt(b / a)

    # Expected value of w and 1/w
    w = kvv * sb_a
    invw = kvv / sb_a - 2 * v / b
    logw = np.log(sb_a) + richardson_gradient(log_besselKv,
                                              x=v * np.ones(sab.shape),
                                              y=sab,
                                              eps=1e-8,
                                              d=0.0001,
                                              r=6,
                                              v=2)
    return (w, invw, logw)
Ejemplo n.º 4
0
def Fm(x, m, r1, r2, semi=True):
    ra = r1
    rb = r2
    if (r2 < r1):
        rb = r1
        ra = r2
    if m > 20 and semi:

        za = x * ra
        zb = x * rb
        if (za < 1e-5) and (zb < 1e-5):
            e = -1 + m * math.log(ra / rb * (m + 1.0) / m) - 0.5 * math.log(
                (m + 1.0) * m) - math.log(rb / 2 / (m + 1.0))
            return -math.exp(2 * e) / 4.0
            #return 0.0
        sqa1 = math.sqrt(m**2 + za**2)
        sqa2 = math.sqrt((m + 1)**2 + za**2)
        sqb1 = math.sqrt(m**2 + zb**2)
        sqb2 = math.sqrt((m + 1)**2 + zb**2)

        li1 = sqa1 + m * math.log(za / (m + sqa1)) - 0.5 * math.log(sqa1)
        li2 = sqa2 + (m + 1) * math.log(za /
                                        (m + 1 + sqa2)) - 0.5 * math.log(sqa2)
        lk1 = -sqb1 - m * math.log(zb / (m + sqb1)) - 0.5 * math.log(sqb1)
        lk2 = -sqb2 - (m + 1) * math.log(zb /
                                         (m + 1 + sqb2)) - 0.5 * math.log(sqb2)
        L = 2.0 * (li1 + lk1)
        Li = 2.0 * (li2 - li1)
        Lk = 2.0 * (lk2 - lk1)
        return math.exp(L) * x * x * (math.exp(Li) - 1) * (math.exp(Lk) -
                                                           1) / 4
        #return math.exp(L) * (math.exp(Li) - 1) * (math.exp(Lk) - 1)/4

    im1 = special.ive(m, x * ra)
    km1 = special.kve(m, x * rb)

    im2 = special.ive(m + 1, x * ra)
    km2 = special.kve(m + 1, x * rb)

    e = math.exp(x * (ra - rb))

    q1 = im1 * km1 * im1 * km1
    q2 = im2 * km2 * im2 * km2
    q3 = im1 * km2 * im1 * km2
    #q4 = q3
    q4 = im2 * km1 * im2 * km1
    #q = x * (im1 * km1 - im2 * km2) * e
    #print r1, r2, m, e, q
    return x * x * (im1 * im1 - im2 * im2) * (km2 * km2 - km1 * km1) * e * e
Ejemplo n.º 5
0
    def dKo(self,n,z):
        """odd second-kind radial Mathieu function derivative (DKo) 
        (analogous to K Bessel functions, called Gek in McLachlan p248), 
        for scalar or vector orders or argument

        n: order (scalar or vector)
        z: radial argument (scalar or vector)"""
        
        from scipy.special import kve,ive
        n,z,sqrtq,enz,epz,v1,v2,M,EV,OD = self._RadDerivFuncSetup(n,z)
        dy = np.empty((n.shape[0],z.shape[0]),dtype=complex)

        ord = self.ord[0:M+2]
        I = ive(ord[0:M+2,None],v1[None,:])[:,None,:]
        K = kve(ord[0:M+2,None],v2[None,:])[:,None,:]
        dI = self._deriv(v1,I[0:M+2,0,:],0)[:,None,:]
        dK = self._deriv(v2,K[0:M+2,0,:],1)[:,None,:]
        j = (n[:]-1)//2 

        dy[EV,:] = (sqrtq/self.B[0,j[EV],0,:]*np.sum(self.B[0:M,j[EV],0,:] *
                     (epz*I[0:M,:,:]*dK[2:M+2,:,:] - enz*dI[0:M,:,:]*K[2:M+2,:,:] -
                     (epz*I[2:M+2,:,:]*dK[0:M,:,:] - enz*dI[2:M+2,:,:]*K[0:M,:,:])),axis=0))

        dy[OD,:] = (sqrtq/self.A[0,j[OD],1,:]*np.sum(self.A[0:M,j[OD],1,:] *
                     (epz*I[0:M,:,:]*dK[1:M+1,:,:] - enz*dI[0:M,:,:]*K[1:M+1,:,:] + 
                      epz*I[1:M+1,:,:]*dK[0:M,:,:] - enz*dI[1:M+1,:,:]*K[0:M,:,:]),axis=0))

        dy *= np.exp(np.abs(v1.real) - v2)[None,:]
        dy[n==0,:] = np.NaN  # dKo_0() invalid
        return np.squeeze(dy)
Ejemplo n.º 6
0
    def Ko(self,n,z):
        """odd second-kind radial Mathieu function (Ko) 
        (analogous to K Bessel functions, called Gek in McLachlan p248), 
        for scalar or vector orders or argument

        n: order (scalar or vector)
        z: radial argument (scalar or vector)"""
        
        from scipy.special import kve,ive
        n,z,sqrtq,v1,v2,M,EV,OD = self._RadFuncSetup(n,z)
        y = np.empty((n.shape[0],z.shape[0]),dtype=complex)

        ord = self.ord[0:M+2]
        I = ive(ord[0:M+2,None],v1[None,:])[:,None,:]
        K = kve(ord[0:M+2,None],v2[None,:])[:,None,:]
        j = (n[:]-1)//2  

        y[EV,:] = (np.sum(self.B[0:M,j[EV],0,:] *
                     (I[0:M,:,:]*K[2:M+2,:,:] - I[2:M+2,:,:]*K[0:M,:,:]),axis=0)/
                   self.B[0,j[EV],0,:])

        y[OD,:] = (np.sum(self.A[0:M,j[OD],1,:] *
                     (I[0:M,:,:]*K[1:M+1,:,:] + I[1:M+1,:,:]*K[0:M,:,:]),axis=0)/
                   self.A[0,j[OD],1,:])

        y *= np.exp(np.abs(v1.real) - v2)[None,:]
        y[n==0,:] = np.NaN   # Ko_0() invalid
        return np.squeeze(y)
Ejemplo n.º 7
0
    def Ko(self, n, z):
        """odd second-kind radial Mathieu function (Ko) 
        (analogous to K Bessel functions, called Gek in McLachlan p248), 
        for scalar or vector orders or argument

        n: order (scalar or vector)
        z: radial argument (scalar or vector)"""

        from scipy.special import kve, ive
        n, z, sqrtq, v1, v2, M, EV, OD = self._RadFuncSetup(n, z)
        y = np.empty((n.shape[0], z.shape[0]), dtype=complex)

        ord = self.ord[0:M + 2]
        I = ive(ord[0:M + 2, None], v1[None, :])[:, None, :]
        K = kve(ord[0:M + 2, None], v2[None, :])[:, None, :]
        j = (n[:] - 1) // 2

        y[EV, :] = (np.sum(self.B[0:M, j[EV], 0, :] *
                           (I[0:M, :, :] * K[2:M + 2, :, :] -
                            I[2:M + 2, :, :] * K[0:M, :, :]),
                           axis=0) / self.B[0, j[EV], 0, :])

        y[OD, :] = (np.sum(self.A[0:M, j[OD], 1, :] *
                           (I[0:M, :, :] * K[1:M + 1, :, :] +
                            I[1:M + 1, :, :] * K[0:M, :, :]),
                           axis=0) / self.A[0, j[OD], 1, :])

        y *= np.exp(np.abs(v1.real) - v2)[None, :]
        y[n == 0, :] = np.NaN  # Ko_0() invalid
        return np.squeeze(y)
Ejemplo n.º 8
0
 def test_besselk10e(self):
     xs = [0.1, 1.0, 10.0]
     for x in xs:
         sp = kve(10, x)
         hal = besselkne(10, x)
         relerr = abs((sp - hal) / sp)
         self.assertLessEqual(relerr, 0.05)
Ejemplo n.º 9
0
 def testBesselKveZNegativeVLarge(self, dtype, rtol):
     seed_stream = test_util.test_seed_stream()
     v = np.linspace(100., 200., num=10, dtype=dtype)
     z = tf.random.uniform([10], -10., -1., seed=seed_stream(), dtype=dtype)
     z, bessel_kve = self.evaluate([z, tfp.math.bessel_kve(v, z)])
     scipy_kve = scipy_special.kve(v, z)
     self.assertAllClose(bessel_kve, scipy_kve, rtol=rtol)
Ejemplo n.º 10
0
def get_prior(E_x, E_invx, k, lamb, rho, tau):
    
    #The underlying probability distribution
    #P(x)=Gamma(x | k, lambda)
    #Q(x)=GIG(x | k, rho, tau)
    #The log(x) term is canceled out between logP(x) and logQ(x)
    
    #Initialization
    prior = 0
    
    #Avoid "invalid multiplication" error caused by small tau
    tau[tau < 1e-100] = 1e-100
    
    #The logP(x) term other than the canceled log(x)
    prior = prior + (k * np.log(lamb) - sc.gammaln(k)) * E_x.size
    prior = prior - np.sum(lamb * E_x)
    
    #The -logQ(x) term
    #log2
    prior = prior + np.log(2) * E_x.size
    
    #-k/2*(log(rho)-log(tau))
    prior = prior - (k/2) * np.sum(np.log(rho) - np.log(tau))
    
    #rho*x+tau/x
    prior = prior + np.sum(rho * E_x + tau * E_invx)
    
    #log(bessel(2*sqrt(rho*tau)))
    prior = prior + np.sum(np.log(sc.kve(k, 2*np.sqrt(rho*tau))))
    
    return prior
Ejemplo n.º 11
0
def ddghypGH(x, par, log=False, invS=None):
    mu = par.mu
    sigma = par.sigma
    alpha = par.alpha

    if (len(mu) != len(alpha)):
        print('mu and alpha do not have the same length.')
        return

    d = len(mu)
    omega = np.exp(np.log(par.omega))
    lamda = par.lamda

    if not invS:
        invS = np.linalg.pinv(sigma)

    pa = omega + np.matmul(np.matmul(alpha, invS), alpha)
    delta = np.array(
        [mahalanobis(x[i, :], mu, invS)**2 for i in range(x.shape[0])])
    mx = omega + delta

    kx = np.sqrt(mx * pa)
    xmu = x - mu

    lvx = np.zeros((x.shape[0], 4))
    lvx[:, 0] = (lamda - d / 2) * np.log(kx)
    lvx[:, 1] = np.log(kve(lamda - d / 2, kx)) - kx
    lvx[:, 2] = np.matmul(np.matmul(xmu, invS), alpha)

    lv = np.zeros(6)
    if np.log(np.linalg.det(sigma)) is np.inf:  # need checking
        sigma = np.eye(len(mu))

    lv[0] = -1 / 2 * np.log(np.linalg.det(sigma))
    lv[0] -= d / 2 * (np.log(2) + np.log(np.pi))
    lv[1] = omega - np.log(kve(lamda, omega))
    lv[2] = -lamda / 2 * np.log(1)
    lv[3] = lamda * np.log(omega) * 0
    lv[4] = (d / 2 - lamda) * np.log(pa)

    val = np.sum(lvx.transpose(), axis=0) + sum(lv)
    if not log:
        val = np.exp(val)

    return val
Ejemplo n.º 12
0
def Fm(x, m, r1, r2, semi = True):
    ra = r1
    rb = r2
    if (r2 < r1):
       rb = r1
       ra = r2
    if m > 20 and semi:
       
       za = x * ra
       zb = x * rb
       if (za < 1e-5) and (zb < 1e-5): 
           e = -1 + m * math.log(ra/rb * (m + 1.0)/m) -0.5 *math.log((m+1.0)*m) - math.log(rb/2/(m + 1.0))
           return -math.exp(2*e)/4.0
           #return 0.0
       sqa1 = math.sqrt(m**2 + za**2)
       sqa2 = math.sqrt((m + 1)**2 + za**2)
       sqb1 = math.sqrt(m**2 + zb**2)
       sqb2 = math.sqrt((m + 1)**2 + zb**2)
       
       li1 = sqa1 + m * math.log(za/(m + sqa1)) - 0.5 * math.log(sqa1) 
       li2 = sqa2 + (m + 1) * math.log(za/(m + 1 + sqa2)) - 0.5 * math.log(sqa2) 
       lk1 = -sqb1 - m * math.log(zb/(m + sqb1)) - 0.5 * math.log(sqb1)
       lk2 = -sqb2 - (m + 1)* math.log(zb/(m + 1 + sqb2)) - 0.5 * math.log(sqb2)
       L =  2.0*(li1 + lk1)
       Li = 2.0*(li2 - li1)
       Lk = 2.0*(lk2 - lk1)
       return math.exp(L) * x * x * (math.exp(Li) - 1) * (math.exp(Lk) - 1)/4
       #return math.exp(L) * (math.exp(Li) - 1) * (math.exp(Lk) - 1)/4
       
    im1 = special.ive(m, x * ra)
    km1 = special.kve(m, x * rb)
    
    im2 = special.ive(m + 1, x * ra)
    km2 = special.kve(m + 1, x * rb)
    
    e = math.exp(x * (ra - rb))
    
    q1 = im1 * km1 * im1 * km1 
    q2 = im2 * km2 * im2 * km2 
    q3 = im1 * km2 * im1 * km2
    #q4 = q3
    q4 = im2 * km1 * im2 * km1
    #q = x * (im1 * km1 - im2 * km2) * e
    #print r1, r2, m, e, q
    return x * x * (im1 * im1 - im2 * im2) * (km2 * km2 - km1 * km1) * e * e
Ejemplo n.º 13
0
    def estimate(self, context, data):
        pdf = ScaleMixture()
        alpha = context.prior.alpha
        beta = context.prior.beta
        d = context._d

        if len(data.shape) == 1:
            data = data[:, numpy.newaxis]

        p = -alpha + 0.5 * d 
        b = 2 * beta 
        a = 1e-5 + data.sum(-1) ** 2 

        s = numpy.clip((numpy.sqrt(b) * kve(p + 1, numpy.sqrt(a * b)))
                       / (numpy.sqrt(a) * kve(p, numpy.sqrt(a * b))),
                       1e-10, 1e10)
        pdf.scales = s
        context.prior.estimate(s)
        pdf.prior = context.prior

        return pdf
Ejemplo n.º 14
0
def get_GIG_expectation(gamma, rho, tau):
    
    #Initialize variables
    if np.isscalar(gamma) == True:
        gamma = gamma * np.ones_like(rho) #Extend into the same size
    E_x = np.zeros_like(rho)
    E_invx = np.zeros_like(rho)
    
    #Avoid "invalid multiplication" error caused by small tau
    tau[tau < 1e-100] = 1e-100
    
    #Compute the scaled bessel function "kve" using the scipy.special
    rt_rho = np.sqrt(rho)
    rt_tau = np.sqrt(tau)
    bessel_gamma = sc.kve(gamma, 2*rt_rho*rt_tau)
    bessel_gamma_1minus = sc.kve(gamma-1, 2*rt_rho*rt_tau)
    bessel_gamma_1plus = sc.kve(gamma+1, 2*rt_rho*rt_tau)
    
    #Compute expectations of x and inverse x under the GIG
    E_x = (bessel_gamma_1plus * rt_tau) / (rt_rho * bessel_gamma)
    E_invx = (bessel_gamma_1minus * rt_rho) / (rt_tau * bessel_gamma)
    
    return E_x, E_invx
Ejemplo n.º 15
0
def compute_gig_expectations(alpha, beta, gamma):
    if np.asarray(alpha).size == 1:
        alpha = alpha * np.ones_like(beta)

    Ex, Exinv = np.zeros_like(beta), np.zeros_like(beta)

    # For very small values of gamma and positive values of alpha, the GIG
    # distribution becomes a gamma distribution, and its expectations are both
    # cheaper and more stable to compute that way.
    gig_inds = (gamma > 1e-200)
    gam_inds = (gamma <= 1e-200)

    if np.any(alpha[gam_inds] < 0):
        raise ValueError("problem with arguments.")

    # Compute expectations for GIG distribution.
    sqrt_beta = np.sqrt(beta[gig_inds])
    sqrt_gamma = np.sqrt(gamma[gig_inds])
    # Note that we're using the *scaled* version here, since we're just
    # computing ratios and it's more stable.
    bessel_alpha_minus = special.kve(alpha[gig_inds] - 1,
                                     2 * sqrt_beta * sqrt_gamma)
    bessel_alpha = special.kve(alpha[gig_inds], 2 * sqrt_beta * sqrt_gamma)
    bessel_alpha_plus = special.kve(alpha[gig_inds] + 1,
                                    2 * sqrt_beta * sqrt_gamma)
    sqrt_ratio = sqrt_gamma / sqrt_beta

    Ex[gig_inds] = bessel_alpha_plus * sqrt_ratio / bessel_alpha
    Exinv[gig_inds] = bessel_alpha_minus / (sqrt_ratio * bessel_alpha)

    # Compute expectations for gamma distribution where we can get away with
    # it.
    Ex[gam_inds] = alpha[gam_inds] / beta[gam_inds]
    Exinv[gam_inds] = beta[gam_inds] / (alpha[gam_inds] - 1)
    Exinv[Exinv < 0] = np.inf

    return (Ex, Exinv)
Ejemplo n.º 16
0
def compute_gig_expectations(alpha, beta, gamma):
    if np.asarray(alpha).size == 1:
        alpha = alpha * np.ones_like(beta)

    Ex, Exinv = np.zeros_like(beta), np.zeros_like(beta)

    # For very small values of gamma and positive values of alpha, the GIG
    # distribution becomes a gamma distribution, and its expectations are both
    # cheaper and more stable to compute that way.
    gig_inds = (gamma > 1e-200)
    gam_inds = (gamma <= 1e-200)

    if np.any(alpha[gam_inds] < 0):
        raise ValueError("problem with arguments.")

    # Compute expectations for GIG distribution.
    sqrt_beta = np.sqrt(beta[gig_inds])
    sqrt_gamma = np.sqrt(gamma[gig_inds])
    # Note that we're using the *scaled* version here, since we're just
    # computing ratios and it's more stable.
    bessel_alpha_minus = special.kve(alpha[gig_inds] - 1, 2 * sqrt_beta *
                                     sqrt_gamma)
    bessel_alpha = special.kve(alpha[gig_inds], 2 * sqrt_beta * sqrt_gamma)
    bessel_alpha_plus = special.kve(alpha[gig_inds] + 1, 2 * sqrt_beta *
                                    sqrt_gamma)
    sqrt_ratio = sqrt_gamma / sqrt_beta

    Ex[gig_inds] = bessel_alpha_plus * sqrt_ratio / bessel_alpha
    Exinv[gig_inds] = bessel_alpha_minus / (sqrt_ratio * bessel_alpha)

    # Compute expectations for gamma distribution where we can get away with
    # it.
    Ex[gam_inds] = alpha[gam_inds] / beta[gam_inds]
    Exinv[gam_inds] = beta[gam_inds] / (alpha[gam_inds] - 1)
    Exinv[Exinv < 0] = np.inf

    return (Ex, Exinv)
def k012e(x):
    """Returns k0e(x), k1e(x) and k2e(x) for real or complex x.
    
    For real x, the fast exponentially scaled K_n Bessel functions, k0e end k1e 
    are defined in scipy.special, but not ke2, which is computed here from the 
    other two using the recurion: 
        K_n(x) = K_{n-2}(x) + 2(n-1)/z * K_{n-1}(x) 
    
    For complex x, kve(0,x) and kve(1,x) and the recursion are used.
    
    Returns the outputs all three functions, evaluated at x.
    """
    if np.iscomplexobj(x):
        k0 = special.kve(0,x)
        k1 = special.kve(1,x)
        k2 = k0 + 2.0*k1/x
    else:
        k0 = special.k0e(x)
        k1 = special.k1e(x)
        k2 = k0 + 2.0*k1/x
    return k0, k1, k2

#def ddxlogK1e(z):
    """
Ejemplo n.º 18
0
    def logpyt(self, theta, t):
        alpha = np.exp(theta['log_alpha'])
        lam = np.exp(theta['log_lambda'])

        abs_y = np.maximum(np.abs(self.data[t]), tol)

        # Numerical issues when computing the modified Bessel function
        #print("Value of (y, alpha, lambda) = ({}, {}, {})".format(abs_y, alpha, lam))
        #print("Bessel function = {}".format(kv(lam - 0.5, alpha * abs_y)))
        if kv(lam - 0.5, alpha * abs_y) > 0:
            return 2 * lam * np.log(alpha) + (lam - 0.5) * np.log(abs_y) + \
                   np.log(kv(lam - 0.5, alpha*abs_y)) - 0.5 * np.log(np.pi) - \
                   gammaln(lam) - (lam - 0.5)*np.log(2*alpha)

        return 2 * lam * np.log(alpha) + (lam - 0.5) * np.log(abs_y) + \
               np.log(kve(lam - 0.5, alpha*abs_y)) - abs_y - 0.5 * np.log(np.pi) - \
               gammaln(lam) - (lam - 0.5) * np.log(2 * alpha)
Ejemplo n.º 19
0
    def logpyt(self, theta, t):
        eta = np.exp(theta['log_eta'])
        c = np.exp(theta['log_c'])

        alpha = np.sqrt(2 * c)
        lam = eta

        abs_y = np.maximum(np.abs(self.data[t]), tol)

        # Numerical issues when computing the modified Bessel function
        if kv(lam - 0.5, alpha * abs_y) > 0:
            return 2 * lam * np.log(alpha) + (lam - 0.5) * np.log(abs_y) + \
                   np.log(kv(lam - 0.5, alpha*abs_y)) - 0.5 * np.log(np.pi) - \
                   gammaln(lam) - (lam - 0.5)*np.log(2*alpha)

        return 2 * lam * np.log(alpha) + (lam - 0.5) * np.log(abs_y) + \
               np.log(kve(lam - 0.5, alpha*abs_y)) - abs_y - 0.5 * np.log(np.pi) - \
               gammaln(lam) - (lam - 0.5) * np.log(2 * alpha)
Ejemplo n.º 20
0
def gig_gamma_term(Ex, Exinv, rho, tau, a, b):
    score = 0
    cut_off = 1e-200
    zero_tau = (tau <= cut_off)
    non_zero_tau = (tau > cut_off)
    score += Ex.size * (a * log(b) - special.gammaln(a))
    score -= np.sum((b - rho) * Ex)

    score -= np.sum(non_zero_tau) * log(0.5)
    score += np.sum(tau[non_zero_tau] * Exinv[non_zero_tau])
    score -= 0.5 * a * np.sum(np.log(rho[non_zero_tau]) -
                              np.log(tau[non_zero_tau]))
    # It's numerically safer to use scaled version of besselk
    score += np.sum(np.log(special.kve(a, 2 * np.sqrt(rho[non_zero_tau] *
                                                      tau[non_zero_tau]))) -
                    2 * np.sqrt(rho[non_zero_tau] * tau[non_zero_tau]))

    score += np.sum(-a * np.log(rho[zero_tau]) + special.gammaln(a))
    return score
Ejemplo n.º 21
0
def gig_gamma_term(Ex, Exinv, rho, tau, a, b):
    score = 0
    cut_off = 1e-200
    zero_tau = (tau <= cut_off)
    non_zero_tau = (tau > cut_off)
    score += Ex.size * (a * log(b) - special.gammaln(a))
    score -= np.sum((b - rho) * Ex)

    score -= np.sum(non_zero_tau) * log(0.5)
    score += np.sum(tau[non_zero_tau] * Exinv[non_zero_tau])
    score -= 0.5 * a * np.sum(
        np.log(rho[non_zero_tau]) - np.log(tau[non_zero_tau]))
    # It's numerically safer to use scaled version of besselk
    score += np.sum(
        np.log(
            special.kve(a, 2 *
                        np.sqrt(rho[non_zero_tau] * tau[non_zero_tau]))) -
        2 * np.sqrt(rho[non_zero_tau] * tau[non_zero_tau]))

    score += np.sum(-a * np.log(rho[zero_tau]) + special.gammaln(a))
    return score
Ejemplo n.º 22
0
    def dKo(self, n, z):
        """odd second-kind radial Mathieu function derivative (DKo) 
        (analogous to K Bessel functions, called Gek in McLachlan p248), 
        for scalar or vector orders or argument

        n: order (scalar or vector)
        z: radial argument (scalar or vector)"""

        from scipy.special import kve, ive
        n, z, sqrtq, enz, epz, v1, v2, M, EV, OD = self._RadDerivFuncSetup(
            n, z)
        dy = np.empty((n.shape[0], z.shape[0]), dtype=complex)

        ord = self.ord[0:M + 2]
        I = ive(ord[0:M + 2, None], v1[None, :])[:, None, :]
        K = kve(ord[0:M + 2, None], v2[None, :])[:, None, :]
        dI = self._deriv(v1, I[0:M + 2, 0, :], 0)[:, None, :]
        dK = self._deriv(v2, K[0:M + 2, 0, :], 1)[:, None, :]
        j = (n[:] - 1) // 2

        dy[EV, :] = (sqrtq / self.B[0, j[EV], 0, :] *
                     np.sum(self.B[0:M, j[EV], 0, :] *
                            (epz * I[0:M, :, :] * dK[2:M + 2, :, :] -
                             enz * dI[0:M, :, :] * K[2:M + 2, :, :] -
                             (epz * I[2:M + 2, :, :] * dK[0:M, :, :] -
                              enz * dI[2:M + 2, :, :] * K[0:M, :, :])),
                            axis=0))

        dy[OD, :] = (sqrtq / self.A[0, j[OD], 1, :] * np.sum(
            self.A[0:M, j[OD], 1, :] *
            (epz * I[0:M, :, :] * dK[1:M + 1, :, :] - enz * dI[0:M, :, :] *
             K[1:M + 1, :, :] + epz * I[1:M + 1, :, :] * dK[0:M, :, :] -
             enz * dI[1:M + 1, :, :] * K[0:M, :, :]),
            axis=0))

        dy *= np.exp(np.abs(v1.real) - v2)[None, :]
        dy[n == 0, :] = np.NaN  # dKo_0() invalid
        return np.squeeze(dy)
Ejemplo n.º 23
0
    def Mtil(m, epr, mur, bet, nu, b):
        def produto(A,B):
            C = _np.zeros((A.shape[0],B.shape[1],A.shape[2]),dtype=complex)
            for i in range(A.shape[0]):
                for j in range(B.shape[1]):
                    for k in range(A.shape[1]):
                        C[i,j,:] = C[i,j,:] + A[i,k,:]*B[k,j,:]
            return C

        for i in range(len(b)): # lembrando que length(b) = número de camadas - 1
            x = nu[i+1,:] * b[i]
            y = nu[i  ,:] * b[i]
            Mt = _np.zeros((4,4,w.shape[0]),dtype=complex)

            if i<len(b)-1:
                D = _np.zeros((4,4,nu.shape[1]),dtype=complex)
                z = nu[i+1,:]*b[i+1]
                if not any(z.real<0):
                    ind = (z.real<60)

                    A = _scyspe.iv(m,z[ind])
                    B = _scyspe.kv(m,z[ind])
                    C = _scyspe.iv(m,x[ind])
                    E = _scyspe.kv(m,x[ind])

                    D[0,0,:]    =  1
                    D[1,1,ind]  = - B*C/(A*E)
                    D[1,1,~ind] = - _np.exp(-2*(z[~ind]-x[~ind]))
                    D[2,2,:]    =  1
                    D[3,3,ind]  = - B*C/(A*E)
                    D[3,3,~ind] = - _np.exp(-2*(z[~ind]-x[~ind]))

            Mt[0,0,:] = -nu[i+1,:]**2*b[i]/epr[i+1,:]*(
                    epr[i+1,:]/nu[i+1,:]*(-_scyspe.kve(m-1,x)/_scyspe.kve(m,x) - m/x)
                    - epr[i,:]/nu[i,:]  *( _scyspe.ive(m-1,y)/_scyspe.ive(m,y) - m/y))
            Mt[0,1,:] = -nu[i+1,:]**2*b[i]/epr[i+1,:]*(
                    epr[i+1,:]/nu[i+1,:]*(-_scyspe.kve(m-1,x)/_scyspe.kve(m,x) - m/x)
                    - epr[i,:]/nu[i,:]  *(-_scyspe.kve(m-1,y)/_scyspe.kve(m,y) - m/y))
            Mt[1,0,:] = -nu[i+1,:]**2*b[i]/epr[i+1,:]*(
                    epr[i+1,:]/nu[i+1,:]*( _scyspe.ive(m-1,x)/_scyspe.ive(m,x) - m/x)
                    - epr[i,:]/nu[i,:]  *( _scyspe.ive(m-1,y)/_scyspe.ive(m,y) - m/y))
            Mt[1,1,:] = -nu[i+1,:]**2*b[i]/epr[i+1,:]*(
                    epr[i+1,:]/nu[i+1,:]*( _scyspe.ive(m-1,x)/_scyspe.ive(m,x) - m/x)
                    - epr[i,:]/nu[i,:]  *(-_scyspe.kve(m-1,y)/_scyspe.kve(m,y) - m/y))

            Mt[0,2,:] = (nu[i+1,:]**2/nu[i,:]**2 - 1)*m/(bet*epr[i+1,:])
            Mt[0,3,:] = Mt[0,2,:]
            Mt[1,2,:] = Mt[0,2,:]
            Mt[1,3,:] = Mt[0,2,:]
            Mt[2,2,:] = -nu[i+1,:]**2*b[i]/mur[i+1,:]*(
                    mur[i+1,:]/nu[i+1,:]*(-_scyspe.kve(m-1,x)/_scyspe.kve(m,x) - m/x)
                    - mur[i,:]/nu[i,:]  *( _scyspe.ive(m-1,y)/_scyspe.ive(m,y) - m/y))
            Mt[2,3,:] = -nu[i+1,:]**2*b[i]/mur[i+1,:]*(
                    mur[i+1,:]/nu[i+1,:]*(-_scyspe.kve(m-1,x)/_scyspe.kve(m,x) - m/x)
                    - mur[i,:]/nu[i,:]  *(-_scyspe.kve(m-1,y)/_scyspe.kve(m,y) - m/y))
            Mt[3,2,:] = -nu[i+1,:]**2*b[i]/mur[i+1,:]*(
                    mur[i+1,:]/nu[i+1,:]*( _scyspe.ive(m-1,x)/_scyspe.ive(m,x) - m/x)
                    - mur[i,:]/nu[i,:]  *( _scyspe.ive(m-1,y)/_scyspe.ive(m,y) - m/y))
            Mt[3,3,:] = -nu[i+1,:]**2*b[i]/mur[i+1,:]*(
                    mur[i+1,:]/nu[i+1,:]*( _scyspe.ive(m-1,x)/_scyspe.ive(m,x) - m/x)
                    - mur[i,:]/nu[i,:]  *(-_scyspe.kve(m-1,y)/_scyspe.kve(m,y) - m/y))
            Mt[2,0,:] = (nu[i+1,:]**2/nu[i,:]**2 - 1)*m/(bet*mur[i+1,:])
            Mt[2,1,:] = Mt[2,0,:]
            Mt[3,0,:] = Mt[2,0,:]
            Mt[3,1,:] = Mt[2,0,:]

            if len(b) == 1:
                M = Mt
            else:
                if (i ==0):
                    M = produto(D,Mt)
                elif i < len(b)-1:
                    M = produto(D,produto(Mt,M))
                else:
                    M = produto(Mt,M)
        return M
Ejemplo n.º 24
0
def rel_thermal_beta(mu):
    # computes thermal velocity/c for mu
    return np.sqrt(1.e0 - (kve(1, mu) / kve(2, mu) + 3.e0 / mu)**(-2))
Ejemplo n.º 25
0
 def BK(xip, nr):
     """Return BK_nr."""
     return np.exp(-1j * np.imag(xip)) * kve(nr, xip)
Ejemplo n.º 26
0
 def BK(xip, nr):
     r"""Return BK_nr."""
     return np.exp(-1j * np.imag(xip)) * special.kve(nr, xip)
Ejemplo n.º 27
0
 def besselkve(self, v, x):
     if v == 1:
         return special.k1e(x)
     else:
         return special.kve(v, x)
Ejemplo n.º 28
0
 def VerifyBesselKve(self, v, z, rtol):
     bessel_kve, v, z = self.evaluate([tfp.math.bessel_kve(v, z), v, z])
     scipy_kve = scipy_special.kve(v, z)
     self.assertAllClose(bessel_kve, scipy_kve, rtol=rtol)
Ejemplo n.º 29
0
def log_besselKv(nu, y):
    return np.log(kve(nu, y)) - np.log(y)
Ejemplo n.º 30
0
    def Mtil(m, epr, mur, bet, nu, b):
        def produto(A, B):
            C = _np.zeros((A.shape[0], B.shape[1], A.shape[2]), dtype=complex)
            for i in range(A.shape[0]):
                for j in range(B.shape[1]):
                    for k in range(A.shape[1]):
                        C[i, j, :] = C[i, j, :] + A[i, k, :] * B[k, j, :]
            return C

        for i in range(
                len(b)):  # lembrando que length(b) = número de camadas - 1
            x = nu[i + 1, :] * b[i]
            y = nu[i, :] * b[i]
            Mt = _np.zeros((4, 4, w.shape[0]), dtype=complex)

            if i < len(b) - 1:
                D = _np.zeros((4, 4, nu.shape[1]), dtype=complex)
                z = nu[i + 1, :] * b[i + 1]
                if not any(z.real < 0):
                    ind = (z.real < 60)

                    A = _scyspe.iv(m, z[ind])
                    B = _scyspe.kv(m, z[ind])
                    C = _scyspe.iv(m, x[ind])
                    E = _scyspe.kv(m, x[ind])

                    D[0, 0, :] = 1
                    D[1, 1, ind] = -B * C / (A * E)
                    D[1, 1, ~ind] = -_np.exp(-2 * (z[~ind] - x[~ind]))
                    D[2, 2, :] = 1
                    D[3, 3, ind] = -B * C / (A * E)
                    D[3, 3, ~ind] = -_np.exp(-2 * (z[~ind] - x[~ind]))

            Mt[0, 0, :] = -nu[i + 1, :]**2 * b[i] / epr[i + 1, :] * (
                epr[i + 1, :] / nu[i + 1, :] *
                (-_scyspe.kve(m - 1, x) / _scyspe.kve(m, x) - m / x) -
                epr[i, :] / nu[i, :] *
                (_scyspe.ive(m - 1, y) / _scyspe.ive(m, y) - m / y))
            Mt[0, 1, :] = -nu[i + 1, :]**2 * b[i] / epr[i + 1, :] * (
                epr[i + 1, :] / nu[i + 1, :] *
                (-_scyspe.kve(m - 1, x) / _scyspe.kve(m, x) - m / x) -
                epr[i, :] / nu[i, :] *
                (-_scyspe.kve(m - 1, y) / _scyspe.kve(m, y) - m / y))
            Mt[1, 0, :] = -nu[i + 1, :]**2 * b[i] / epr[i + 1, :] * (
                epr[i + 1, :] / nu[i + 1, :] *
                (_scyspe.ive(m - 1, x) / _scyspe.ive(m, x) - m / x) -
                epr[i, :] / nu[i, :] *
                (_scyspe.ive(m - 1, y) / _scyspe.ive(m, y) - m / y))
            Mt[1, 1, :] = -nu[i + 1, :]**2 * b[i] / epr[i + 1, :] * (
                epr[i + 1, :] / nu[i + 1, :] *
                (_scyspe.ive(m - 1, x) / _scyspe.ive(m, x) - m / x) -
                epr[i, :] / nu[i, :] *
                (-_scyspe.kve(m - 1, y) / _scyspe.kve(m, y) - m / y))

            Mt[0, 2, :] = (nu[i + 1, :]**2 / nu[i, :]**2 -
                           1) * m / (bet * epr[i + 1, :])
            Mt[0, 3, :] = Mt[0, 2, :]
            Mt[1, 2, :] = Mt[0, 2, :]
            Mt[1, 3, :] = Mt[0, 2, :]
            Mt[2, 2, :] = -nu[i + 1, :]**2 * b[i] / mur[i + 1, :] * (
                mur[i + 1, :] / nu[i + 1, :] *
                (-_scyspe.kve(m - 1, x) / _scyspe.kve(m, x) - m / x) -
                mur[i, :] / nu[i, :] *
                (_scyspe.ive(m - 1, y) / _scyspe.ive(m, y) - m / y))
            Mt[2, 3, :] = -nu[i + 1, :]**2 * b[i] / mur[i + 1, :] * (
                mur[i + 1, :] / nu[i + 1, :] *
                (-_scyspe.kve(m - 1, x) / _scyspe.kve(m, x) - m / x) -
                mur[i, :] / nu[i, :] *
                (-_scyspe.kve(m - 1, y) / _scyspe.kve(m, y) - m / y))
            Mt[3, 2, :] = -nu[i + 1, :]**2 * b[i] / mur[i + 1, :] * (
                mur[i + 1, :] / nu[i + 1, :] *
                (_scyspe.ive(m - 1, x) / _scyspe.ive(m, x) - m / x) -
                mur[i, :] / nu[i, :] *
                (_scyspe.ive(m - 1, y) / _scyspe.ive(m, y) - m / y))
            Mt[3, 3, :] = -nu[i + 1, :]**2 * b[i] / mur[i + 1, :] * (
                mur[i + 1, :] / nu[i + 1, :] *
                (_scyspe.ive(m - 1, x) / _scyspe.ive(m, x) - m / x) -
                mur[i, :] / nu[i, :] *
                (-_scyspe.kve(m - 1, y) / _scyspe.kve(m, y) - m / y))
            Mt[2, 0, :] = (nu[i + 1, :]**2 / nu[i, :]**2 -
                           1) * m / (bet * mur[i + 1, :])
            Mt[2, 1, :] = Mt[2, 0, :]
            Mt[3, 0, :] = Mt[2, 0, :]
            Mt[3, 1, :] = Mt[2, 0, :]

            if len(b) == 1:
                M = Mt
            else:
                if (i == 0):
                    M = produto(D, Mt)
                elif i < len(b) - 1:
                    M = produto(D, produto(Mt, M))
                else:
                    M = produto(Mt, M)
        return M
def k1e(x):
    if np.iscomplexobj(x):
        return special.kve(1,x)
    else:
        return special.k1e(x)
def k0e(x):
    if np.iscomplexobj(x):
        return special.kve(0,x)
    else:
        return special.k0e(x)