def test_power_zero(self):
# ticket #1271
zero = np.array([0j])
one = np.array([1 + 0j])
cinf = np.array([complex(np.inf, 0)])
cnan = np.array([complex(np.nan, np.nan)])
def assert_complex_equal(x, y):
x, y = np.asarray(x), np.asarray(y)
assert_array_equal(x.real, y.real)
assert_array_equal(x.imag, y.imag)
# positive powers
for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]:
assert_complex_equal(np.power(zero, p), zero)
# zero power
assert_complex_equal(np.power(zero, 0), one)
assert_complex_equal(np.power(zero, 0 + 1j), cnan)
# negative power
for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]:
assert_complex_equal(np.power(zero, -p), cnan)
assert_complex_equal(np.power(zero, -1 + 0.2j), cnan)
def test_fast_power(self):
x = np.array([1, 2, 3], np.int16)
assert (x ** 2.00001).dtype is (x ** 2.0).dtype
def setCoefs(self):
# If not closed, then this should change (less sides) !
self.Nsides = len(self.xylist)
self.ldList = []
xy = self.xylist
self.xlist = [xy[0][0]]; self.ylist = [xy[0][1]]
self.z1 = []; self.z2 = []
for i in range(self.Nsides-1):
ld = LineDoublet(self.modelParent,xy[i][0],xy[i][1],xy[i+1][0],xy[i+1][1],\
self.aqin,self.aqout,self.Ndegree,self.overspec,addToModel=0)
self.ldList = self.ldList + [ld]
self.xlist = self.xlist + [xy[i+1][0]]; self.ylist = self.ylist + [xy[i+1][1]]
self.z1 = self.z1 + [ complex( xy[i][0], xy[i][1] ) ]
self.z2 = self.z2 + [ complex( xy[i+1][0], xy[i+1][1] ) ]
if self.closed:
ld = LineDoublet(self.modelParent,xy[-1][0],xy[-1][1],xy[0][0],xy[0][1],\
self.aqin,self.aqout,self.Ndegree,self.overspec,addToModel=0)
self.ldList = self.ldList + [ld]
self.xlist = self.xlist + [xy[0][0]]; self.ylist = self.ylist + [xy[0][1]]
self.z1 = self.z1 + [ complex( xy[-1][0], xy[-1][1] ) ]
self.z2 = self.z2 + [ complex( xy[0][0], xy[0][1] ) ]
self.z1 = array(self.z1); self.z2 = array(self.z2)
self.Nparam = 0
for ld in self.ldList:
self.Nparam = self.Nparam + ld.Ndegree # Cause the constant and linear portions are joined
self.parameters = zeros( (self.Nparam,1), 'd' )
def getJumpPoint(begin, end, loop, runningJumpSpace):
"Get running jump point inside loop."
segment = begin - end
segmentLength = abs(segment)
if segmentLength == 0.0:
return begin
segment /= segmentLength
distancePoint = DistancePoint(begin, loop, runningJumpSpace, segment)
if distancePoint.distance == runningJumpSpace:
return distancePoint.point
effectiveDistance = distancePoint.distance
jumpPoint = distancePoint.point
segmentLeft = complex(0.70710678118654757, -0.70710678118654757)
distancePoint = DistancePoint(begin, loop, runningJumpSpace, segmentLeft)
distancePoint.distance *= 0.5
if distancePoint.distance > effectiveDistance:
effectiveDistance = distancePoint.distance
jumpPoint = distancePoint.point
segmentRight = complex(0.70710678118654757, 0.70710678118654757)
distancePoint = DistancePoint(begin, loop, runningJumpSpace, segmentRight)
distancePoint.distance *= 0.5
if distancePoint.distance > effectiveDistance:
effectiveDistance = distancePoint.distance
jumpPoint = distancePoint.point
return jumpPoint
def test_complex_nans(self):
nan = np.nan
for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]:
arg1 = np.array([0, cnan, cnan], dtype=np.complex)
arg2 = np.array([cnan, 0, cnan], dtype=np.complex)
out = np.array([0, 0, nan], dtype=np.complex)
assert_equal(np.fmin(arg1, arg2), out)
def potentialInfluence(self,aq,x,y):
zin = complex(x,y)
bigZ = ( 2.0*zin - (self.z1 + self.z2) )/ (self.z2 - self.z1)
if abs(bigZ.imag) < self.tiny and abs(bigZ.real) < 1.0-self.tiny: # point is on boundary; this could be nicer by setting the log
if self.aqin == aq:
bigZ = complex(bigZ.real,self.tiny)
elif self.aqout == aq:
bigZ = complex(bigZ.real,-self.tiny)
zin = ( (self.z2-self.z1)*bigZ + (self.z1+self.z2) ) / 2.0
bigZmin1 = bigZ - 1.0; bigZplus1 = bigZ + 1.0
## if abs(bigZmin1) < self.tiny:
## # point is at right corner; move back a little along element; may fail if corner is very pointy
## # This needs to be moved by the PolygonInhom class; after all, that class decided it was inside.
## if self.aqin == aq:
## zin = self.z2 + complex(4.0,-1.0) * self.tiny * (self.z1 - self.z2)
## else:
## zin = self.z2 + complex(4.0,1.0) * self.tiny * (self.z1 - self.z2)
## elif abs(bigZplus1) < self.tiny: # point is at left corner, move up a little along ldLeft
## if self.aqin == aq:
## zin = self.ldLeft.z2 + complex(4.0,-1.0) * self.tiny * (self.ldLeft.z1 - self.ldLeft.z2)
## else:
## zin = self.ldLeft.z2 + complex(4.0,1.0) * self.tiny * (self.ldLeft.z1 - self.ldLeft.z2)
if abs(bigZmin1) < self.tiny or abs(bigZplus1) < self.tiny: # gotta be inside; move point
# zin = self.aqin.movePoint(zin)
# doesn't have to be inside when inhoms butt-up
zin = aq.movePoint(zin)
# Only works for line-doublet in one layer, so that is hardcoded (the zero lists)
rv = zeros((self.Ndegree+1,aq.Naquifers),'d')
x = zin.real; y = zin.imag
potlapldho(x,y,self.x1,self.y1,self.x2,self.y2,self.Ndegree,self.potInf)
rv[:,0] = self.potInf
return rv
def test_power_complex(self):
x = np.array([1 + 2j, 2 + 3j, 3 + 4j])
assert_equal(x ** 0, [1.0, 1.0, 1.0])
assert_equal(x ** 1, x)
assert_almost_equal(x ** 2, [-3 + 4j, -5 + 12j, -7 + 24j])
assert_almost_equal(x ** 3, [(1 + 2j) ** 3, (2 + 3j) ** 3, (3 + 4j) ** 3])
assert_almost_equal(x ** 4, [(1 + 2j) ** 4, (2 + 3j) ** 4, (3 + 4j) ** 4])
assert_almost_equal(x ** (-1), [1 / (1 + 2j), 1 / (2 + 3j), 1 / (3 + 4j)])
assert_almost_equal(x ** (-2), [1 / (1 + 2j) ** 2, 1 / (2 + 3j) ** 2, 1 / (3 + 4j) ** 2])
assert_almost_equal(x ** (-3), [(-11 + 2j) / 125, (-46 - 9j) / 2197, (-117 - 44j) / 15625])
assert_almost_equal(x ** (0.5), [ncu.sqrt(1 + 2j), ncu.sqrt(2 + 3j), ncu.sqrt(3 + 4j)])
norm = 1.0 / ((x ** 14)[0])
assert_almost_equal(
x ** 14 * norm, [i * norm for i in [-76443 + 16124j, 23161315 + 58317492j, 5583548873 + 2465133864j]]
)
# Ticket #836
def assert_complex_equal(x, y):
assert_array_equal(x.real, y.real)
assert_array_equal(x.imag, y.imag)
for z in [complex(0, np.inf), complex(1, np.inf)]:
err = np.seterr(invalid="ignore")
z = np.array([z], dtype=np.complex_)
try:
assert_complex_equal(z ** 1, z)
assert_complex_equal(z ** 2, z * z)
assert_complex_equal(z ** 3, z * z * z)
finally:
np.seterr(**err)
def mat_unitary(self):
s = [
math.sin(2 * self.at0),
math.sin(2 * self.at1),
math.sin(2 * self.aq0),
math.sin(2 * self.aq1),
math.sin(2 * self.aq2),
]
c = [
math.cos(2 * self.at0),
math.cos(2 * self.at1),
math.cos(2 * self.aq0),
math.cos(2 * self.aq1),
math.cos(2 * self.aq2),
]
phi = [
numpy.exp(complex(0, 4 * self.pt1)),
numpy.exp(complex(0, 2 * self.pt2)),
numpy.exp(complex(0, -2 * self.pt2)),
]
U = numpy.array(
[
[c[2] * c[3], -phi[0] * s[0] * s[2] * c[3] - phi[1] * c[0] * s[1] * s[3]],
[c[2] * s[3], -phi[0] * s[0] * s[2] * s[3] + phi[1] * c[0] * s[1] * c[3]],
[s[2] * c[4], phi[0] * s[0] * c[2] * c[4] + phi[2] * c[0] * c[1] * s[4]],
[s[2] * s[4], phi[0] * s[0] * c[2] * s[4] - phi[2] * c[0] * c[1] * c[4]],
]
)
theta = cmath.phase(U[0, 1])
for i in range(4):
U[i, 1] = U[i, 1] * numpy.exp(complex(0, -theta))
return U
def complex_div(a, b):
# This is CPython's algorithm (in _Py_c_quot()).
areal = a.real
aimag = a.imag
breal = b.real
bimag = b.imag
if not breal and not bimag:
raise ZeroDivisionError("complex division by zero")
if abs(breal) >= abs(bimag):
# Divide tops and bottom by b.real
if not breal:
return complex(NAN, NAN)
ratio = bimag / breal
denom = breal + bimag * ratio
return complex(
(areal + aimag * ratio) / denom,
(aimag - areal * ratio) / denom)
else:
# Divide tops and bottom by b.imag
if not bimag:
return complex(NAN, NAN)
ratio = breal / bimag
denom = breal * ratio + bimag
return complex(
(a.real * ratio + a.imag) / denom,
(a.imag * ratio - a.real) / denom)
def zeta(s):
"""
Riemann zeta function, real argument
"""
if not isinstance(s, (float, int)):
try:
s = float(s)
except (ValueError, TypeError):
try:
s = complex(s)
if not s.imag:
return complex(zeta(s.real))
except (ValueError, TypeError):
pass
raise NotImplementedError
if s == 1:
raise ValueError("zeta(1) pole")
if s >= 27:
return 1.0 + 2.0**(-s) + 3.0**(-s)
n = int(s)
if n == s:
if n >= 0:
return _zeta_int[n]
if not (n % 2):
return 0.0
if s <= 0.0:
return 0
if s <= 2.0:
if s <= 1.0:
return _polyval(_zeta_0,s)/(s-1)
return _polyval(_zeta_1,s)/(s-1)
z = _polyval(_zeta_P,s) / _polyval(_zeta_Q,s)
return 1.0 + 2.0**(-s) + 3.0**(-s) + 4.0**(-s)*z
def test_branches(self):
with np.errstate(all="ignore"):
for t in [np.complex64, np.complex128]:
# tupled (numerator, denominator, expected)
# for testing as expected == numerator/denominator
data = list()
# trigger branch: real(fabs(denom)) > imag(fabs(denom))
# followed by else condition as neither are == 0
data.append((( 2.0, 1.0), ( 2.0, 1.0), (1.0, 0.0)))
# trigger branch: real(fabs(denom)) > imag(fabs(denom))
# followed by if condition as both are == 0
# is performed in test_zero_division(), so this is skipped
# trigger else if branch: real(fabs(denom)) < imag(fabs(denom))
data.append((( 1.0, 2.0), ( 1.0, 2.0), (1.0, 0.0)))
for cases in data:
n = cases[0]
d = cases[1]
ex = cases[2]
result = t(complex(n[0], n[1])) / t(complex(d[0], d[1]))
# check real and imag parts separately to avoid comparison
# in array context, which does not account for signed zeros
assert_equal(result.real, ex[0])
assert_equal(result.imag, ex[1])
def removeIntersection( loop ): 'Get loop without the first intersection.' for pointIndex, ahead in enumerate(loop): behind = loop[ ( pointIndex + len( loop ) - 1 ) % len( loop ) ] behindEnd = loop[ ( pointIndex + len( loop ) - 2 ) % len( loop ) ] behindMidpoint = 0.5 * ( behind + behindEnd ) aheadEnd = loop[ (pointIndex + 1) % len( loop ) ] aheadMidpoint = 0.5 * ( ahead + aheadEnd ) normalizedSegment = behind - behindMidpoint normalizedSegmentLength = abs( normalizedSegment ) if normalizedSegmentLength > 0.0: normalizedSegment /= normalizedSegmentLength segmentYMirror = complex(normalizedSegment.real, -normalizedSegment.imag) behindRotated = segmentYMirror * behind behindMidpointRotated = segmentYMirror * behindMidpoint aheadRotated = segmentYMirror * ahead aheadMidpointRotated = segmentYMirror * aheadMidpoint y = behindRotated.imag xIntersection = euclidean.getXIntersectionIfExists( aheadRotated, aheadMidpointRotated, y ) if xIntersection != None: if xIntersection > min( behindMidpointRotated.real, behindRotated.real ) and xIntersection < max( behindMidpointRotated.real, behindRotated.real ): intersectionPoint = normalizedSegment * complex( xIntersection, y ) loop[ ( pointIndex + len( loop ) - 1 ) % len( loop ) ] = intersectionPoint del loop[pointIndex] return
def getTeardropPath(inclination, overhangRadians, overhangSpan, radiusArealized, sides): "Get vector3 teardrop path." sideAngle = 2.0 * math.pi / float(sides) overhangPlaneAngle = euclidean.getWiddershinsUnitPolar(overhangRadians) overhangRadians = math.atan2(overhangPlaneAngle.imag, overhangPlaneAngle.real * math.cos(inclination)) tanOverhangAngle = math.tan(overhangRadians) beginAngle = overhangRadians beginMinusEndAngle = math.pi + overhangRadians + overhangRadians withinSides = int(math.ceil(beginMinusEndAngle / sideAngle)) withinSideAngle = -beginMinusEndAngle / float(withinSides) teardropPath = [] for side in xrange(withinSides + 1): unitPolar = euclidean.getWiddershinsUnitPolar(beginAngle) teardropPath.append(unitPolar * radiusArealized) beginAngle += withinSideAngle firstPoint = teardropPath[0] if overhangSpan <= 0.0: teardropPath.append(complex(0.0, firstPoint.imag + firstPoint.real / tanOverhangAngle)) else: deltaX = (radiusArealized - firstPoint.imag) * tanOverhangAngle overhangPoint = complex(firstPoint.real - deltaX, radiusArealized) remainingDeltaX = max(0.0, overhangPoint.real - 0.5 * overhangSpan ) overhangPoint += complex(-remainingDeltaX, remainingDeltaX / tanOverhangAngle) teardropPath.append(complex(-overhangPoint.real, overhangPoint.imag)) teardropPath.append(overhangPoint) return euclidean.getVector3Path(teardropPath)
def paz_2_amplitude_value_of_freq_resp(paz, freq):
"""
Returns Amplitude at one frequency for the given poles and zeros
:param paz: Given poles and zeros
:param freq: Given frequency
The amplitude of the freq is estimated according to "Of Poles and
Zeros", Frank Scherbaum, p 43.
.. rubric:: Example
>>> paz = {'poles': [-4.44 + 4.44j, -4.44 - 4.44j],
... 'zeros': [0 + 0j, 0 + 0j],
... 'gain': 0.4}
>>> amp = paz_2_amplitude_value_of_freq_resp(paz, 1)
>>> print(round(amp, 7))
0.2830262
"""
jw = complex(0, 2 * np.pi * freq) # angular frequency
fac = complex(1, 0)
for zero in paz['zeros']: # numerator
fac *= jw - zero
for pole in paz['poles']: # denominator
fac /= jw - pole
return abs(fac) * paz['gain']
def test_power_zero(self):
# ticket #1271
zero = np.array([0j])
one = np.array([1+0j])
cinf = np.array([complex(np.inf, 0)])
cnan = np.array([complex(np.nan, np.nan)])
def assert_complex_equal(x, y):
x, y = np.asarray(x), np.asarray(y)
assert_array_equal(x.real, y.real)
assert_array_equal(x.imag, y.imag)
# positive powers
for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]:
assert_complex_equal(np.power(zero, p), zero)
# zero power
assert_complex_equal(np.power(zero, 0), one)
with np.errstate(invalid="ignore"):
assert_complex_equal(np.power(zero, 0+1j), cnan)
# negative power
for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]:
assert_complex_equal(np.power(zero, -p), cnan)
assert_complex_equal(np.power(zero, -1+0.2j), cnan)
def _follow_vertical_line(self, x, y):
"""Find a vertical line with optional arrow heads."""
# follow line to the bottom
_, end_y, line_end_style = self._follow_line(x, y, dy=1, line_character='|')
# follow line to the top
_, start_y, line_start_style = self._follow_line(x, y, dy=-1, line_character='|')
# if a '+' follows a line, then the line is stretched to hit the '+' center
start_y_fix = end_y_fix = 0
if self.get(x, start_y - 1) == '+':
start_y_fix = -0.5
if self.get(x, end_y + 1) == '+':
end_y_fix = 0.5
# tag characters as used (not the arrow heads)
self.tag([(x, y) for y in range(start_y, end_y + 1)], CLASS_LINE)
# return the new shape object with arrows etc.
p1 = complex(self.hcenter(x), self.top(start_y + start_y_fix))
p2 = complex(self.hcenter(x), self.bottom(end_y + end_y_fix))
shapes = []
if line_start_style:
p1, arrow_shapes = line_start_style(p1, p2)
shapes.extend(arrow_shapes)
if line_end_style:
p2, arrow_shapes = line_end_style(p2, p1)
shapes.extend(arrow_shapes)
shapes.append(Line(p1, p2))
return group(shapes)
def _follow_horizontal_line(self, x, y, thick=False):
"""Find a horizontal line with optional arrow heads."""
if thick:
line_character = '='
else:
line_character = '-'
# follow line to the right
end_x, _, line_end_style = self._follow_line(x, y, dx=1, line_character=line_character)
# follow line to the left
start_x, _, line_start_style = self._follow_line(x, y, dx=-1, line_character=line_character)
start_x_fix = end_x_fix = 0
if self.get(start_x - 1, y) == '+':
start_x_fix = -0.5
if self.get(end_x + 1, y) == '+':
end_x_fix = 0.5
self.tag([(x, y) for x in range(start_x, end_x+1)], CLASS_LINE)
# return the new shape object with arrows etc.
p1 = complex(self.left(start_x + start_x_fix), self.vcenter(y))
p2 = complex(self.right(end_x + end_x_fix), self.vcenter(y))
shapes = []
if line_start_style:
p1, arrow_shapes = line_start_style(p1, p2)
shapes.extend(arrow_shapes)
if line_end_style:
p2, arrow_shapes = line_end_style(p2, p1)
shapes.extend(arrow_shapes)
shapes.append(Line(p1, p2, thick=thick))
return group(shapes)
def generate_jpeg(width, height):
# Mandelbrot fractal
# FB - 201003254
# drawing area
xa = -2.0
xb = 1.0
ya = -1.5
yb = 1.5
maxIt = 25 # max iterations allowed
# image size
image = Image.new('RGB', (width, height))
c = complex(random.random() * 2.0 - 1.0, random.random() - 0.5)
for y in range(height):
zy = y * (yb - ya) / (height - 1) + ya
for x in range(width):
zx = x * (xb - xa) / (width - 1) + xa
z = complex(zx, zy)
for i in range(maxIt):
if abs(z) > 2.0:
break
z = z * z + c
r = i % 4 * 64
g = i % 8 * 32
b = i % 16 * 16
image.putpixel((x, y), b * 65536 + g * 256 + r)
output = StringIO()
image.save(output, format='PNG')
return output.getvalue()
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 test_repr_roundtrip(self):
vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
vals += [-v for v in vals]
# complex(repr(z)) should recover z exactly, even for complex
# numbers involving an infinity, nan, or negative zero
for x in vals:
for y in vals:
z = complex(x, y)
roundtrip = complex(repr(z))
self.assertFloatsAreIdentical(z.real, roundtrip.real)
self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
# if we predefine some constants, then eval(repr(z)) should
# also work, except that it might change the sign of zeros
inf, nan = float('inf'), float('nan')
infj, nanj = complex(0.0, inf), complex(0.0, nan)
for x in vals:
for y in vals:
z = complex(x, y)
roundtrip = eval(repr(z))
# adding 0.0 has no effect beside changing -0.0 to 0.0
self.assertFloatsAreIdentical(0.0 + z.real,
0.0 + roundtrip.real)
self.assertFloatsAreIdentical(0.0 + z.imag,
0.0 + roundtrip.imag)
def is_number(s):
try:
complex(s) # for int, long, float and complex
except ValueError:
return False
return True
def drawMandelbrot(self):
start = self.start
end = self.end
print "drawing mandelbrot! ", start, end
scale_x = complex((end-start).real/self.size, 0)
scale_y = complex(0, (end-start).imag/self.size)
for y in range(self.size):
for x in range(self.size):
z = 0j
c = start + x*scale_x + y*scale_y
for count in range(self.iterations):
if abs(z) <= 2:
z = z * z + c
else:
break
color = self.getColor(count)
ps = self.pointsize
self.canvas.create_rectangle(x*ps, y*ps, x*ps + ps, y*ps + ps, fill=color, outline=color)
if y % 32 == 0:
root.update()
def test_getnewargs(self):
self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
def getD3Tensor(self, setting):
'''
Obtain third order anharmonic tensor from QE d3.x
'''
file = open(setting.get('fildyn'), 'r')
lines = file.readlines()
ntype = int(lines[2].split()[0])
natom = int(lines[2].split()[1])
d3tensor = []
qpoints = []
numberq = 0
for index, line in enumerate(lines):
if 'q = (' in line:
numberq = numberq + 1
qpoints.append([float(f) for f in lines[index].split()[3:6]])
for mode in range(0,3*natom):
for i in range(0,natom):
for j in range(0,natom):
for idir in range(0,3):
_itemp = index+mode*(natom*natom*7 + 3)+\
(i*natom+j)*7 + 6 + idir*natom
temp = lines[_itemp]+lines[_itemp + 1]
_val = [float(f) for f in temp.split()]
d3tensor.append(complex(_val[0],_val[1]))
d3tensor.append(complex(_val[2],_val[3]))
d3tensor.append(complex(_val[4],_val[5]))
return \
(np.rollaxis(np.array(d3tensor).reshape(\
numberq,natom,3,natom,natom,3,3),2,5), None), (np.array(qpoints), None),
def test_receive(self):
port = self.__get_free_port()
receive_dialog = self.__get_recv_dialog()
receive_dialog.device.set_server_port(port)
receive_dialog.ui.btnStart.click()
data = np.array([complex(1, 2), complex(3, 4), complex(5, 6)], dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertEqual(receive_dialog.device.current_index, 3)
self.assertTrue(np.array_equal(receive_dialog.device.data[:3], data))
receive_dialog.ui.btnStop.click()
receive_dialog.ui.btnClear.click()
self.assertEqual(receive_dialog.device.current_index, 0)
self.__close_dialog(receive_dialog)
def combined(c1, exp1, offset1, c2, exp2, offset2, width=500, height=500, real_min=-2.0, real_max=2.0, imag_min=-2.0, imag_max=2.0, pickColor=julia.timeBased, allPerlin = False):
# Generate evenly spaced values over real and imaginary ranges
real_range = numpy.arange(real_min, real_max, (real_max - real_min) / width)
imag_range = numpy.arange(imag_max, imag_min, (imag_min - imag_max) / height)
# Obtain image to work with
image = Image.new('RGB', (width, height), (0, 0, 0))
drawer = ImageDraw.Draw(image)
# Generate pixel values
for imag, ipix in itertools.izip(imag_range, range(height)):
for real, rpix in itertools.izip(real_range, range(width)):
z = complex(real, imag) + offset1
n = 255
while abs(z) < 10 and n >= 5:
z = z ** exp1 + c1
n -= 5
m = 255
z = (complex(real, imag) + offset2) * 2
while abs(z) < 10 and n >= 5:
z = z ** exp2 + c2
n -= 5
n = n - (m * 5)
n = n % 255
drawer.point((ipix, rpix), fill=pickColor(n, 0, real, imag)) # n varies between 255 and 5
#time.increase()
# And return results
return image
def test_inversion():
N = 2**2 # Make mgrids without q1 = q2 = 0, since that case can be
# problematic
Q1, Q2 = np.mgrid[-8:8:complex(0, N), -8:8:complex(0, N)]
epsilons = np.linspace(.1, .7, N)
for epsilon in epsilons:
check_inversions(Q1, Q2, epsilon)
def test_spectrum(self):
port = self.__get_free_port()
spectrum_dialog = self.__get_spectrum_dialog()
spectrum_dialog.device.set_server_port(port)
spectrum_dialog.ui.btnStart.click()
self.assertEqual(len(spectrum_dialog.scene_manager.peak), 0)
data = np.array([complex(1, 1), complex(2, 2), complex(3, 3)], dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertGreater(len(spectrum_dialog.scene_manager.peak), 0)
spectrum_dialog.ui.btnStop.click()
self.__close_dialog(spectrum_dialog)
def createImage(self):
self.updateProgress(0, self.height)
for y in range(self.height):
for x in range(self.width):
z = complex(0.0, 0.0)
k = complex(self.origin.real + \
float(x)/float(self.width)*self.range,
self.origin.imag - \
float(y) / float(self.height)*self.range)
# calculate z = (z +k) * (z + k) over and over
for iteration in range(self.depth):
real_part = z.real + k.real
imag_part = z.imag + k.imag
del z
z = complex(real_part * real_part - imag_part * \
imag_part, 2 * real_part * imag_part)
distance = z.real * z.real + z.imag * z.imag
if distance >= self.maxDistance:
cidx = int(distance % self.ncolors)
self.pixel(x, y, cidx)
break
self.updateProgress(y)
self.updateProgress(self.height, self.height)
self.im.putpalette(self.rgb.getpalette())
self.im.save("out.gif")
self.img = PhotoImage(file="out.gif")
self.label['image'] = self.img
def divComplexNumbers(rA, iA, rB, iB):
'''
z.w = (a+bi).(c+di) = (ac-bd) + (ad+bc)i
complex((rA*rB-iA*iB), (rA*iB+iA*rB))
z/w = (z * conj(w)) / (w*conj(w))
conjugado de w (a+bi) eh (a+(-b)i)
ans = "{0}+{1}i".format( _sReal , _sImag)
'''
#A = complex(rA, iA)
#B = complex(rB, iB)
#cB = complex(rB, -iB)
#cB = B.conjugate()
num = mulComplexNumbers(rA, iA, rB, -iB) #A.__mul__(cB)
dem = mulComplexNumbers(rB, iB, rB, -iB) #B.__mul__(cB)
if num.imag == 0 and dem.imag == 0:
return num.real / dem.real
elif dem.imag == 0:
rs = complex(num.real/dem.real, num.imag/dem.real)
return rs
else:
rs = complex(num.real/dem.real, num.imag/dem.imag)
return rs
def coherency_elements (self,observation):
"""helper method: returns the four components of the coherency matrix""";
i,q,u,v = [ self.stokes(st) for st in STOKES ];
# diagonal = (len(Context.active_correlations) == 2);
diagonal = False; # the above was bothersome -- even if we only use 2 corrs, we still want to do all intermediate computations in 2x2
if observation.circular():
if self._constant_flux:
return (i+v,0,0,i-v) if diagonal else (i+v,complex(q,u),complex(q,-u),i-v);
rr = self.ns.rr ** (self.stokes("I") + self.stokes("V"));
if diagonal:
rl = lr = 0;
else:
rl = self.ns.rl ** Meq.ToComplex(self.stokes("Q"),self.stokes("U"));
lr = self.ns.lr ** Meq.Conj(rl);
ll = self.ns.ll ** (self.stokes("I") - self.stokes("V"));
return rr,rl,lr,ll;
else:
if self._constant_flux:
return (i+q,0,0,i-q) if diagonal else (i+q,complex(u,v),complex(u,-v),i-q);
xx = self.ns.xx ** (self.stokes("I") + self.stokes("Q"));
if diagonal:
xy = yx = 0;
else:
xy = self.ns.xy ** Meq.ToComplex(self.stokes("U"),self.stokes("V"));
yx = self.ns.yx ** Meq.Conj(xy);
yy = self.ns.yy ** (self.stokes("I") - self.stokes("Q"));
return xx,xy,yx,yy;
def solveTest3():
x1,x2 = ev.solve(1.,5.,4.)
return x1==complex(-1.,0.) and x2==complex(-4.,0.)
def test_phase(self):
self.assertAlmostEqual(phase(0), 0.)
self.assertAlmostEqual(phase(1.), 0.)
self.assertAlmostEqual(phase(-1.), pi)
self.assertAlmostEqual(phase(-1. + 1E-300j), pi)
self.assertAlmostEqual(phase(-1. - 1E-300j), -pi)
self.assertAlmostEqual(phase(1j), pi / 2)
self.assertAlmostEqual(phase(-1j), -pi / 2)
# zeros
self.assertEqual(phase(complex(0.0, 0.0)), 0.0)
self.assertEqual(phase(complex(0.0, -0.0)), -0.0)
self.assertEqual(phase(complex(-0.0, 0.0)), pi)
self.assertEqual(phase(complex(-0.0, -0.0)), -pi)
# infinities
self.assertAlmostEqual(phase(complex(-INF, -0.0)), -pi)
self.assertAlmostEqual(phase(complex(-INF, -2.3)), -pi)
self.assertAlmostEqual(phase(complex(-INF, -INF)), -0.75 * pi)
self.assertAlmostEqual(phase(complex(-2.3, -INF)), -pi / 2)
self.assertAlmostEqual(phase(complex(-0.0, -INF)), -pi / 2)
self.assertAlmostEqual(phase(complex(0.0, -INF)), -pi / 2)
self.assertAlmostEqual(phase(complex(2.3, -INF)), -pi / 2)
self.assertAlmostEqual(phase(complex(INF, -INF)), -pi / 4)
self.assertEqual(phase(complex(INF, -2.3)), -0.0)
self.assertEqual(phase(complex(INF, -0.0)), -0.0)
self.assertEqual(phase(complex(INF, 0.0)), 0.0)
self.assertEqual(phase(complex(INF, 2.3)), 0.0)
self.assertAlmostEqual(phase(complex(INF, INF)), pi / 4)
self.assertAlmostEqual(phase(complex(2.3, INF)), pi / 2)
self.assertAlmostEqual(phase(complex(0.0, INF)), pi / 2)
self.assertAlmostEqual(phase(complex(-0.0, INF)), pi / 2)
self.assertAlmostEqual(phase(complex(-2.3, INF)), pi / 2)
self.assertAlmostEqual(phase(complex(-INF, INF)), 0.75 * pi)
self.assertAlmostEqual(phase(complex(-INF, 2.3)), pi)
self.assertAlmostEqual(phase(complex(-INF, 0.0)), pi)
# real or imaginary part NaN
for z in complex_nans:
self.assert_(math.isnan(phase(z)))
def table_to_hdu(table, character_as_bytes=False):
"""
Convert an `~astropy.table.Table` object to a FITS
`~astropy.io.fits.BinTableHDU`.
Parameters
----------
table : astropy.table.Table
The table to convert.
character_as_bytes : bool
Whether to return bytes for string columns when accessed from the HDU.
By default this is `False` and (unicode) strings are returned, but for
large tables this may use up a lot of memory.
Returns
-------
table_hdu : `~astropy.io.fits.BinTableHDU`
The FITS binary table HDU.
"""
# Avoid circular imports
from .connect import is_column_keyword, REMOVE_KEYWORDS
from .column import python_to_tdisp
# Header to store Time related metadata
hdr = None
# Not all tables with mixin columns are supported
if table.has_mixin_columns:
# Import is done here, in order to avoid it at build time as erfa is not
# yet available then.
from astropy.table.column import BaseColumn
from astropy.time import Time
from astropy.units import Quantity
from .fitstime import time_to_fits
# Only those columns which are instances of BaseColumn, Quantity or Time can
# be written
unsupported_cols = table.columns.not_isinstance((BaseColumn, Quantity, Time))
if unsupported_cols:
unsupported_names = [col.info.name for col in unsupported_cols]
raise ValueError(f'cannot write table with mixin column(s) '
f'{unsupported_names}')
time_cols = table.columns.isinstance(Time)
if time_cols:
table, hdr = time_to_fits(table)
# Create a new HDU object
tarray = table.as_array()
if isinstance(tarray, np.ma.MaskedArray):
# Fill masked values carefully:
# float column's default mask value needs to be Nan and
# string column's default mask should be an empty string.
# Note: getting the fill value for the structured array is
# more reliable than for individual columns for string entries.
# (no 'N/A' for a single-element string, where it should be 'N').
default_fill_value = np.ma.default_fill_value(tarray.dtype)
for colname, (coldtype, _) in tarray.dtype.fields.items():
if np.all(tarray.fill_value[colname] == default_fill_value[colname]):
if issubclass(coldtype.type, np.complexfloating):
tarray.fill_value[colname] = complex(np.nan, np.nan)
elif issubclass(coldtype.type, np.inexact):
tarray.fill_value[colname] = np.nan
elif issubclass(coldtype.type, np.character):
tarray.fill_value[colname] = ''
# TODO: it might be better to construct the FITS table directly from
# the Table columns, rather than go via a structured array.
table_hdu = BinTableHDU.from_columns(tarray.filled(), header=hdr,
character_as_bytes=character_as_bytes)
for col in table_hdu.columns:
# Binary FITS tables support TNULL *only* for integer data columns
# TODO: Determine a schema for handling non-integer masked columns
# with non-default fill values in FITS (if at all possible).
int_formats = ('B', 'I', 'J', 'K')
if not (col.format in int_formats or
col.format.p_format in int_formats):
continue
fill_value = tarray[col.name].fill_value
col.null = fill_value.astype(int)
else:
table_hdu = BinTableHDU.from_columns(tarray, header=hdr,
character_as_bytes=character_as_bytes)
# Set units and format display for output HDU
for col in table_hdu.columns:
if table[col.name].info.format is not None:
# check for boolean types, special format case
logical = table[col.name].info.dtype == bool
tdisp_format = python_to_tdisp(table[col.name].info.format,
logical_dtype=logical)
if tdisp_format is not None:
col.disp = tdisp_format
unit = table[col.name].unit
if unit is not None:
# Local imports to avoid importing units when it is not required,
# e.g. for command-line scripts
from astropy.units import Unit
from astropy.units.format.fits import UnitScaleError
try:
col.unit = unit.to_string(format='fits')
except UnitScaleError:
scale = unit.scale
raise UnitScaleError(
f"The column '{col.name}' could not be stored in FITS "
f"format because it has a scale '({str(scale)})' that "
f"is not recognized by the FITS standard. Either scale "
f"the data or change the units.")
except ValueError:
# Warn that the unit is lost, but let the details depend on
# whether the column was serialized (because it was a
# quantity), since then the unit can be recovered by astropy.
warning = (
f"The unit '{unit.to_string()}' could not be saved in "
f"native FITS format ")
if any('SerializedColumn' in item and 'name: '+col.name in item
for item in table.meta.get('comments', [])):
warning += (
"and hence will be lost to non-astropy fits readers. "
"Within astropy, the unit can roundtrip using QTable, "
"though one has to enable the unit before reading.")
else:
warning += (
"and cannot be recovered in reading. If pyyaml is "
"installed, it can roundtrip within astropy by "
"using QTable both to write and read back, "
"though one has to enable the unit before reading.")
warnings.warn(warning, AstropyUserWarning)
else:
# Try creating a Unit to issue a warning if the unit is not
# FITS compliant
Unit(col.unit, format='fits', parse_strict='warn')
# Column-specific override keywords for coordinate columns
coord_meta = table.meta.pop('__coordinate_columns__', {})
for col_name, col_info in coord_meta.items():
col = table_hdu.columns[col_name]
# Set the column coordinate attributes from data saved earlier.
# Note: have to set these, even if we have no data.
for attr in 'coord_type', 'coord_unit':
setattr(col, attr, col_info.get(attr, None))
trpos = col_info.get('time_ref_pos', None)
if trpos is not None:
setattr(col, 'time_ref_pos', trpos)
for key, value in table.meta.items():
if is_column_keyword(key.upper()) or key.upper() in REMOVE_KEYWORDS:
warnings.warn(
f"Meta-data keyword {key} will be ignored since it conflicts "
f"with a FITS reserved keyword", AstropyUserWarning)
continue
# Convert to FITS format
if key == 'comments':
key = 'comment'
if isinstance(value, list):
for item in value:
try:
table_hdu.header.append((key, item))
except ValueError:
warnings.warn(
f"Attribute `{key}` of type {type(value)} cannot be "
f"added to FITS Header - skipping", AstropyUserWarning)
else:
try:
table_hdu.header[key] = value
except ValueError:
warnings.warn(
f"Attribute `{key}` of type {type(value)} cannot be "
f"added to FITS Header - skipping", AstropyUserWarning)
return table_hdu
# Token 0 -> Hola
# Token 1 -> ,
# Token 2-> Mundo
# Token 3 -> !
# ahora cambia el parseador, aceptando saludos con mas que una sola palabra antes que ','
saludo = Group(OneOrMore(Word(alphas))) + ',' + Word(alphas) + oneOf('! . ?')
tokens = saludo.parseString("Hasta mañana, Mundo !")
for i, token in enumerate(tokens):
print("Token %d -> %s" % (i, token))
# Ahora parseamos algunas cadenas, usando el metodo runTests
saludo.runTests("""\
Hola, Mundo!
Hasta mañana, Mundo !
""",
fullDump=False)
# Por supuesto, se pueden "reutilizar" gramáticas, por ejemplo:
numimag = Word(nums) + 'i'
numreal = Word(nums)
numcomplex = numreal + '+' + numimag
print(numcomplex.parseString("3+5i"))
# Cambiar a complejo numero durante parsear:
numcomplex.setParseAction(lambda t: complex(''.join(t).replace('i', 'j')))
print(numcomplex.parseString("3+5i"))
# Excelente!!, bueno, los dejo, me voy a seguir tirando código...
def hamiltonian_3nu_vacuum_energy_independent(s12,
s23,
s13,
dCP,
D21,
D31,
compute_matrix_multiplication=False
):
r"""Returns the three-neutrino Hamiltonian for vacuum oscillations.
Computes and returns the 3x3 complex three-neutrino Hamiltonian for
oscillations in vacuum, parametrized by three mixing angles ---
theta_12, theta_23, theta_13 --- one CP-violation phase --- delta_CP
--- and two mass-squared difference --- Delta m^2_21, Delta m^2_31.
The Hamiltonian is H = (1/2)*R.M2.R^dagger, with R the 3x3 PMNS
matrix and M2 the mass matrix. The multiplicative factor 1/E is not
applied.
Parameters
----------
s12 : float
Sin(theta_12).
s23 : float
Sin(theta_23).
s13 : float
Sin(theta_13).
D21 : float
Mass-squared difference Delta m^2_21.
D31 : float
Mass-squared difference Delta m^2_31.
compute_matrix_multiplication : bool, optional
If False (default), use the pre-computed expressions; otherwise,
multiply R.M2.R^dagger live.
Returns
-------
list
Hamiltonian 3x3 matrix.
"""
c12 = sqrt(1.0 - s12 * s12)
c23 = sqrt(1.0 - s23 * s23)
c13 = sqrt(1.0 - s13 * s13)
f = 1. / 2.
if not compute_matrix_multiplication:
# All Hij have units of [eV^2]
H00 = c13 * c13 * D21 * s12 * s12 + D31 * s13 * s13
H01 = c12*c13*c23*D21*s12 + \
c13*(D31-D21*s12*s12)*s13*s23*complex(cos(dCP),-sin(dCP))
H02 = c13*c23*(D31-D21*s12*s12)*s13*complex(cos(dCP),-sin(dCP)) - \
c12*c13*D21*s12*s23
H10 = c12*c13*c23*D21*s12 + \
c13*(D31-D21*s12*s12)*s13*s23*complex(cos(dCP),sin(dCP))
H11 = c12*c12*c23*c23*D21 + (c13*c13*D31 + D21*s12*s12*s13*s13)*s23*s23 - \
2.0*c12*c23*D21*s12*s13*s23*cos(dCP)
H12 = c13*c13*c23*D31*s23 + \
(c23*s12*s13*complex(cos(dCP),-sin(dCP)) + c12*s23) * \
(-c12*c23*D21 + D21*s12*s13*s23*complex(cos(dCP),sin(dCP)))
H20 = c13*c23*(D31-D21*s12*s12)*s13*complex(cos(dCP),sin(dCP)) - \
c12*c13*D21*s12*s23
H21 = c13*c13*c23*D31*s23 - \
D21*(c23*s12*s13*complex(cos(dCP),sin(dCP)) + c12*s23) * \
(c12*c23 - s12*s13*s23*complex(cos(dCP),-sin(dCP)))
H22 = c23*c23*(c13*c13*D31 + D21*s12*s12*s13*s13) + c12*c12*D21*s23*s23 + \
2.0*c12*c23*D21*s12*s13*s23*cos(dCP)
H = [[H00 * f, H01 * f, H02 * f], [H10 * f, H11 * f, H12 * f],
[H20 * f, H21 * f, H22 * f]]
else:
# PMNS matrix
R = np.array(pmns_mixing_matrix(s12, s23, s13, dCP))
# Mass matrix
M2 = np.array([[0.0, 0.0, 0.0], [0.0, D21, 0.0], [0.0, 0.0, D31]])
#scalar NSI matrix
#N = np.array([[0.0,0.0,0.0], [0.0,np.sqrt(D31)*0.1,0.0], [0.0,0.0,0.0]])
#H2 = list(f*np.matmul(R, np.matmul(N,np.conj(matrix.transpose(R)))))
#M1=M2+N
# Hamiltonian
H = list(
f * np.matmul(R, np.matmul(M2, np.conj(matrix.transpose(R))))
) #+np.array([[0.1,0.0,0.0], [0.0,0.1,0.0], [0.0,0.0,(f*D31*0.01)]])
return H
plt.xlabel('frequency [Hz]')
plt.ylabel('magnitude [dB]')
plt.xscale('log')
#%%
# this plots the raw values as they are stored in the trace
# TRACe:DATA
# the data are tuples of real and imag parts
# combine into complex array
# take abs value of complex and generate dB value with log10
freq = np.logspace(1, 4, len(disp_val))
real = raw_val[::2]
imag = raw_val[1::2]
comp = np.ndarray(len(real), dtype=complex)
for v in range(len(real)):
comp[v] = complex(real[v], imag[v])
magn = np.log10(np.abs(comp))
plt.figure(figsize=(8,5))
plt.plot(freq, magn)
plt.grid()
plt.xlabel('frequency [Hz]')
plt.ylabel('magnitude [dB]')
plt.xscale('log')
#plt.savefig('Network_Analyzer_Capacitor.png', dpi=200) # 200dpi -> 1600x1000
a1 = '10'
b1 = int(a1, base=10) # 将x转换为一个整数 base:进制
a2 = '101'
b2 = int(a2, 2)
a3 = '1234'
b3 = int(a3, 5)
a4 = '12334276'
b4 = int(a4, 8)
print(b1, b2, b3, b4)
a5 = 12
b5 = float(a5) # 将x转换到一个浮点数
print(b5) # 12.0
a6 = complex(1, 2)
print(a6) # (1+2j)
a7 = "www"
b7 = str(a7) # 将对象 x 转换为字符串 给用户看
print(b7) # www
print(isinstance(b7, str)) # True
a8 = "www"
b8 = repr(a8) # 将对象 x 转换为表达式字符串 给机器看
print(b8) # 'www'
print(isinstance(b8, str)) # True
a9 = 7
b8 = eval('3 * a9') # 用来简单计算在字符串中的有效Python表达式,并返回一个对象
def test_abs(self):
# zeros
for z in complex_zeros:
self.assertEqual(abs(z), 0.0)
# infinities
for z in complex_infinities:
self.assertEqual(abs(z), INF)
# real or imaginary part NaN
self.assertEqual(abs(complex(NAN, -INF)), INF)
self.assert_(math.isnan(abs(complex(NAN, -2.3))))
self.assert_(math.isnan(abs(complex(NAN, -0.0))))
self.assert_(math.isnan(abs(complex(NAN, 0.0))))
self.assert_(math.isnan(abs(complex(NAN, 2.3))))
self.assertEqual(abs(complex(NAN, INF)), INF)
self.assertEqual(abs(complex(-INF, NAN)), INF)
self.assert_(math.isnan(abs(complex(-2.3, NAN))))
self.assert_(math.isnan(abs(complex(-0.0, NAN))))
self.assert_(math.isnan(abs(complex(0.0, NAN))))
self.assert_(math.isnan(abs(complex(2.3, NAN))))
self.assertEqual(abs(complex(INF, NAN)), INF)
self.assert_(math.isnan(abs(complex(NAN, NAN))))
# result overflows
if float.__getformat__("double").startswith("IEEE"):
self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308))
def test_specific_values(self):
if not float.__getformat__("double").startswith("IEEE"):
return
def rect_complex(z):
"""Wrapped version of rect that accepts a complex number instead of
two float arguments."""
return cmath.rect(z.real, z.imag)
def polar_complex(z):
"""Wrapped version of polar that returns a complex number instead of
two floats."""
return complex(*polar(z))
for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):
arg = complex(ar, ai)
expected = complex(er, ei)
if fn == 'rect':
function = rect_complex
elif fn == 'polar':
function = polar_complex
else:
function = getattr(cmath, fn)
if 'divide-by-zero' in flags or 'invalid' in flags:
try:
actual = function(arg)
except ValueError:
continue
else:
test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)
self.fail('ValueError not raised in test %s' % test_str)
if 'overflow' in flags:
try:
actual = function(arg)
except OverflowError:
continue
else:
test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)
self.fail('OverflowError not raised in test %s' % test_str)
actual = function(arg)
if 'ignore-real-sign' in flags:
actual = complex(abs(actual.real), actual.imag)
expected = complex(abs(expected.real), expected.imag)
if 'ignore-imag-sign' in flags:
actual = complex(actual.real, abs(actual.imag))
expected = complex(expected.real, abs(expected.imag))
# for the real part of the log function, we allow an
# absolute error of up to 2e-15.
if fn in ('log', 'log10'):
real_abs_err = 2e-15
else:
real_abs_err = 5e-323
if not (almostEqualF(
expected.real, actual.real, abs_err=real_abs_err)
and almostEqualF(expected.imag, actual.imag)):
error_message = (
"%s: %s(complex(%r, %r))\n" % (id, fn, ar, ai) +
"Expected: complex(%r, %r)\n" %
(expected.real, expected.imag) +
"Received: complex(%r, %r)\n" %
(actual.real, actual.imag) +
"Received value insufficiently close to expected value.")
self.fail(error_message)
def polar_complex(z):
"""Wrapped version of polar that returns a complex number instead of
two floats."""
return complex(*polar(z))
# The complex() function returns a complex number by specifying a real number and an imaginary number.
# z = x + jy
x1 = 2
y1 = 3
x2 = 4
y2 = 5
print("complex(x1, y1):", complex(x1, y1))
print("complex(x2, y2):", complex(x2, y2))
print("complex(x1, y1) + complex(x2, y2):", complex(x1, y1) + complex(x2, y2))
print("complex(\"2+3j\") + complex(\"2-3j\"):",
complex("2+3j") + complex("2-3j"))
"""
complex(x1, y1): (2+3j)
complex(x2, y2): (4+5j)
complex(x1, y1) + complex(x2, y2): (6+8j)
complex("2+3j") + complex("2-3j"): (4+0j)
"""
from test.test_support import run_unittest
from test.test_math import parse_testfile, test_file
import unittest
import os, sys
import cmath, math
from cmath import phase, polar, rect, pi
INF = float('inf')
NAN = float('nan')
complex_zeros = [complex(x, y) for x in [0.0, -0.0] for y in [0.0, -0.0]]
complex_infinities = [
complex(x, y) for x, y in [
(INF, 0.0), # 1st quadrant
(INF, 2.3),
(INF, INF),
(2.3, INF),
(0.0, INF),
(-0.0, INF), # 2nd quadrant
(-2.3, INF),
(-INF, INF),
(-INF, 2.3),
(-INF, 0.0),
(-INF, -0.0), # 3rd quadrant
(-INF, -2.3),
(-INF, -INF),
(-2.3, -INF),
(-0.0, -INF),
(0.0, -INF), # 4th quadrant
(2.3, -INF),
(INF, -INF),
# 1. 아래 문자열의 길이를 구해보세요.
q1 = "dk2jd923i1jdk2jd93jfd92jd918943jfd8923"
print(len(q1))
# 2. print 함수를 사용해서 아래와 같이 출력해보세요.
# apple;orange;banana;lemon
print('apple;orange;banana;lemon')
# 3. 화면에 * 기호 100개를 표시하세요.
print('*' * 100)
# 4. 문자열 "30" 을 각각 정수형, 실수형, 복소수형, 문자형으로 변환해보세요.
print(int('30'))
print(float('30'))
print(complex('30'))
print(str('30'))
# 5. 다음 문자열 "Niceman" 에서 "man" 문자열만 추출해보세요.
a = 'Niceman'
print(a[4:])
# 6. 다음 문자열을 거꾸로 출력해보세요. : "Strawberry"
a = 'Strawberry'
print(a[::-1])
# 7. 다음 문자열에서 '-'를 제거 후 출력하세요. : "010-7777-9999"
a = '010-7777-9999'
print(a.replace('-',' '))
#정규표현식
import re
data = zeros([N, N], int)
# two arrays of N evenly spaced intervals from -2 to 2
xcoords = linspace(-2, 2, N)
ycoords = linspace(-2, 2, N)
# enumerate function: https://docs.python.org/3/library/functions.html#enumerate
# see also: https://docs.python.org/2.3/whatsnew/section-enumerate.html
# saves iterator value in u and v
# saves coordinate value in x and y
for butts, x in enumerate(xcoords):
for craps, y in enumerate(ycoords):
# two complex numbers used
# c becomes the coordinates evaluated
z = complex(0, 0)
c = complex(x, y)
# up to 100 iterations of calculation
for iterations in range(max_iterations):
# calculate from 0 and reuse in each iteration after
z_prime = z**2 + c
z = z_prime
# if |z| is greater than 2, then you're done
# save the number of iterations to the data map
if abs(z) > 2.0:
data[craps, butts] = iterations
break
# output number of iterations on the grid
print(type(x))
print(type(y))
print(type(z))
print('---------------------')
# dalam tipe data number kita bisa konversikan ke tipe yang lain
# kecuali tipe data complex tidak bisa diconvert ke tipe data yang lain
x = 1
y = 2.8
z = 1j
a = float(x)
b = int(y)
c = complex(x)
print(a)
print(b)
print(c)
print(type(a))
print(type(b))
print(type(c))
print('----------------------')
# ada juga build in fungsi yang sudah ada di python yang kita harus
# import dulu contohnya random()
import random
def test_expressions():
# Test expressions by wrapping them in an RX gate for convenience
def _expr(expression, expected):
parse_equals("RX(" + expression + ") 0", RX(expected, 0))
# Decimals
_expr("+123", 123)
_expr("-123", -123)
_expr("123.456", 123.456)
_expr("+123.456", 123.456)
_expr("-123.456", -123.456)
# Exponential
_expr("1e3", 1000.0)
_expr("1.5e2", 150.0)
_expr("3.5919865395417361e-05", 3.5919865395417361e-05)
_expr("3.5919865395417361E-05", 3.5919865395417361e-05)
# Complex
_expr("123.456i", complex(0, 123.456))
_expr("+123.456i", complex(0, 123.456))
# Edge case: making the whole complex number negative makes the real part -0.0
_expr("-123.456i", complex(-0., -123.456))
_expr("777+123.456i", complex(777, 123.456))
_expr("777-123.456i", complex(777, -123.456))
_expr("+777-123.456i", complex(777, -123.456))
# Imaginary
_expr("i * 2", complex(0, 2))
_expr("2i", complex(0, 2))
_expr("1 ^ 2", 1)
# Pi
_expr("pi", np.pi)
_expr("pi / 2", np.pi / 2)
_expr("-pi / 2", np.pi / -2)
# Expressions
_expr("1+2", 3)
_expr("1-2", -1)
_expr("3*4", 12)
_expr("6/2", 3.0)
_expr("2^3", 8)
# Order of operations
_expr("3 + 6 * (5 + 4) / 3 - 7", 14.0)
_expr("3 ^ 2 + 5", 14)
# Functions
_expr("sin(0)", 0.0)
_expr("cos(0)", 1.0)
_expr("sqrt(4)", 2.0)
_expr("exp(0)", 1.0)
_expr("cis(0)", complex(1, 0))
# Unary precedence
# https://github.com/rigetticomputing/pyquil/issues/246
_expr("-3+4", 1)
_expr("-(3+4)", -7)
_expr("-(3-4)", 1)
_expr("-0.1423778799706841+0.5434363975682295i",
complex(-0.1423778799706841, 0.5434363975682295))
def dampingTest5():
a,b,c = complex(2.,2.),complex(2.,3.),1.
res = ev.damping(a,b,c)
check1 = str(res.real)=='-0.890659452156'
check2 = str(res.imag)=='-0.59646815482'
return check1 and check2
def dampingTest6():
a,b,c = complex(2.,2.),complex(2.,3.),complex(2.,4.)
res = ev.damping(a,b,c)
check1 = str(res.real)=='-0.506549632262'
check2 = str(res.imag)=='-0.0185075645167'
return check1 and check2
def dampingTest3():
a,b,c = 1.,complex(1.,1.),complex(1.,1.)
res = ev.damping(a,b,c)
check1 = str(res.real)=='-0.549342056734'
check2 = str(res.imag)=='-0.227544930281'
return check1 and check2
def dampingTest4():
a,b,c = complex(2.,2.),1.,1.
res = ev.damping(a,b,c)
check1 = str(res.real)=='-0.274671028367'
check2 = str(res.imag)=='0.113772465141'
return check1 and check2
def angle_of_vector(vector):
"""
Returns polar coordinate theta when vector is project on xy plane
"""
return np.angle(complex(*vector[:2]))
def dampingTest2():
a,b,c = 1.,1.,complex(1.,1.)
res = ev.damping(a,b,c)
check1 = str(res.real)=='-0.388443493508'
check2 = str(res.imag)=='0.160898563226'
return check1 and check2
# Title: 1a.py # Purpose: To compute mean square error (MSE) vs. number of components (N) for the signal given in part 2b of EE 321's Project 3 # Developers: Siddesh Sood, Shawn Boyd, Cameron Palmer # Last Modified: October 22, 2020 # Importing libraries import numpy as np import matplotlib.pyplot as plt import math as m # Defining constants PI = np.pi # Pi j = complex(0, 1) # A complex number e = m.e T = 2 # Period between pulses OMEGA = (2 * PI) / T # How many components to create and sum (a large number) N = 100 # Create an independent variable t to fit exactly one period T indep_var = np.array(np.arange(0, T, 0.01).tolist()) # An array of Ns. Set NMax to the maximum number of Ns you want your signals to go to NMax = 1000 NArray = np.array(np.arange(10, NMax, 10).tolist()) # Create the variable that will hold all signals signals = np.zeros((len(indep_var), len(NArray) + 1)) signals[:,
def parallel_to_serial(z: complex) -> complex:
"""Convert parallel impedance to serial impedance equivalent"""
z_sq_sum = z.real**2 + z.imag**2
# TODO: Fix divide by zero
return complex(z.real * z.imag**2 / z_sq_sum,
z.real**2 * z.imag / z_sq_sum)
import cmath
a = float(input('请输入一个实数字:'))
b = float(input('请输入一个虚数字:'))
num_sqrt = cmath.sqrt(complex(a, b))
print('{0:0.3f}+{1:0.3f}j的平方根为 {2:0.3f}+{3:0.3f}j'.format(
a, b, num_sqrt.real, num_sqrt.imag))
#求复数的平方根
def z(self) -> complex:
""" return the s value complex number """
return complex(self.re, self.im)
import matplotlib.cm as cm
def iter_count(C, max_iter):
X = C
for n in range(max_iter):
if abs(X) > 2.:
return n
X = X ** 2 + C
return max_iter
N = 512
max_iter = 64
xmin, xmax, ymin, ymax = -2.2, .8, -1.5, 1.5
X = numpy.linspace(xmin, xmax, N)
Y = numpy.linspace(ymin, ymax, N)
Z = numpy.empty((N, N))
for i, y in enumerate(Y):
for j, x in enumerate(X):
Z[i, j] = iter_count(complex(x, y), max_iter)
plot.imshow(Z,
cmap = cm.binary,
interpolation = 'bicubic',
extent=(xmin, xmax, ymin, ymax))
cb = plot.colorbar(orientation='horizontal', shrink=.75)
cb.set_label('iteration count')
plot.show()
a = 3.14e10
b = 5
print(int(a))
print(complex(a))
print(complex(a,b))
print(float(b))
print(a ** -2)
print(float(a))
print(b ** -2)
print(8/5)
print(8//5)
print(int(8/5))
print(4/2)
print(8.0//5)
print(8//5.0)
print("我叫%s今年%d岁"%('小明',12))
print('hello'.capitalize())
print(max('hello'))
def phase(a, b):
ap = a.pos
bp = b.pos
phase = -B * (0.5 * (ap[1] + bp[1]) * (bp[0] - ap[0]))
return -complex(cos(phase), sin(phase))
# c)Complex c = 6 + 9j print(type(c)) #Convert float to int a = 5.6 b = int(a) print(type(b)) print(b) #Convert int to float print(float(b)) #Convert to complex k = 6 print(complex(b,k)) #d) boolean(they are placed in numeric because true is 1 and false is 0) t = b<k print(t) f = b>k print(f) #boolean convert to int. print(int(t)) print(int(f)) # ----------------------------------------------------------------------------------------------- # # 3) Sequence #list #set
