我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用cmath.sqrt()。
def test_complex_sqrt_accuracy(): def test_mpc_sqrt(lst): for a, b in lst: z = mpc(a + j*b) assert mpc_ae(sqrt(z*z), z) z = mpc(-a + j*b) assert mpc_ae(sqrt(z*z), -z) z = mpc(a - j*b) assert mpc_ae(sqrt(z*z), z) z = mpc(-a - j*b) assert mpc_ae(sqrt(z*z), -z) random.seed(2) N = 10 mp.dps = 30 dps = mp.dps test_mpc_sqrt([(random.uniform(0, 10),random.uniform(0, 10)) for i in range(N)]) test_mpc_sqrt([(i + 0.1, (i + 0.2)*10**i) for i in range(N)]) mp.dps = 15
def test_arg_sign(): assert arg(3) == 0 assert arg(-3).ae(pi) assert arg(j).ae(pi/2) assert arg(-j).ae(-pi/2) assert arg(0) == 0 assert isnan(atan2(3,nan)) assert isnan(atan2(nan,3)) assert isnan(atan2(0,nan)) assert isnan(atan2(nan,0)) assert isnan(atan2(nan,nan)) assert arg(inf) == 0 assert arg(-inf).ae(pi) assert isnan(arg(nan)) #assert arg(inf*j).ae(pi/2) assert sign(0) == 0 assert sign(3) == 1 assert sign(-3) == -1 assert sign(inf) == 1 assert sign(-inf) == -1 assert isnan(sign(nan)) assert sign(j) == j assert sign(-3*j) == -j assert sign(1+j).ae((1+j)/sqrt(2))
def test_cyclotomic(): mp.dps = 15 assert [cyclotomic(n,1) for n in range(31)] == [1,0,2,3,2,5,1,7,2,3,1,11,1,13,1,1,2,17,1,19,1,1,1,23,1,5,1,3,1,29,1] assert [cyclotomic(n,-1) for n in range(31)] == [1,-2,0,1,2,1,3,1,2,1,5,1,1,1,7,1,2,1,3,1,1,1,11,1,1,1,13,1,1,1,1] assert [cyclotomic(n,j) for n in range(21)] == [1,-1+j,1+j,j,0,1,-j,j,2,-j,1,j,3,1,-j,1,2,1,j,j,5] assert [cyclotomic(n,-j) for n in range(21)] == [1,-1-j,1-j,-j,0,1,j,-j,2,j,1,-j,3,1,j,1,2,1,-j,-j,5] assert cyclotomic(1624,j) == 1 assert cyclotomic(33600,j) == 1 u = sqrt(j, prec=500) assert cyclotomic(8, u).ae(0) assert cyclotomic(30, u).ae(5.8284271247461900976) assert cyclotomic(2040, u).ae(1) assert cyclotomic(0,2.5) == 1 assert cyclotomic(1,2.5) == 2.5-1 assert cyclotomic(2,2.5) == 2.5+1 assert cyclotomic(3,2.5) == 2.5**2 + 2.5 + 1 assert cyclotomic(7,2.5) == 406.234375
def add_globals(self): "Add some Scheme standard procedures." import math, cmath, operator as op from functools import reduce self.update(vars(math)) self.update(vars(cmath)) self.update({ '+':op.add, '-':op.sub, '*':op.mul, '/':op.itruediv, 'níl':op.not_, 'agus':op.and_, '>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq, 'mod':op.mod, 'frmh':cmath.sqrt, 'dearbhluach':abs, 'uas':max, 'íos':min, 'cothrom_le?':op.eq, 'ionann?':op.is_, 'fad':len, 'cons':cons, 'ceann':lambda x:x[0], 'tóin':lambda x:x[1:], 'iarcheangail':op.add, 'liosta':lambda *x:list(x), 'liosta?': lambda x:isa(x,list), 'folamh?':lambda x: x == [], 'adamh?':lambda x: not((isa(x, list)) or (x == None)), 'boole?':lambda x: isa(x, bool), 'scag':lambda f, x: list(filter(f, x)), 'cuir_le':lambda proc,l: proc(*l), 'mapáil':lambda p, x: list(map(p, x)), 'lódáil':lambda fn: load(fn), 'léigh':lambda f: f.read(), 'oscail_comhad_ionchuir':open,'dún_comhad_ionchuir':lambda p: p.file.close(), 'oscail_comhad_aschur':lambda f:open(f,'w'), 'dún_comhad_aschur':lambda p: p.close(), 'dac?':lambda x:x is eof_object, 'luacháil':lambda x: evaluate(x), 'scríobh':lambda x,port=sys.stdout:port.write(to_string(x) + '\n')}) return self
def tang(self, r2, r3, r4): """Quality function that takes 3 radiuses and makes 4 circles that are kissing""" c2 = Circle(0, 0, r2) # The first circle is placed at the origin c3 = Circle(r2 + r3, 0, r3) # The second circle is placed kissing the first circle to the right x = (r2 * r2 + r2 * r4 + r2 * r3 - r3 * r4) / ( r2 + r3) # Magic triangle maths to figure out where the of the third circle should go y = cmath.sqrt((r2 + r4) * (r2 + r4) - x * x) c4 = Circle(x.real, y.real, r4) c1 = self.outer(c2, c3, c4) # The outer circle is generated based on the first 3 offx = 0 - c1.x offy = 0 - c1.y c2.correct(offx, offy) # Offsets all the circles so the biggest circle is centered instead of the first circle c3.correct(offx, offy) c4.correct(offx, offy) c1.correct(offx, offy) return c1, c2, c3, c4
def _quilt(self, avatars): """ Makes a quilt of avatars of avatars that tries to be as square as possible """ xbound = math.ceil(math.sqrt(len(avatars))) ybound = math.ceil(len(avatars) / xbound) size = int(2520 / xbound) base = Image.new(mode='RGBA', size=(xbound * size, ybound * size), color=(0, 0, 0, 0)) x, y = 0, 0 for avatar in avatars: im = Image.open(avatar) base.paste(im.resize((size, size), resample=Image.BILINEAR), box=(x * size, y * size)) if x < xbound - 1: x += 1 else: x = 0 y += 1 buffer = BytesIO() base.save(buffer, 'png') buffer.seek(0) return discord.File(buffer, filename='quilt.png')
def black_bolt_shear(dia, n, fu): ''' Args: dia (int) diameter of bolt n (str) number of shear plane(s) through which bolt is passing fu (float) ultimate tensile strength of a bolt Returns: Shear capacity of bearing type bolt in kN ''' A = net_area_calc(dia) root3 = math.sqrt(3) Vs = fu * n * A / (root3 * 1.25 * 1000) Vs = round(Vs.real, 3) return Vs # NOT present in CAD_notchB-B branch ############ REDUCTION FACTORS FOR BOLTS ############ # Check added by Danish Ansari on 13th June 2017 # Check for Long joints & Large grip lengths, IS 800:2007 Cl 10.3.3.1 & Cl 10.3.3.2
def quadratic(a: float, b: float, c: float) -> Tuple[complex, complex]: ''' Compute the roots of the quadratic equation: ax^2 + bx + c = 0 Written in Python as: a*x**2 + b*x + c == 0.0 For example: >>> x1, x2 = quadratic(a=8, b=22, c=15) >>> x1 (-1.25+0j) >>> x2 (-1.5+0j) >>> 8*x1**2 + 22*x1 + 15 0j >>> 8*x2**2 + 22*x2 + 15 0j ''' discriminant = cmath.sqrt(b**2.0 - 4.0*a*c) x1 = (-b + discriminant) / (2.0 * a) x2 = (-b - discriminant) / (2.0 * a) return x1, x2
def SQRT(df, price='Close'): """ Square Root """ sqrt_list = [] i = 0 while i < len(df[price]): sqrt = cmath.sqrt(df[price][i]).real sqrt_list.append(sqrt) i += 1 return sqrt_list
def PHI(): """ Mathematical constant PHI """ return (cmath.sqrt(5).real + 1) / 2
def __init__(self, sensor, layer, dense_snow_correction="auto"): if layer.frac_volume > 0.5 and dense_snow_correction == "auto": layer = layer.inverted_medium() f = layer.frac_volume e0 = layer.permittivity(0, sensor.frequency) # background permittivity es = layer.permittivity(1, sensor.frequency) # scatterer permittivity lmda = C_SPEED / sensor.frequency if not hasattr(layer.microstructure, "stickiness") or not hasattr(layer.microstructure, "compute_t"): raise SMRTError("DMRT_ShortRange is only compatible with SHS microstructure model") radius = layer.microstructure.radius t = layer.microstructure.compute_t() y = (es - e0) / (es + 2*e0) fy = f*y k0 = (2 * math.pi / lmda) * cmath.sqrt(e0).real Eeff = e0 + 3*fy*e0/(1-fy) * (1 + 2j/3* (k0 * radius)**3 * y * (1-f)**4 / ((1-fy)*(1+2*f-t*f*(1-f))**2) ) Ks = 2/(9*f) * k0 * (k0 * radius)**3 * abs(Eeff/e0 - 1)**2 * (1-f)**4 / (1+2*f-t*f*(1-f))**2 # TODO: to further double check beta = 2 * k0 * cmath.sqrt(Eeff).imag if Ks >= beta: raise SMRTError("Grain diameter is too large for DMRT_ShortRange resulting in single scattering albedo larger than 1." "It is recommended to decrease the size or used an alternative emmodel able to do Mie calculations.") self._effective_permittivity = Eeff self.ks = Ks self.ka = beta - self.ks
def rootWrapper(a,b,c,d): if a: # Monics formula see http://en.wikipedia.org/wiki/Cubic_function#Monic_formula_of_roots a,b,c = (b/a, c/a, d/a) m = 2.0*a**3 - 9.0*a*b + 27.0*c k = a**2 - 3.0*b n = m**2 - 4.0*k**3 w1 = -.5 + .5*cmath.sqrt(-3.0) w2 = -.5 - .5*cmath.sqrt(-3.0) if n < 0: m1 = pow(complex((m+cmath.sqrt(n))/2),1./3) n1 = pow(complex((m-cmath.sqrt(n))/2),1./3) else: if m+math.sqrt(n) < 0: m1 = -pow(-(m+math.sqrt(n))/2,1./3) else: m1 = pow((m+math.sqrt(n))/2,1./3) if m-math.sqrt(n) < 0: n1 = -pow(-(m-math.sqrt(n))/2,1./3) else: n1 = pow((m-math.sqrt(n))/2,1./3) x1 = -1./3 * (a + m1 + n1) x2 = -1./3 * (a + w1*m1 + w2*n1) x3 = -1./3 * (a + w2*m1 + w1*n1) return (x1,x2,x3) elif b: det=c**2.0-4.0*b*d if det: return (-c+cmath.sqrt(det))/(2.0*b),(-c-cmath.sqrt(det))/(2.0*b) else: return -c/(2.0*b), elif c: return 1.0*(-d/c), return ()
def balf(t): retval = (balfax*(t**2) + balfbx*t + balfcx)**2 + (balfay*(t**2) + balfby*t + balfcy)**2 return math.sqrt(retval)
def test_exact_sqrts(): for i in range(20000): assert sqrt(mpf(i*i)) == i random.seed(1) for prec in [100, 300, 1000, 10000]: mp.dps = prec for i in range(20): A = random.randint(10**(prec//2-2), 10**(prec//2-1)) assert sqrt(mpf(A*A)) == A mp.dps = 15 for i in range(100): for a in [1, 8, 25, 112307]: assert sqrt(mpf((a*a, 2*i))) == mpf((a, i)) assert sqrt(mpf((a*a, -2*i))) == mpf((a, -i))
def test_sqrt_rounding(): for i in [2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]: i = from_int(i) for dps in [7, 15, 83, 106, 2000]: mp.dps = dps a = mpf_pow_int(mpf_sqrt(i, mp.prec, round_down), 2, mp.prec, round_down) b = mpf_pow_int(mpf_sqrt(i, mp.prec, round_up), 2, mp.prec, round_up) assert mpf_lt(a, i) assert mpf_gt(b, i) random.seed(1234) prec = 100 for rnd in [round_down, round_nearest, round_ceiling]: for i in range(100): a = mpf_rand(prec) b = mpf_mul(a, a) assert mpf_sqrt(b, prec, rnd) == a # Test some extreme cases mp.dps = 100 a = mpf(9) + 1e-90 b = mpf(9) - 1e-90 mp.dps = 15 assert sqrt(a, rounding='d') == 3 assert sqrt(a, rounding='n') == 3 assert sqrt(a, rounding='u') > 3 assert sqrt(b, rounding='d') < 3 assert sqrt(b, rounding='n') == 3 assert sqrt(b, rounding='u') == 3 # A worst case, from the MPFR test suite assert sqrt(mpf('7.0503726185518891')) == mpf('2.655253776675949')
def test_float_sqrt(): mp.dps = 15 # These should round identically for x in [0, 1e-7, 0.1, 0.5, 1, 2, 3, 4, 5, 0.333, 76.19]: assert sqrt(mpf(x)) == float(x)**0.5 assert sqrt(-1) == 1j assert sqrt(-2).ae(cmath.sqrt(-2)) assert sqrt(-3).ae(cmath.sqrt(-3)) assert sqrt(-100).ae(cmath.sqrt(-100)) assert sqrt(1j).ae(cmath.sqrt(1j)) assert sqrt(-1j).ae(cmath.sqrt(-1j)) assert sqrt(math.pi + math.e*1j).ae(cmath.sqrt(math.pi + math.e*1j)) assert sqrt(math.pi - math.e*1j).ae(cmath.sqrt(math.pi - math.e*1j))
def test_issue_3195(): for dps in [20, 80]: mp.dps = dps r = nthroot(mpf('-1e-20'), 4) assert r.ae(mpf(10)**(-5) * (1 + j) * mpf(2)**(-0.5)) mp.dps = 80 assert nthroot('-1e-3', 4).ae(mpf(10)**(-3./4) * (1 + j)/sqrt(2)) assert nthroot('-1e-6', 4).ae((1 + j)/(10 * sqrt(20))) # Check that this doesn't take eternity to compute mp.dps = 20 assert nthroot('-1e100000000', 4).ae((1+j)*mpf('1e25000000')/sqrt(2)) mp.dps = 15
def _mathfun_n(f_real, f_complex): def f(*args, **kwargs): try: return f_real(*(float(x) for x in args)) except (TypeError, ValueError): return f_complex(*(complex(x) for x in args)) f.__name__ = f_real.__name__ return f # Workaround for non-raising log and sqrt in Python 2.5 and 2.4 # on Unix system
def math_sqrt(x): if x < 0.0: raise ValueError("math domain error") return math.sqrt(x)
def test_issue_96(): for dps in [20, 80]: mp.dps = dps r = nthroot(mpf('-1e-20'), 4) assert r.ae(mpf(10)**(-5) * (1 + j) * mpf(2)**(-0.5)) mp.dps = 80 assert nthroot('-1e-3', 4).ae(mpf(10)**(-3./4) * (1 + j)/sqrt(2)) assert nthroot('-1e-6', 4).ae((1 + j)/(10 * sqrt(20))) # Check that this doesn't take eternity to compute mp.dps = 20 assert nthroot('-1e100000000', 4).ae((1+j)*mpf('1e25000000')/sqrt(2)) mp.dps = 15
def test_issue_136(): for dps in [20, 80]: mp.dps = dps r = nthroot(mpf('-1e-20'), 4) assert r.ae(mpf(10)**(-5) * (1 + j) * mpf(2)**(-0.5)) mp.dps = 80 assert nthroot('-1e-3', 4).ae(mpf(10)**(-3./4) * (1 + j)/sqrt(2)) assert nthroot('-1e-6', 4).ae((1 + j)/(10 * sqrt(20))) # Check that this doesn't take eternity to compute mp.dps = 20 assert nthroot('-1e100000000', 4).ae((1+j)*mpf('1e25000000')/sqrt(2)) mp.dps = 15
def csp_to_point_distance(csp, p, dist_bounds = [0,1e100], tolerance=.01) : min_dist = [1e100,0,0,0] for j in range(len(csp)) : for i in range(1,len(csp[j])) : d = csp_seg_to_point_distance(csp[j][i-1],csp[j][i],p,sample_points = 5, tolerance = .01) if d[0] < dist_bounds[0] : # draw_pointer( list(csp_at_t(subpath[dist[2]-1],subpath[dist[2]],dist[3])) # +list(csp_at_t(csp[dist[4]][dist[5]-1],csp[dist[4]][dist[5]],dist[6])),"red","line", comment = math.sqrt(dist[0])) return [d[0],j,i,d[1]] else : if d[0] < min_dist[0] : min_dist = [d[0],j,i,d[1]] return min_dist
def csp_simple_bound_to_point_distance(p, csp): minx,miny,maxx,maxy = None,None,None,None for subpath in csp: for sp in subpath: for p_ in sp: minx = min(minx,p_[0]) if minx!=None else p_[0] miny = min(miny,p_[1]) if miny!=None else p_[1] maxx = max(maxx,p_[0]) if maxx!=None else p_[0] maxy = max(maxy,p_[1]) if maxy!=None else p_[1] return math.sqrt(max(minx-p[0],p[0]-maxx,0)**2+max(miny-p[1],p[1]-maxy,0)**2)
def point_to_point_d(a,b): return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)
def csp_normalized_slope(sp1,sp2,t) : ax,ay,bx,by,cx,cy,dx,dy=bezmisc.bezierparameterize((sp1[1][:],sp1[2][:],sp2[0][:],sp2[1][:])) if sp1[1]==sp2[1]==sp1[2]==sp2[0] : return [1.,0.] f1x = 3*ax*t*t+2*bx*t+cx f1y = 3*ay*t*t+2*by*t+cy if abs(f1x*f1x+f1y*f1y) > 1e-20 : l = math.sqrt(f1x*f1x+f1y*f1y) return [f1x/l, f1y/l] if t == 0 : f1x = sp2[0][0]-sp1[1][0] f1y = sp2[0][1]-sp1[1][1] if abs(f1x*f1x+f1y*f1y) > 1e-20 : l = math.sqrt(f1x*f1x+f1y*f1y) return [f1x/l, f1y/l] else : f1x = sp2[1][0]-sp1[1][0] f1y = sp2[1][1]-sp1[1][1] if f1x*f1x+f1y*f1y != 0 : l = math.sqrt(f1x*f1x+f1y*f1y) return [f1x/l, f1y/l] elif t == 1 : f1x = sp2[1][0]-sp1[2][0] f1y = sp2[1][1]-sp1[2][1] if abs(f1x*f1x+f1y*f1y) > 1e-20 : l = math.sqrt(f1x*f1x+f1y*f1y) return [f1x/l, f1y/l] else : f1x = sp2[1][0]-sp1[1][0] f1y = sp2[1][1]-sp1[1][1] if f1x*f1x+f1y*f1y != 0 : l = math.sqrt(f1x*f1x+f1y*f1y) return [f1x/l, f1y/l] else : return [1.,0.]
def vector_from_to_length(a,b): return math.sqrt((a[0]-b[0])*(a[0]-b[0]) + (a[1]-b[1])*(a[1]-b[1])) ################################################################################ ### Common functions ################################################################################
