def rotozoom(self, surface, angle, size):
"""
Return Surface rotated and resized by the given angle and size.
"""
if not angle:
width = int(surface.get_width() * size)
height = int(surface.get_height() * size)
return self.scale(surface, (width, height))
theta = angle * self.deg_rad
width_i = int(surface.get_width() * size)
height_i = int(surface.get_height() * size)
cos_theta = _fabs(_cos(theta))
sin_theta = _fabs(_sin(theta))
width_f = int(_ceil((width_i * cos_theta) + (height_i * sin_theta)))
if width_f % 2:
width_f += 1
height_f = int(_ceil((width_i * sin_theta) + (height_i * cos_theta)))
if height_f % 2:
height_f += 1
surf = Surface((width_f, height_f))
surf.saveContext()
surf.translate(width_f / 2.0, height_f / 2.0)
surf.rotate(-theta)
surf.drawImage(surface.canvas, 0, 0, surface.get_width(),
surface.get_height(), -width_i / 2, -height_i / 2,
width_i, height_i)
surf.restoreContext()
return surf
def rotate(surface, angle):
"""
Return Surface rotated by the given angle.
"""
if not angle:
return surface.copy()
theta = angle * _deg_rad
width_i = surface.getWidth()
height_i = surface.getHeight()
cos_theta = _fabs(_cos(theta))
sin_theta = _fabs(_sin(theta))
width_f = int((width_i * cos_theta) + (height_i * sin_theta))
height_f = int((width_i * sin_theta) + (height_i * cos_theta))
surf = Surface((width_f, height_f), BufferedImage.TYPE_INT_ARGB)
at = AffineTransform()
at.translate(width_f / 2.0, height_f / 2.0)
at.rotate(-theta)
g2d = surf.createGraphics()
ot = g2d.getTransform()
g2d.setTransform(at)
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR)
g2d.drawImage(surface, -width_i // 2, -height_i // 2, None)
g2d.setTransform(ot)
g2d.dispose()
return surf
def rotozoom(surface, angle, size):
"""
Return Surface rotated and resized by the given angle and size.
"""
if not angle:
width = int(surface.getWidth() * size)
height = int(surface.getHeight() * size)
return scale(surface, (width, height))
theta = angle * _deg_rad
width_i = int(surface.getWidth() * size)
height_i = int(surface.getHeight() * size)
cos_theta = _fabs(_cos(theta))
sin_theta = _fabs(_sin(theta))
width_f = int(_ceil((width_i * cos_theta) + (height_i * sin_theta)))
if width_f % 2:
width_f += 1
height_f = int(_ceil((width_i * sin_theta) + (height_i * cos_theta)))
if height_f % 2:
height_f += 1
surf = Surface((width_f, height_f), BufferedImage.TYPE_INT_ARGB)
at = AffineTransform()
at.translate(width_f / 2.0, height_f / 2.0)
at.rotate(-theta)
g2d = surf.createGraphics()
ot = g2d.getTransform()
g2d.setTransform(at)
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR)
g2d.drawImage(surface, -width_i // 2, -height_i // 2, width_i, height_i,
None)
g2d.setTransform(ot)
g2d.dispose()
return surf
def rotozoom(self, surface, angle, size):
"""
Return Surface rotated and resized by the given angle and size.
"""
if not angle:
width = int(surface.getWidth()*size)
height = int(surface.getHeight()*size)
return self.scale(surface, (width, height))
theta = angle*self.deg_rad
width_i = int(surface.getWidth()*size)
height_i = int(surface.getHeight()*size)
cos_theta = _fabs( _cos(theta) )
sin_theta = _fabs( _sin(theta) )
width_f = int( _ceil((width_i*cos_theta)+(height_i*sin_theta)) )
if width_f % 2:
width_f += 1
height_f = int( _ceil((width_i*sin_theta)+(height_i*cos_theta)) )
if height_f % 2:
height_f += 1
surf = Surface((width_f,height_f), BufferedImage.TYPE_INT_ARGB)
at = AffineTransform()
at.translate(width_f/2, height_f/2)
at.rotate(-theta)
g2d = surf.createGraphics()
ot = g2d.getTransform()
g2d.setTransform(at)
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)
g2d.drawImage(surface, -width_i//2, -height_i//2, width_i, height_i, None)
g2d.setTransform(ot)
g2d.dispose()
return surf
def rotate(self, surface, angle):
"""
Return Surface rotated by the given angle.
"""
if not angle:
return surface.copy()
theta = angle*self.deg_rad
width_i = surface.getWidth()
height_i = surface.getHeight()
cos_theta = _fabs( _cos(theta) )
sin_theta = _fabs( _sin(theta) )
width_f = int( (width_i*cos_theta)+(height_i*sin_theta) )
height_f = int( (width_i*sin_theta)+(height_i*cos_theta) )
surf = Surface((width_f,height_f), BufferedImage.TYPE_INT_ARGB)
at = AffineTransform()
at.translate(width_f/2, height_f/2)
at.rotate(-theta)
g2d = surf.createGraphics()
ot = g2d.getTransform()
g2d.setTransform(at)
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)
g2d.drawImage(surface, -width_i//2, -height_i//2, None)
g2d.setTransform(ot)
g2d.dispose()
return surf
def rotozoom(self, surface, angle, size):
"""
Return Surface rotated and resized by the given angle and size.
"""
if not angle:
width = int(surface.get_width()*size)
height = int(surface.get_height()*size)
return self.scale(surface, (width, height))
theta = angle*self.deg_rad
width_i = int(surface.get_width()*size)
height_i = int(surface.get_height()*size)
cos_theta = _fabs( _cos(theta) )
sin_theta = _fabs( _sin(theta) )
width_f = int( _ceil((width_i*cos_theta)+(height_i*sin_theta)) )
if width_f % 2:
width_f += 1
height_f = int( _ceil((width_i*sin_theta)+(height_i*cos_theta)) )
if height_f % 2:
height_f += 1
surf = Surface((width_f,height_f))
surf.saveContext()
surf.translate(width_f/2.0, height_f/2.0)
surf.rotate(-theta)
surf.drawImage(surface.canvas, 0, 0, surface.get_width(), surface.get_height(), -width_i/2, -height_i/2, width_i, height_i)
surf.restoreContext()
return surf
def rotate(self, surface, angle):
"""
Return Surface rotated by the given angle.
"""
if not angle:
return surface.copy()
theta = angle * self.deg_rad
width_i = surface.get_width()
height_i = surface.get_height()
cos_theta = _fabs(_cos(theta))
sin_theta = _fabs(_sin(theta))
width_f = int((width_i * cos_theta) + (height_i * sin_theta))
height_f = int((width_i * sin_theta) + (height_i * cos_theta))
surf = Surface((width_f, height_f))
surf.saveContext()
surf.translate(width_f / 2.0, height_f / 2.0)
surf.rotate(-theta)
surf.drawImage(surface.canvas, -width_i / 2, -height_i / 2)
surf.restoreContext()
return surf
def rotate(self, surface, angle):
"""
Return Surface rotated by the given angle.
"""
if not angle:
return surface.copy()
theta = angle*self.deg_rad
width_i = surface.get_width()
height_i = surface.get_height()
cos_theta = _fabs( _cos(theta) )
sin_theta = _fabs( _sin(theta) )
width_f = int( (width_i*cos_theta)+(height_i*sin_theta) )
height_f = int( (width_i*sin_theta)+(height_i*cos_theta) )
surf = Surface((width_f,height_f))
surf.saveContext()
surf.translate(width_f/2.0, height_f/2.0)
surf.rotate(-theta)
surf.drawImage(surface.canvas, -width_i/2, -height_i/2)
surf.restoreContext()
return surf
def next_price(self):
"""Calculate and return a new price; use initial price on first call"""
if self._state.iter == 0:
# On first iteration use initial price
price = self._initial_price
else:
change = self._state.random.gauss(0.0, self._sigma)
price = _fabs(
self._state.last_price + self._state.last_price * change
)
if price < 0.1:
price = 0.1
self._state = _STATE(price, self._state.random, self._state.iter + 1)
return self._state.last_price
def _frac(x):
return _fabs(x - _floor(x))
def str(latlong):
"""Convert latitude/longitude information in various formats into a pretty printable Unicode string."""
if len(latlong) == 2:
return u'{0:f}\N{DEGREE SIGN}{1:s}, {2:f}\N{DEGREE SIGN}{3:s}'.format(
_fabs(latlong[0]), _ns(latlong[0]), _fabs(latlong[1]),
_ew(latlong[1]))
elif len(latlong) == 3:
return u'{0:f}\N{DEGREE SIGN}{1:s}, {2:f}\N{DEGREE SIGN}{3:s}, {4:.3f}m'.format(
_fabs(latlong[0]), _ns(latlong[0]), _fabs(latlong[1]),
_ew(latlong[1]), latlong[2])
elif len(latlong) == 4:
return u'{0:.0f}\N{DEGREE SIGN}{1:.4f}\'{2:s}, {3:.0f}\N{DEGREE SIGN}{4:.4f}\'{5:s}'.format(
_fabs(latlong[0]), latlong[1], _ns(latlong[0]), _fabs(latlong[2]),
latlong[3], _ew(latlong[2]))
elif len(latlong) == 5:
return u'{0:.0f}\N{DEGREE SIGN}{1:.4f}\'{2:s}, {3:.0f}\N{DEGREE SIGN}{4:.4f}\'{5:s}, {6:.3f}m'.format(
_fabs(latlong[0]), latlong[1], _ns(latlong[0]), _fabs(latlong[2]),
latlong[3], _ew(latlong[2]), latlong[4])
elif len(latlong) == 6:
return u'{0:.0f}\N{DEGREE SIGN}{1:.0f}\'{2:.2f}"{3:s}, {4:.0f}\N{DEGREE SIGN}{5:.0f}\'{6:.2f}"{7:s}'.format(
_fabs(latlong[0]), latlong[1], latlong[2], _ns(latlong[0]),
_fabs(latlong[3]), latlong[4], latlong[5], _ew(latlong[3]))
elif len(latlong) == 7:
return u'{0:.0f}\N{DEGREE SIGN}{1:.0f}\'{2:.2f}"{3:s}, {4:.0f}\N{DEGREE SIGN}{5:.0f}\'{6:.2f}"{7:s}, {8:.3f}m'.format(
_fabs(latlong[0]), latlong[1], latlong[2], _ns(latlong[0]),
_fabs(latlong[3]), latlong[4], latlong[5], _ew(latlong[3]),
latlong[6])
else:
raise ValueError('Incorrect format for latitude/longitude data')
def binomialvariate(self, n=1, p=0.5):
"""Binomial random variable.
Gives the number of successes for *n* independent trials
with the probability of success in each trial being *p*:
sum(random() < p for i in range(n))
Returns an integer in the range: 0 <= X <= n
"""
# Error check inputs and handle edge cases
if n < 0:
raise ValueError("n must be non-negative")
if p <= 0.0 or p >= 1.0:
if p == 0.0:
return 0
if p == 1.0:
return n
raise ValueError("p must be in the range 0.0 <= p <= 1.0")
random = self.random
# Fast path for a common case
if n == 1:
return _index(random() < p)
# Exploit symmetry to establish: p <= 0.5
if p > 0.5:
return n - self.binomialvariate(n, 1.0 - p)
if n * p < 10.0:
# BG: Geometric method by Devroye with running time of O(np).
# https://dl.acm.org/doi/pdf/10.1145/42372.42381
x = y = 0
c = _log(1.0 - p)
if not c:
return x
while True:
y += _floor(_log(random()) / c) + 1
if y > n:
return x
x += 1
# BTRS: Transformed rejection with squeeze method by Wolfgang Hörmann
# https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.47.8407&rep=rep1&type=pdf
assert n * p >= 10.0 and p <= 0.5
setup_complete = False
spq = _sqrt(n * p *
(1.0 - p)) # Standard deviation of the distribution
b = 1.15 + 2.53 * spq
a = -0.0873 + 0.0248 * b + 0.01 * p
c = n * p + 0.5
vr = 0.92 - 4.2 / b
while True:
u = random()
v = random()
u -= 0.5
us = 0.5 - _fabs(u)
k = _floor((2.0 * a / us + b) * u + c)
if k < 0 or k > n:
continue
# The early-out "squeeze" test substantially reduces
# the number of acceptance condition evaluations.
if us >= 0.07 and v <= vr:
return k
# Acceptance-rejection test.
# Note, the original paper errorneously omits the call to log(v)
# when comparing to the log of the rescaled binomial distribution.
if not setup_complete:
alpha = (2.83 + 5.1 / b) * spq
lpq = _log(p / (1.0 - p))
m = _floor((n + 1) * p) # Mode of the distribution
h = _lgamma(m + 1) + _lgamma(n - m + 1)
setup_complete = True # Only needs to be done once
v *= alpha / (a / (us * us) + b)
if _log(v) <= h - _lgamma(k + 1) - _lgamma(n - k +
1) + (k - m) * lpq:
return k
