def jacobi_elliptic_cn(u, m, verbose=False): """ Implements the jacobi elliptic cn function, using the expansion in terms of q, from Abramowitz 16.23.2. """ u = convert_lossless(u) m = convert_lossless(m) if verbose: print >> sys.stderr, '\nelliptic.jacobi_elliptic_cn' print >> sys.stderr, '\tu: %1.12f' % u print >> sys.stderr, '\tm: %1.12f' % m zero = mpf('0') onehalf = mpf('0.5') one = mpf('1') two = mpf('2') if m == zero: # cn collapses to cos(u) if verbose: print >> sys.stderr, 'cn: special case, m == 0' return cos(u) elif m == one: # cn collapses to sech(u) if verbose: print >> sys.stderr, 'cn: special case, m == 1' return sech(u) else: k = sqrt(m) # convert m to k q = calculate_nome(k) kprimesquared = one - k**2 kprime = sqrt(kprimesquared) v = (pi * u) / (two*ellipk(k**2)) sum = zero term = zero # series starts at zero if verbose: print >> sys.stderr, 'elliptic.jacobi_elliptic_cn: calculating' while True: factor1 = (q**(term + onehalf)) / (one + q**(two*term + one)) factor2 = cos((two*term + one)*v) term_n = factor1*factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if not factor2 == zero: #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + one answer = (two*pi) / (sqrt(m) * ellipk(k**2)) * sum return answer
def jacobi_elliptic_cn(u, m, verbose=False): """ Implements the jacobi elliptic cn function, using the expansion in terms of q, from Abramowitz 16.23.2. """ u = convert_lossless(u) m = convert_lossless(m) if verbose: print >> sys.stderr, '\nelliptic.jacobi_elliptic_cn' print >> sys.stderr, '\tu: %1.12f' % u print >> sys.stderr, '\tm: %1.12f' % m zero = mpf('0') onehalf = mpf('0.5') one = mpf('1') two = mpf('2') if m == zero: # cn collapses to cos(u) if verbose: print >> sys.stderr, 'cn: special case, m == 0' return cos(u) elif m == one: # cn collapses to sech(u) if verbose: print >> sys.stderr, 'cn: special case, m == 1' return sech(u) else: k = sqrt(m) # convert m to k q = calculate_nome(k) kprimesquared = one - k**2 kprime = sqrt(kprimesquared) v = (pi * u) / (two * ellipk(k**2)) sum = zero term = zero # series starts at zero if verbose: print >> sys.stderr, 'elliptic.jacobi_elliptic_cn: calculating' while True: factor1 = (q**(term + onehalf)) / (one + q**(two * term + one)) factor2 = cos((two * term + one) * v) term_n = factor1 * factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if not factor2 == zero: #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + one answer = (two * pi) / (sqrt(m) * ellipk(k**2)) * sum return answer
def chebcoeff(f,a,b,j,N): s = mpf(0) h = mpf(0.5) for k in range(1, N+1): t = cos(pi*(k-h)/N) s += f(t*(b-a)*h + (b+a)*h) * cos(pi*j*(k-h)/N) return 2*s/N
def jacobi_theta_3(z, m): """ Implements the jacobi theta function 2, using the series expansion found in Abramowitz & Stegun [4]. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if abs(q) >= mpf('1'): raise ValueError delta_sum = 1 term = 1 # series starts at 1 zero = mpf('0') sum = zero if z == zero: factor2 = mpf('1') while True: factor1 = q**(term*term) term_n = factor1 # suboptimal, kept for readability sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: factor1 = q**(term*term) if z == zero: factor2 = 1 else: factor2 = cos(2*term*z) term_n = factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break if factor2 != mpf('0'): # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return 1 + 2*sum
def jacobi_theta_3(z, m): """ Implements the jacobi theta function 2, using the series expansion found in Abramowitz & Stegun [4]. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if abs(q) >= mpf('1'): raise ValueError delta_sum = 1 term = 1 # series starts at 1 zero = mpf('0') sum = zero if z == zero: factor2 = mpf('1') while True: factor1 = q**(term * term) term_n = factor1 # suboptimal, kept for readability sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: factor1 = q**(term * term) if z == zero: factor2 = 1 else: factor2 = cos(2 * term * z) term_n = factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break if factor2 != mpf('0'): # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return 1 + 2 * sum
def chebyfit(f, interval, N, error=False): """ Chebyshev approximation: returns coefficients of a degree N-1 polynomial that approximates f on the interval [a, b]. With error=True, also returns an estimate of the maximum error. """ a, b = AS_POINTS(interval) orig = mp.prec try: mp.prec = orig + int(N**0.5) + 20 c = [chebcoeff(f,a,b,k,N) for k in range(N)] d = [mpf(0)] * N d[0] = -c[0]/2 h = mpf(0.5) T = chebT(mpf(2)/(b-a), mpf(-1)*(b+a)/(b-a)) for k in range(N): Tk = T.next() for i in range(len(Tk)): d[i] += c[k]*Tk[i] d = d[::-1] # Estimate maximum error err = mpf(0) for k in range(N): x = cos(pi*k/N) * (b-a)*h + (b+a)*h err = max(err, abs(f(x) - polyval(d, x))) finally: mp.prec = orig if error: return d, +err else: return d
def jacobi_elliptic_dn(u, m, verbose=False): """ Implements the jacobi elliptic cn function, using the expansion in terms of q, from Abramowitz 16.23.3. """ u = convert_lossless(u) m = convert_lossless(m) if verbose: print >> sys.stderr, '\nelliptic.jacobi_elliptic_dn' print >> sys.stderr, '\tu: %1.12f' % u print >> sys.stderr, '\tm: %1.12f' % m zero = mpf('0') onehalf = mpf('0.5') one = mpf('1') two = mpf('2') if m == zero: # dn collapes to 1 return one elif m == one: # dn collapses to sech(u) return sech(u) else: k = sqrt(m) # convert m to k q = calculate_nome(k) v = (pi * u) / (two*ellipk(k**2)) sum = zero term = one # series starts at one if verbose: print >> sys.stderr, 'elliptic.jacobi_elliptic_dn: calculating' while True: factor1 = (q**term) / (one + q**(two*term)) factor2 = cos(two*term*v) term_n = factor1*factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if not factor2 == zero: #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + one K = ellipk(k**2) answer = (pi / (two*K)) + (two*pi*sum)/(ellipk(k**2)) return answer
def jacobi_elliptic_dn(u, m, verbose=False): """ Implements the jacobi elliptic cn function, using the expansion in terms of q, from Abramowitz 16.23.3. """ u = convert_lossless(u) m = convert_lossless(m) if verbose: print >> sys.stderr, '\nelliptic.jacobi_elliptic_dn' print >> sys.stderr, '\tu: %1.12f' % u print >> sys.stderr, '\tm: %1.12f' % m zero = mpf('0') onehalf = mpf('0.5') one = mpf('1') two = mpf('2') if m == zero: # dn collapes to 1 return one elif m == one: # dn collapses to sech(u) return sech(u) else: k = sqrt(m) # convert m to k q = calculate_nome(k) v = (pi * u) / (two * ellipk(k**2)) sum = zero term = one # series starts at one if verbose: print >> sys.stderr, 'elliptic.jacobi_elliptic_dn: calculating' while True: factor1 = (q**term) / (one + q**(two * term)) factor2 = cos(two * term * v) term_n = factor1 * factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if not factor2 == zero: #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + one K = ellipk(k**2) answer = (pi / (two * K)) + (two * pi * sum) / (ellipk(k**2)) return answer
def main(): """ main program """ #Collect user input F1 = float( input("What is the magnitude of the first force (in Newtons)? ")) theta1 = float(input("What is the angle of the first force (in deg)? ")) F2 = float( input("What is the magnitude of the second force (in Newtons)? ")) theta2 = float(input("What is the angle of the second force (in deg)?")) #Convert to radians theta1_rad = functions.deg2rad(theta1) theta2_rad = functions.deg2rad(theta2) #x and y components of Fsum F3x = F1 * functions.cos(theta1_rad) + F2 * functions.cos(theta2_rad) F3y = F1 * functions.sin(theta1_rad) + F2 * functions.sin(theta2_rad) print("Net force is: ", F3x, F3y)
def jcn(u, m): """ Computes of the Jacobi elliptic cn function in terms of Jacobi theta functions. `u` is any complex number, `m` must be in the unit disk The cn-function is doubly periodic in the complex plane with periods `4 K(m)` and `4 i K(1-m)` (see :func:`ellipk`):: >>> from mpmath import * >>> mp.dps = 25 >>> print jcn(2, 0.25) -0.2698649654510865792581416 >>> print jcn(2+4*ellipk(0.25), 0.25) -0.2698649654510865792581416 >>> print chop(jcn(2+4*j*ellipk(1-0.25), 0.25)) -0.2698649654510865792581416 """ if abs(m) < eps: return cos(u) elif m == one: return sech(u) else: extra = 10 try: mp.prec += extra q = calculate_nome(sqrt(m)) v3 = jtheta(3, zero, q) v2 = jtheta(2, zero, q) v04 = jtheta(4, zero, q) arg1 = u / (v3*v3) v1 = jtheta(2, arg1, q) v4 = jtheta(4, arg1, q) cn = (v04/v2)*(v1/v4) finally: mp.prec -= extra return cn
def _djacobi_theta2(z, q, nd): MIN = 2 extra1 = 10 extra2 = 20 if isinstance(q, mpf) and isinstance(z, mpf): wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) x2 = (x*x) >> wp a = b = x2 c1, s1 = cos_sin(z._mpf_, wp) cn = c1 = to_fixed(c1, wp) sn = s1 = to_fixed(s1, wp) c2 = (c1*c1 - s1*s1) >> wp s2 = (c1 * s1) >> (wp - 1) cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp if (nd&1): s = s1 + ((a * sn * 3**nd) >> wp) else: s = c1 + ((a * cn * 3**nd) >> wp) n = 2 while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp if nd&1: s += (a * sn * (2*n+1)**nd) >> wp else: s += (a * cn * (2*n+1)**nd) >> wp n += 1 s = -(s << 1) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) # case z real, q complex elif isinstance(z, mpf): wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = x2re aim = bim = x2im c1, s1 = cos_sin(z._mpf_, wp) cn = c1 = to_fixed(c1, wp) sn = s1 = to_fixed(s1, wp) c2 = (c1*c1 - s1*s1) >> wp s2 = (c1 * s1) >> (wp - 1) cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp if (nd&1): sre = s1 + ((are * sn * 3**nd) >> wp) sim = ((aim * sn * 3**nd) >> wp) else: sre = c1 + ((are * cn * 3**nd) >> wp) sim = ((aim * cn * 3**nd) >> wp) n = 5 while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp if (nd&1): sre += ((are * sn * n**nd) >> wp) sim += ((aim * sn * n**nd) >> wp) else: sre += ((are * cn * n**nd) >> wp) sim += ((aim * cn * n**nd) >> wp) n += 2 sre = -(sre << 1) sim = -(sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) #case z complex, q real elif isinstance(q, mpf): wp = mp.prec + extra2 x = to_fixed(q._mpf_, wp) x2 = (x*x) >> wp a = b = x2 prec0 = mp.prec mp.prec = wp c1 = cos(z) s1 = sin(z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) #c2 = (c1*c1 - s1*s1) >> wp c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp c2im = (c1re*c1im - s1re*s1im) >> (wp - 1) #s2 = (c1 * s1) >> (wp - 1) s2re = (c1re*s1re - c1im*s1im) >> (wp - 1) s2im = (c1re*s1im + c1im*s1re) >> (wp - 1) #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if (nd&1): sre = s1re + ((a * snre * 3**nd) >> wp) sim = s1im + ((a * snim * 3**nd) >> wp) else: sre = c1re + ((a * cnre * 3**nd) >> wp) sim = c1im + ((a * cnim * 3**nd) >> wp) n = 5 while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if (nd&1): sre += ((a * snre * n**nd) >> wp) sim += ((a * snim * n**nd) >> wp) else: sre += ((a * cnre * n**nd) >> wp) sim += ((a * cnim * n**nd) >> wp) n += 2 sre = -(sre << 1) sim = -(sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) # case z and q complex else: wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = x2re aim = bim = x2im prec0 = mp.prec mp.prec = wp # cos(2*z), siz(2*z) with z complex c1 = cos(z) s1 = sin(z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp c2im = (c1re*c1im - s1re*s1im) >> (wp - 1) s2re = (c1re*s1re - c1im*s1im) >> (wp - 1) s2im = (c1re*s1im + c1im*s1re) >> (wp - 1) t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if (nd&1): sre = s1re + (((are * snre - aim * snim) * 3**nd) >> wp) sim = s1im + (((are * snim + aim * snre)* 3**nd) >> wp) else: sre = c1re + (((are * cnre - aim * cnim) * 3**nd) >> wp) sim = c1im + (((are * cnim + aim * cnre)* 3**nd) >> wp) n = 5 while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if (nd&1): sre += (((are * snre - aim * snim) * n**nd) >> wp) sim += (((aim * snre + are * snim) * n**nd) >> wp) else: sre += (((are * cnre - aim * cnim) * n**nd) >> wp) sim += (((aim * cnre + are * cnim) * n**nd) >> wp) n += 2 sre = -(sre << 1) sim = -(sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) s *= nthroot(q, 4) if (nd&1): return (-1)**(nd//2) * s else: return (-1)**(1 + nd//2) * s
def jacobi_theta_2(z, m, verbose=False): """ Implements the jacobi theta function 2, using the series expansion found in Abramowitz & Stegun [4]. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2' m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if verbose: print >> sys.stderr, '\tk: %f ' % k print >> sys.stderr, '\tq: %f ' % q if abs(q) >= mpf('1'): raise ValueError sum = 0 term = 0 # series starts at zero zero = mpf('0') if q == zero: if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2: q == 0, return 0' return zero else: if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2: calculating' if z == zero: factor2 = mpf('1') while True: factor1 = q**(term*(term + 1)) term_n = factor1 # suboptimal, kept for readability sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if factor1 == zero: # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: factor1 = q**(term*(term + 1)) if z == zero: factor2 = 1 else: factor2 = cos((2*term + 1)*z) term_n = factor1 * factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if factor1 == zero: # all further terms will be zero break if factor2 != zero: # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return (2*q**(0.25))*sum # can't get here print >> sys.stderr, 'elliptic.jacobi_theta_2 in impossible state' sys.exit(2)
def jacobi_theta_4(z, m): """ Implements the series expansion of the jacobi theta function 1, where z == 0. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if abs(q) >= mpf('1'): raise ValueError sum = 0 delta_sum = 1 term = 1 # series starts at 1 zero = mpf('0') if z == zero: factor2 = mpf('1') while True: if (term % 2) == 0: factor0 = 1 else: factor0 = -1 factor1 = q**(term * term) term_n = factor0 * factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: if (term % 2) == 0: factor0 = 1 else: factor0 = -1 factor1 = q**(term * term) if z == zero: factor2 = 1 else: factor2 = cos(2 * term * z) term_n = factor0 * factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break if factor2 != mpf('0'): # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return 1 + 2 * sum
def jacobi_theta_2(z, m, verbose=False): """ Implements the jacobi theta function 2, using the series expansion found in Abramowitz & Stegun [4]. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2' m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if verbose: print >> sys.stderr, '\tk: %f ' % k print >> sys.stderr, '\tq: %f ' % q if abs(q) >= mpf('1'): raise ValueError sum = 0 term = 0 # series starts at zero zero = mpf('0') if q == zero: if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2: q == 0, return 0' return zero else: if verbose: print >> sys.stderr, 'elliptic.jacobi_theta_2: calculating' if z == zero: factor2 = mpf('1') while True: factor1 = q**(term * (term + 1)) term_n = factor1 # suboptimal, kept for readability sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if factor1 == zero: # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: factor1 = q**(term * (term + 1)) if z == zero: factor2 = 1 else: factor2 = cos((2 * term + 1) * z) term_n = factor1 * factor2 sum = sum + term_n if verbose: print >> sys.stderr, '\tTerm: %d' % term, print >> sys.stderr, '\tterm_n: %e' % term_n, print >> sys.stderr, '\tsum: %e' % sum if factor1 == zero: # all further terms will be zero break if factor2 != zero: # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return (2 * q**(0.25)) * sum # can't get here print >> sys.stderr, 'elliptic.jacobi_theta_2 in impossible state' sys.exit(2)
def _jacobi_theta2(z, q): extra1 = 10 extra2 = 20 # the loops below break when the fixed precision quantities # a and b go to zero; # right shifting small negative numbers by wp one obtains -1, not zero, # so the condition a**2 + b**2 > MIN is used to break the loops. MIN = 2 if z == zero: if isinstance(q, mpf): wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) x2 = (x*x) >> wp a = b = x2 s = x2 while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp s += a s = (1 << (wp+1)) + (s << 1) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) else: wp = mp.prec + extra1 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = x2re aim = bim = x2im sre = (1<<wp) + are sim = aim while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp sre += are sim += aim sre = (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) else: if isinstance(q, mpf) and isinstance(z, mpf): wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) x2 = (x*x) >> wp a = b = x2 c1, s1 = cos_sin(z._mpf_, wp) cn = c1 = to_fixed(c1, wp) sn = s1 = to_fixed(s1, wp) c2 = (c1*c1 - s1*s1) >> wp s2 = (c1 * s1) >> (wp - 1) cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp s = c1 + ((a * cn) >> wp) while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp s += (a * cn) >> wp s = (s << 1) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) s *= nthroot(q, 4) return s # case z real, q complex elif isinstance(z, mpf): wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = x2re aim = bim = x2im c1, s1 = cos_sin(z._mpf_, wp) cn = c1 = to_fixed(c1, wp) sn = s1 = to_fixed(s1, wp) c2 = (c1*c1 - s1*s1) >> wp s2 = (c1 * s1) >> (wp - 1) cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp sre = c1 + ((are * cn) >> wp) sim = ((aim * cn) >> wp) while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp sre += ((are * cn) >> wp) sim += ((aim * cn) >> wp) sre = (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) #case z complex, q real elif isinstance(q, mpf): wp = mp.prec + extra2 x = to_fixed(q._mpf_, wp) x2 = (x*x) >> wp a = b = x2 prec0 = mp.prec mp.prec = wp c1 = cos(z) s1 = sin(z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) #c2 = (c1*c1 - s1*s1) >> wp c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp c2im = (c1re*c1im - s1re*s1im) >> (wp - 1) #s2 = (c1 * s1) >> (wp - 1) s2re = (c1re*s1re - c1im*s1im) >> (wp - 1) s2im = (c1re*s1im + c1im*s1re) >> (wp - 1) #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 sre = c1re + ((a * cnre) >> wp) sim = c1im + ((a * cnim) >> wp) while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 sre += ((a * cnre) >> wp) sim += ((a * cnim) >> wp) sre = (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) # case z and q complex else: wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = x2re aim = bim = x2im prec0 = mp.prec mp.prec = wp # cos(z), siz(z) with z complex c1 = cos(z) s1 = sin(z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp c2im = (c1re*c1im - s1re*s1im) >> (wp - 1) s2re = (c1re*s1re - c1im*s1im) >> (wp - 1) s2im = (c1re*s1im + c1im*s1re) >> (wp - 1) t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 n = 1 termre = c1re termim = c1im sre = c1re + ((are * cnre - aim * cnim) >> wp) sim = c1im + ((are * cnim + aim * cnre) >> wp) n = 3 termre = ((are * cnre - aim * cnim) >> wp) termim = ((are * cnim + aim * cnre) >> wp) sre = c1re + ((are * cnre - aim * cnim) >> wp) sim = c1im + ((are * cnim + aim * cnre) >> wp) n = 5 while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 termre = ((are * cnre - aim * cnim) >> wp) termim = ((aim * cnre + are * cnim) >> wp) sre += ((are * cnre - aim * cnim) >> wp) sim += ((aim * cnre + are * cnim) >> wp) n += 2 sre = (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) s *= nthroot(q, 4) return s
def _djacobi_theta3(z, q, nd): """nd=1,2,3 order of the derivative with respect to z""" MIN = 2 extra1 = 10 extra2 = 20 if isinstance(q, mpf) and isinstance(z, mpf): s = MP_ZERO wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) a = b = x x2 = (x*x) >> wp c1, s1 = cos_sin(mpf_shift(z._mpf_, 1), wp) c1 = to_fixed(c1, wp) s1 = to_fixed(s1, wp) cn = c1 sn = s1 if (nd&1): s += (a * sn) >> wp else: s += (a * cn) >> wp n = 2 while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp if nd&1: s += (a * sn * n**nd) >> wp else: s += (a * cn * n**nd) >> wp n += 1 s = -(s << (nd+1)) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) # case z real, q complex elif isinstance(z, mpf): wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = xre aim = bim = xim c1, s1 = cos_sin(mpf_shift(z._mpf_, 1), wp) c1 = to_fixed(c1, wp) s1 = to_fixed(s1, wp) cn = c1 sn = s1 if (nd&1): sre = (are * sn) >> wp sim = (aim * sn) >> wp else: sre = (are * cn) >> wp sim = (aim * cn) >> wp n = 2 while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp if nd&1: sre += (are * sn * n**nd) >> wp sim += (aim * sn * n**nd) >> wp else: sre += (are * cn * n**nd) >> wp sim += (aim * cn * n**nd) >> wp n += 1 sre = -(sre << (nd+1)) sim = -(sim << (nd+1)) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) #case z complex, q real elif isinstance(q, mpf): wp = mp.prec + extra2 x = to_fixed(q._mpf_, wp) a = b = x x2 = (x*x) >> wp prec0 = mp.prec mp.prec = wp c1 = cos(2*z) s1 = sin(2*z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) if (nd&1): sre = (a * snre) >> wp sim = (a * snim) >> wp else: sre = (a * cnre) >> wp sim = (a * cnim) >> wp n = 2 while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if (nd&1): sre += (a * snre * n**nd) >> wp sim += (a * snim * n**nd) >> wp else: sre += (a * cnre * n**nd) >> wp sim += (a * cnim * n**nd) >> wp n += 1 sre = -(sre << (nd+1)) sim = -(sim << (nd+1)) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) # case z and q complex else: wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = xre aim = bim = xim prec0 = mp.prec mp.prec = wp # cos(2*z), sin(2*z) with z complex c1 = cos(2*z) s1 = sin(2*z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) if (nd&1): sre = (are * snre - aim * snim) >> wp sim = (aim * snre + are * snim) >> wp else: sre = (are * cnre - aim * cnim) >> wp sim = (aim * cnre + are * cnim) >> wp n = 2 while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 if(nd&1): sre += ((are * snre - aim * snim) * n**nd) >> wp sim += ((aim * snre + are * snim) * n**nd) >> wp else: sre += ((are * cnre - aim * cnim) * n**nd) >> wp sim += ((aim * cnre + are * cnim) * n**nd) >> wp n += 1 sre = -(sre << (nd+1)) sim = -(sim << (nd+1)) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) if (nd&1): return (-1)**(nd//2) * s else: return (-1)**(1 + nd//2) * s
def _jacobi_theta3(z, q): extra1 = 10 extra2 = 20 MIN = 2 if z == zero: if isinstance(q, mpf): wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) s = x a = b = x x2 = (x*x) >> wp while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp s += a s = (1 << wp) + (s << 1) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) return s else: wp = mp.prec + extra1 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) sre = are = bre = xre sim = aim = bim = xim while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp sre += are sim += aim sre = (1 << wp) + (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) return s else: if isinstance(q, mpf) and isinstance(z, mpf): s = MP_ZERO wp = mp.prec + extra1 x = to_fixed(q._mpf_, wp) a = b = x x2 = (x*x) >> wp c1, s1 = cos_sin(mpf_shift(z._mpf_, 1), wp) c1 = to_fixed(c1, wp) s1 = to_fixed(s1, wp) cn = c1 sn = s1 s += (a * cn) >> wp while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp s += (a * cn) >> wp s = (1 << wp) + (s << 1) s = mpf(from_man_exp(s, -wp, mp.prec, 'n')) return s # case z real, q complex elif isinstance(z, mpf): wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = xre aim = bim = xim c1, s1 = cos_sin(mpf_shift(z._mpf_, 1), wp) c1 = to_fixed(c1, wp) s1 = to_fixed(s1, wp) cn = c1 sn = s1 sre = (are * cn) >> wp sim = (aim * cn) >> wp while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp sre += (are * cn) >> wp sim += (aim * cn) >> wp sre = (1 << wp) + (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) return s #case z complex, q real elif isinstance(q, mpf): wp = mp.prec + extra2 x = to_fixed(q._mpf_, wp) a = b = x x2 = (x*x) >> wp prec0 = mp.prec mp.prec = wp c1 = cos(2*z) s1 = sin(2*z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) sre = (a * cnre) >> wp sim = (a * cnim) >> wp while abs(a) > MIN: b = (b*x2) >> wp a = (a*b) >> wp t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 sre += (a * cnre) >> wp sim += (a * cnim) >> wp sre = (1 << wp) + (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) return s # case z and q complex else: wp = mp.prec + extra2 xre, xim = q._mpc_ xre = to_fixed(xre, wp) xim = to_fixed(xim, wp) x2re = (xre*xre - xim*xim) >> wp x2im = (xre*xim) >> (wp - 1) are = bre = xre aim = bim = xim prec0 = mp.prec mp.prec = wp # cos(2*z), sin(2*z) with z complex c1 = cos(2*z) s1 = sin(2*z) mp.prec = prec0 cnre = c1re = to_fixed(c1.real._mpf_, wp) cnim = c1im = to_fixed(c1.imag._mpf_, wp) snre = s1re = to_fixed(s1.real._mpf_, wp) snim = s1im = to_fixed(s1.imag._mpf_, wp) sre = (are * cnre - aim * cnim) >> wp sim = (aim * cnre + are * cnim) >> wp while are**2 + aim**2 > MIN: bre, bim = (bre * x2re - bim * x2im) >> wp, \ (bre * x2im + bim * x2re) >> wp are, aim = (are * bre - aim * bim) >> wp, \ (are * bim + aim * bre) >> wp t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp cnre = t1 cnim = t2 snre = t3 snim = t4 sre += (are * cnre - aim * cnim) >> wp sim += (aim * cnre + are * cnim) >> wp sre = (1 << wp) + (sre << 1) sim = (sim << 1) sre = from_man_exp(sre, -wp, mp.prec, 'n') sim = from_man_exp(sim, -wp, mp.prec, 'n') s = mpc(sre, sim) return s
def jacobi_theta_4(z, m): """ Implements the series expansion of the jacobi theta function 1, where z == 0. z is any complex number, but only reals here? m is the parameter, which must be converted to the nome """ m = convert_lossless(m) z = convert_lossless(z) k = sqrt(m) q = calculate_nome(k) if abs(q) >= mpf('1'): raise ValueError sum = 0 delta_sum = 1 term = 1 # series starts at 1 zero = mpf('0') if z == zero: factor2 = mpf('1') while True: if (term % 2) == 0: factor0 = 1 else: factor0 = -1 factor1 = q**(term*term) term_n = factor0 * factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 else: while True: if (term % 2) == 0: factor0 = 1 else: factor0 = -1 factor1 = q**(term*term) if z == zero: factor2 = 1 else: factor2 = cos(2*term*z) term_n = factor0 * factor1 * factor2 sum = sum + term_n if factor1 == mpf('0'): # all further terms will be zero break if factor2 != mpf('0'): # check precision iff cos != 0 #if log(term_n, '10') < -1*mpf.dps: if abs(term_n) < eps: break term = term + 1 return 1 + 2*sum
import numpy as np import matplotlib.pyplot as plt from functions import sin, cos x = np.linspace(0, 10, 10000) plt.plot(x, sin(x)) plt.plot(x, cos(x)) plt.show()
def cos(self): return F.cos(self)