Пример #1
0
def test_chebyshev1_mpmath():
    scheme = quadpy.line_segment.ChebyshevGauss1(4, mode="mpmath", decimal_places=50)
    tol = 1.0e-50

    x1 = mp.cos(3 * mp.pi / 8)
    x2 = mp.cos(1 * mp.pi / 8)
    assert (abs(scheme.points - [-x2, -x1, +x1, +x2]) < tol).all()

    w = mp.pi / 4
    tol = 1.0e-49
    assert (abs(scheme.weights - [w, w, w, w]) < tol).all()
    return
Пример #2
0
def test_chebyshev1_mpmath():
    mp.dps = 50
    scheme = quadpy.c1.chebyshev_gauss_1(4, mode="mpmath")
    tol = 1.0e-50

    x1 = mp.cos(3 * mp.pi / 8)
    x2 = mp.cos(1 * mp.pi / 8)
    assert (abs(scheme.points_symbolic - [+x2, +x1, -x1, -x2]) < tol).all()

    w = mp.pi / 4
    tol = 1.0e-49
    assert (abs(scheme.weights_symbolic - [w, w, w, w]) < tol).all()
Пример #3
0
def test_chebyshev2_mpmath():
    scheme = quadpy.line_segment.ChebyshevGauss2(4, mode="mpmath", decimal_places=51)

    tol = 1.0e-50

    x1 = mp.cos(2 * mp.pi / 5)
    x2 = mp.cos(1 * mp.pi / 5)
    assert (abs(scheme.points - [-x2, -x1, +x1, +x2]) < tol).all()

    w1 = mp.pi / 5 * mp.sin(2 * mp.pi / 5) ** 2
    w2 = mp.pi / 5 * mp.sin(1 * mp.pi / 5) ** 2
    assert (abs(scheme.weights - [w2, w1, w1, w2]) < tol).all()
    return
Пример #4
0
def test_chebyshev2_mpmath():
    mp.dps = 51
    scheme = quadpy.c1.chebyshev_gauss_2(4, mode="mpmath")

    tol = 1.0e-50

    x1 = mp.cos(2 * mp.pi / 5)
    x2 = mp.cos(1 * mp.pi / 5)
    assert (abs(scheme.points_symbolic - [+x2, +x1, -x1, -x2]) < tol).all()

    w1 = mp.pi / 5 * mp.sin(2 * mp.pi / 5)**2
    w2 = mp.pi / 5 * mp.sin(1 * mp.pi / 5)**2
    assert (abs(scheme.weights_symbolic - [w2, w1, w1, w2]) < tol).all()
Пример #5
0
 def ddTk(x):
     with mp.extradps(extradps):
         x = clip(x, -1.0, 1.0)
         if mp.almosteq(x, mp.one): return pos
         if mp.almosteq(x, -mp.one): return neg
         moredps = max(
             0,
             int(-math.log10(
                 min(abs(x - mp.one), abs(x + mp.one))) * 1.5) +
             2)
         moredps = min(moredps, 100)
         with mp.extradps(moredps):
             t = mp.acos(x)
             s = mp.sin(t)
             return -k**2 * mp.cos(k * t) / s**2 + k * mp.cos(
                 t) * mp.sin(k * t) / s**3
Пример #6
0
def chebyshev_gauss_2(n, mode="numpy", decimal_places=None):
    """Chebyshev-Gauss quadrature for \\int_{-1}^1 f(x) * sqrt(1+x^2) dx."""
    degree = n if n % 2 == 1 else n + 1

    # TODO make explicit for all modes
    if mode == "numpy":
        points = numpy.cos(numpy.pi * numpy.arange(1, n + 1) / (n + 1))
        weights = (
            numpy.pi
            / (n + 1)
            * (numpy.sin(numpy.pi * numpy.arange(1, n + 1) / (n + 1))) ** 2
        )
    elif mode == "sympy":
        points = numpy.array(
            [sympy.cos(sympy.Rational(k, n + 1) * sympy.pi) for k in range(1, n + 1)]
        )
        weights = numpy.array(
            [
                sympy.pi / (n + 1) * sympy.sin(sympy.pi * sympy.Rational(k, n + 1)) ** 2
                for k in range(1, n + 1)
            ]
        )
    else:
        assert mode == "mpmath"
        points = numpy.array(
            [mp.cos(mp.mpf(k) / (n + 1) * mp.pi) for k in range(1, n + 1)]
        )
        weights = numpy.array(
            [
                mp.pi / (n + 1) * mp.sin(mp.pi * mp.mpf(k) / (n + 1)) ** 2
                for k in range(1, n + 1)
            ]
        )
    return C1Scheme("Chebyshev-Gauss 2", degree, weights, points)
Пример #7
0
 def two_body_reference(self, t1, num_1 = 0, num_2 = 1):
     """ reference notations are same as Yoel's notes
     using a precision of 64 digits for max accuracy """
     mp.dps = 64
     self.load_data()
     t1 = mp.mpf(t1)
     m_1 = mp.mpf(self.planet_lst[num_1].mass)
     m_2 = mp.mpf(self.planet_lst[num_2].mass)
     x1_0 = mp.matrix(self.planet_lst[num_1].loc)
     x2_0 = mp.matrix(self.planet_lst[num_2].loc)
     v1_0 = mp.matrix(self.planet_lst[num_1].v)
     v2_0 = mp.matrix(self.planet_lst[num_2].v)
     M = m_1 + m_2
     x_cm = (1/M)*((m_1*x1_0)+(m_2*x2_0))
     v_cm = (1/M)*((m_1*v1_0)+(m_2*v2_0))
     u1_0 = v1_0 - v_cm
     w = x1_0 - x_cm
     r_0 = mp.norm(w)
     alpha = mp.acos((np.inner(u1_0,w))/(mp.norm(u1_0)*mp.norm(w)))
     K = mp.mpf(self.G) * (m_2**3)/(M**2)
     u1_0 = mp.norm(u1_0)
     L = r_0 * u1_0 * mp.sin(alpha)
     cosgamma = ((L**2)/(K*r_0)) - 1
     singamma = -((L*u1_0*mp.cos(alpha))/K)
     gamma = mp.atan2(singamma, cosgamma)
     e = mp.sqrt(((r_0*(u1_0**2)*(mp.sin(alpha)**2)/K)-1)**2 + \
              (((r_0**2)*(u1_0**4)*(mp.sin(alpha)**2)*(mp.cos(alpha)**2))/(K**2)) )        
     r_theta = lambda theta: (L**2)/(K*(1+(e*mp.cos(theta - gamma))))
     f = lambda x: r_theta(x)**2/L
     curr_theta = 0
     max_it = 30
     it = 1
     converged = 0
     while ((it < max_it) & (converged != 1)):
         t_val = mp.quad(f,[0,curr_theta]) - t1
         dt_val = f(curr_theta)
         delta = t_val/dt_val
         if (abs(delta)<1.0e-6):
             converged = 1
         curr_theta -= delta
         it += 1 
     x1_new = mp.matrix([r_theta(curr_theta)*mp.cos(curr_theta), r_theta(curr_theta)*mp.sin(curr_theta)]) 
     # x2_new = -(m_1/m_2)*(x1_new) +(x_cm + v_cm*t1)
     x1_new = x1_new + (x_cm + v_cm*t1)
     return x1_new
Пример #8
0
def RSZ_plain(x):
    x = mp.mpf(x.real)
    tau = mp.sqrt(x / (2 * mp.pi()))
    N = int(tau.real)
    z = 2 * (x - N) - 1
    running_sum = 0
    for n in range(1, N + 1):
        running_sum += mp.cos(RStheta(x) - (x * mp.log(n))) / mp.sqrt(n)
    return (2 * running_sum).real
Пример #9
0
def RSZ_upto_c1(x):
    x = mp.mpf(x.real)
    tau = mp.sqrt(x/(2*PI))
    N = int(tau.real)
    p = tau-N
    running_sum=0
    for n in range(1,N+1):
        running_sum += mp.cos(RStheta(x) - x*mp.log(n))/mp.sqrt(n)
    return (2*running_sum + mp.power(-1,N-1)*mp.power(tau,-0.5)*(c0(p) - (1/tau)*c1(p))).real
Пример #10
0
def Ht_complex_integrand(u, z, t):
    """
    Computes the integrand of H_t(u) in Terry' blog at
    https://terrytao.wordpress.com/2018/02/02/polymath15-second-thread-generalising-the-riemann-siegel-approximate-functional-equation/
    :param u: integration parameter
    :param z: point at which H_t is computed
    :param t: the "time" parameter
    :return: integrand of H_t(z)
    """
    u, z, t = mp.mpc(u), mp.mpc(z), mp.mpc(t)
    return mp.exp(t * u * u) * phi_decay(u) * mp.cos(z * u)
Пример #11
0
def Construct_Dp(Phi, Psi, Omega, tt):

    Cos = mp.matrix([[
        mp.cos(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])
    Sin = mp.matrix([[
        mp.sin(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])

    OmegaCosSin = Cos * Omega * Sin

    Dp = -Phi * (OmegaCosSin.T - OmegaCosSin) * Phi.T
    return (Dp)
Пример #12
0
def Construct_Dm(Phi, Psi, Omega, tt):

    Cos = mp.matrix([[
        mp.cos(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])
    Sin = mp.matrix([[
        mp.sin(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])

    OmegaSinCos = Sin * Omega * Cos

    Dm = -Psi * (OmegaSinCos - OmegaSinCos.T) * Psi.T
    return (Dm)
Пример #13
0
def f02(y, n, R, rh, l, pm1, Om, lam, sig):
    K = lam**2 * sig / 2 / fp.sqrt(2 * fp.pi)
    a = (R**2 - rh**2) * l**2 / 4 / sig**2 / rh**2
    b = fp.sqrt(R**2 - rh**2) * Om * l / rh
    Zp = mp.mpf((R**2 + rh**2) / (R**2 - rh**2))
    if Zp - mp.cosh(y) > 0:
        return fp.mpf(K * mp.exp(-a * y**2) * mp.cos(b * y) /
                      mp.sqrt(Zp - mp.cosh(y)))
    elif Zp - mp.cosh(y) < 0:
        return fp.mpf(-K * mp.exp(-a * y**2) * mp.sin(b * y) /
                      mp.sqrt(mp.cosh(y) - Zp))
    else:
        return 0
Пример #14
0
def fn1(y, n, R, rh, l, pm1, Om, lam, sig):
    K = lam**2 * sig / 2 / fp.sqrt(2 * fp.pi)
    a = (R**2 - rh**2) * l**2 / 4 / sig**2 / rh**2
    b = fp.sqrt(R**2 - rh**2) * Om * l / rh
    Zm = mp.mpf(rh**2 / (R**2 - rh**2) *
                (R**2 / rh**2 * fp.cosh(2 * fp.pi * rh / l * n) - 1))
    if Zm == mp.cosh(y):
        return 0
    elif Zm - fp.cosh(y) > 0:
        return fp.mpf(K * mp.exp(-a * y**2) * mp.cos(b * y) /
                      mp.sqrt(Zm - mp.cosh(y)))
    else:
        return fp.mpf(-K * mp.exp(-a * y**2) * mp.sin(b * y) /
                      mp.sqrt(mp.cosh(y) - Zm))
Пример #15
0
def Construct_K(Phi, Psi, Omega, tt):

    Cos = mp.matrix([[
        mp.cos(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])
    Sin = mp.matrix([[
        mp.sin(eigvalst[i] * tt) if i == j else mp.mpf(0.0) for j in range(L)
    ] for i in range(L)])

    OmegaCos = Cos * Omega * Cos
    OmegaSin = Sin * Omega * Sin

    Kmatrix = -Phi * (OmegaCos + OmegaSin.T) * Psi.T
    return (Kmatrix)
Пример #16
0
 def __init__(self, domain=None, name='sin^2'):
     super(SinSquaredExpression,
           self).__init__(mp_terms=[
               lambda x: mp.sin(x)**2, lambda x: mp.sin(2 * x),
               lambda x: 2 * mp.cos(2 * x)
           ],
                          fp_terms=[
                              lambda x: math.sin(x)**2,
                              lambda x: math.sin(2 * x),
                              lambda x: 2 * math.cos(2 * x)
                          ],
                          desc="sin^2(x)",
                          domain=domain,
                          name=name)
Пример #17
0
 def __init__(self, side, extended, distance):
     self.distance = mp.mpf(distance)
     rightPointX = mp.mpf('1.41949302') if extended else mp.sqrt(2)
     self.side = side  # side length of square
     self.d = side / mp.cos(mp.pi / 12)  # length of left edge
     sin60 = mp.sqrt(3) / 2
     self.top = matrix([self.d / 2, sin60 * self.d])
     self.right = matrix([side * rightPointX, 0])
     self.nleft = matrix([[-sin60, 0.5]])
     self.ndown = matrix([[0, -1]])
     v = self.right - self.top
     norm = mp.norm(v)
     self.nright = matrix([[-v[1] / norm, v[0] / norm]])
     self.offset = self.nright * self.right
Пример #18
0
 def verify(self, x0, x1, y0, y1, s, t, x, y):
     "Verify the transformation given by (s, t, x, y) on pentagon."
     pentagon = [(x0, 0), (x1, 0), (0, y0), (0, y1), (self.side, self.side)]
     # reference point in interior of pentagon
     ref = matrix([x0 + x1 + self.side, y0 + y1 + self.side]) / 5
     translation = matrix(
         [s * ref[0] + t * ref[1] + x, -t * ref[0] + s * ref[1] + y])
     # reconstruct rotation angle
     norm = mp.sqrt(s * s + t * t)
     if t < 0:
         angle = -mp.acos(s / norm)
     else:
         angle = mp.acos(s / norm)
     rotation = matrix([[mp.cos(angle), mp.sin(angle)],
                        [-mp.sin(angle), mp.cos(angle)]])
     pentagon = list(map(lambda pt: matrix(pt), pentagon))
     ipentagon = list(
         map(lambda pt: rotation * (pt - ref) + translation, pentagon))
     # Verify that ipentagon is a congruent image of pentagon
     eps = mp.mpf(10)**-(mp.dps - 2)  # accept error in last two digits
     for i in range(5):
         for j in range(i + 1, 5):
             d1 = mp.norm(pentagon[j] - pentagon[i])
             d2 = mp.norm(ipentagon[j] - ipentagon[i])
             dd = abs(d1 - d2)
             assert dd < eps, (pentagon, dd, eps)
     dists = []
     for p in ipentagon:
         dists.append(self.nleft * p)
         dists.append(self.ndown * p)
         dists.append(self.nright * p - self.offset)
     dist = max(map(lambda m: m[0], dists))
     if dist > -self.distance:
         sys.stderr.write("Pentagon failing slack test: %d %d %d %d\n" %
                          (x0, x1, y0, y1))
         return False
     return True
Пример #19
0
def mp_cyl(x):
    f = mp.mpf
    theta = f(THETA) * mp.pi / f(180)
    qr = x * f(RADIUS) * mp.sin(theta)
    qh = x * f(LENGTH) / f(2) * mp.cos(theta)
    be = f(2) * mp.j1(qr) / qr
    si = mp.sin(qh) / qh
    background = f(0)
    #background = f(1)/f(1000)
    volume = mp.pi * f(RADIUS)**f(2) * f(LENGTH)
    contrast = f(5)
    units = f(1) / f(10000)
    #return be
    #return si
    return units * (volume * contrast * be * si)**f(2) / volume + background
Пример #20
0
def chebyshev_gauss_1(n, mode="numpy"):
    """Chebyshev-Gauss quadrature for \\int_{-1}^1 f(x) / sqrt(1+x^2) dx."""
    degree = n if n % 2 == 1 else n + 1

    if mode == "numpy":
        points = np.cos((2 * np.arange(1, n + 1) - 1) / (2 * n) * np.pi)
        weights = np.full(n, np.pi / n)
    elif mode == "sympy":
        points = np.array([
            sympy.cos(sympy.Rational(2 * k - 1, 2 * n) * sympy.pi)
            for k in range(1, n + 1)
        ])
        weights = np.full(n, sympy.pi / n)
    else:
        assert mode == "mpmath"
        points = np.array([
            mp.cos(mp.mpf(2 * k - 1) / (2 * n) * mp.pi)
            for k in range(1, n + 1)
        ])
        weights = np.full(n, mp.pi / n)
    return C1Scheme("Chebyshev-Gauss 1", degree, weights, points)
Пример #21
0
def createP_pi(lx, ly):
    fle = fl(lx, ly, 0)
    phi_l = -mp.atan(mp.im(fle) / mp.re(fle))

    f = lambda kx, ky, kz: (1 + 1 / (3**(1 / 2)) * mp.exp(1j * phi_l) * fl(
        lx + kx / ct.hbar, ly + ky / ct.hbar, kz / ct.hbar)) * w2pz(
            kx, ky, kz)

    #analytical
    #differential vectors, not used in nearest neighbor approximation
    R_12 = [R_1[0] - R_2[0], R_1[1] - R_2[1], R_1[2] - R_2[2]]
    R_23 = [R_2[0] - R_3[0], R_2[1] - R_3[1], R_2[2] - R_3[2]]
    R_31 = [R_3[0] - R_1[0], R_3[1] - R_1[1], R_3[2] - R_1[2]]

    nrm = mp.sqrt(1 / (
        2 + 2 * s / (3**(1 / 2)) *
        (mp.cos(phi_l + mp.fdot([lx, ly, 0], R_1)) +
         mp.cos(phi_l + mp.fdot([lx, ly, 0], R_2)) +
         mp.cos(phi_l + mp.fdot([lx, ly, 0], R_3))) + 2 * s2 *
        (mp.cos(mp.fdot([lx, ly, 0], R_12)) + mp.cos(mp.fdot(
            [lx, ly, 0], R_23)) + mp.cos(mp.fdot([lx, ly, 0], R_31)))))

    return lambda kx, ky, kz: f(kx, ky, kz) * nrm
Пример #22
0
def f1(x):
    return mp.cos(x) * mp.cosh(x) - 1
Пример #23
0
from mpmath import mp
mp.dps = 50
    
N = long(sys.argv[1]) if len(sys.argv) > 1 else 1000000

inicio = -1*mp.pi
fim = 1*mp.pi
dx = (fim-inicio)/(N-1)

Idx = mp.mpf(1/dx)

with open('Cosseno.h', 'w') as f:

    f.write("\n".join([
        'using namespace std;',
        '',
        '#define COS_N {N}',
        '#define COS_inicio {inicio}',
        '#define COS_fim {fim}',
        '',
        '',
    ]).format(**locals()))

    f.write('const double Cosseno[] = {')

    for i in range(N):
        value = mp.cos(i*dx + inicio)
        v = "%.50e" % value
        f.write( v + ' ,\n')

    f.write('\n};')
Пример #24
0
def cosd(x):
    try:
        return mp.cos(x * mp.pi / 180)
    except:
        return math.cos(x * math.pi / 180)
Пример #25
0
 def __init__(self, npts):
     # Only points
     self.points = [mp.cos((i - 1)*mp.pi/(npts - 1))
                    for i in xrange(npts, 0, -1)]
Пример #26
0
def c0(p):
    return mp.cos(2 * mp.pi() *
                  (p * p - p - 1 / 16.0)) / mp.cos(2 * mp.pi() * p)
Пример #27
0
def psi(p):
    term1 = 2 * mp.pi()
    term2 = mp.cos(mp.pi() * (p * p / 2 - p - 1 / 8.0))
    term3 = mp.exp(0.5j * mp.pi() * p * p - 5j * mp.pi() / 8.0)
    term4 = mp.cos(mp.pi() * p)
    return term1 * term2 * term3 / term4
Пример #28
0
from mpmath import mp
mp.dps = 50  # dokładność
print(
    mp.quad(lambda x: (mp.cos(x) - mp.exp(x)) * mp.csc(x),
            [-0.9999999999999999, 1]))
#Zakres nie zaczyna się od -1 ponieważ wartość funkcji w tym punkcie jest bardzo bliska 0 i program sie wypisuje
#Natomiast zastępując liczbe -1 bardzo bliską -1 otrzymujemy wynik bardzo poprawny z dokładnościa większa niz 10 cyfr
Пример #29
0
import sys

from mpmath import mp
mp.dps = 50
    
N = long(sys.argv[1]) if len(sys.argv) > 1 else 20000

inicio = -1*mp.pi
fim = 1*mp.pi
dx = (fim-inicio)/(N-1)
idx = 1 / dx

Idx = mp.mpf(1/dx)

with open('Cos.h', 'w') as f:

    f.write("\n".join([
        '#define COS_N {N}',
        '#define COS_Idx {idx}',
        '#define COS_inicio {inicio}',
        '#define COS_fim {fim}',
        '',
        '',
    ]).format(**locals()))

    f.write('const double Cos[] = {')

    for i in range(N):
        f.write('' + str(mp.cos(i*dx + inicio)) + ',\n')

    f.write('\n};')
Пример #30
0
    def dR(self, lx, ly, kr, kt, kp, qmin, qmax, band, fdm, local_mchi):
        if band == "pi":
            if not self.lastlx == lx or not self.lastly == ly:
                self.P_pi = createP_pi(lx, ly)
                self.lastlx = lx
                self.lastly = ly
                self.E_b = E_pi_minus(lx, ly)

            sqP = lambda qr, qt, qp: mp.re(
                self.P_pi(
                    qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp.cos(kp
                                                                            ),
                    qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(kt) * mp.sin(kp
                                                                            ),
                    qr * mp.cos(qt) - kr * mp.cos(kt)))**2 + mp.im(
                        self.P_pi(
                            qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp
                            .cos(kp),
                            qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(
                                kt) * mp.sin(kp),
                            qr * mp.cos(qt) - kr * mp.cos(kt)))**2
        else:
            if not self.lastlx == lx or not self.lastly == ly:
                self.P_sigma = createP_sigma(lx, ly, band)
                self.lastlx = lx
                self.lastly = ly
                self.E_b = E_sigma(lx, ly, band)

            sqP = lambda qr, qt, qp: mp.re(
                self.P_sigma(
                    qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp.cos(kp
                                                                            ),
                    qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(kt) * mp.sin(kp
                                                                            ),
                    qr * mp.cos(qt) - kr * mp.cos(kt)))**2 + mp.im(
                        self.P_sigma(
                            qr * mp.sin(qt) * mp.cos(qp) - kr * mp.sin(kt) * mp
                            .cos(kp),
                            qr * mp.sin(qt) * mp.sin(qp) - kr * mp.sin(
                                kt) * mp.sin(kp),
                            qr * mp.cos(qt) - kr * mp.cos(kt)))**2

        integrand = lambda qr, qt, qp: (qr) * mp.sin(qt) / (
            4 * mp.pi) * self.eta(qr, kr, self.E_b, local_mchi) * F_DM(
                qr, fdm) * sqP(qr, qt, qp)

        result = mint.integrate(integrand, [qmin, qmax], [0, mp.pi],
                                [0, 2 * mp.pi], self.method)
        return result
Пример #31
0
def df1(x):
    return mp.cos(x) * mp.sinh(x) - mp.sin(x) * mp.cosh(x)
Пример #32
0
def f3(x):
    return 2**(-x) + mp.e**x + 2 * mp.cos(x) - 6
Пример #33
0
def cosd(x):
    try:
        return mp.cos(x * mp.pi / 180)
    except:
        return math.cos(x * math.pi / 180)
Пример #34
0
add_function(
    name="expm1(x)",
    mp_function=mp.expm1,
    np_function=np.expm1,
    ocl_function=make_ocl("return expm1(q);", "sas_expm1"),
    limits=(-5., 5.),
)
add_function(
    name="arctan(x)",
    mp_function=mp.atan,
    np_function=np.arctan,
    ocl_function=make_ocl("return atan(q);", "sas_arctan"),
)
add_function(
    name="3 j1(x)/x",
    mp_function=lambda x: 3 * (mp.sin(x) / x - mp.cos(x)) / (x * x),
    # Note: no taylor expansion near 0
    np_function=lambda x: 3 * (np.sin(x) / x - np.cos(x)) / (x * x),
    ocl_function=make_ocl("return sas_3j1x_x(q);", "sas_j1c",
                          ["lib/sas_3j1x_x.c"]),
)
add_function(
    name="(1-cos(x))/x^2",
    mp_function=lambda x: (1 - mp.cos(x)) / (x * x),
    np_function=lambda x: (1 - np.cos(x)) / (x * x),
    ocl_function=make_ocl("return (1-cos(q))/q/q;", "sas_1mcosx_x2"),
)
add_function(
    name="(1-sin(x)/x)/x",
    mp_function=lambda x: 1 / x - mp.sin(x) / (x * x),
    np_function=lambda x: 1 / x - np.sin(x) / (x * x),