# Python math.sin() Examples

The following are 30 code examples of math.sin(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
```def step(self, amt=1):
for i in range(self._size):
y = math.sin(
math.pi *
float(self.cycles) *
float(self._step * i) /
float(self._size))

if y >= 0.0:
# Peaks of sine wave are white
y = 1.0 - y  # Translate Y to 0.0 (top) to 1.0 (center)
r, g, b = self.palette(0)
c2 = (int(255 - float(255 - r) * y),
int(255 - float(255 - g) * y),
int(255 - float(255 - b) * y))
else:
# Troughs of sine wave are black
y += 1.0  # Translate Y to 0.0 (bottom) to 1.0 (center)
r, g, b = self.palette(0)
c2 = (int(float(r) * y),
int(float(g) * y),
int(float(b) * y))
self.layout.set(self._start + i, c2)

self._step += amt ```
Example #2
```def step(self, amt=1):
for i in range(self._size):
y = math.sin((math.pi * float(self.cycles) * float(i) / float(self._size)) + self._moveStep)

if y >= 0.0:
# Peaks of sine wave are white
y = 1.0 - y  # Translate Y to 0.0 (top) to 1.0 (center)
r, g, b = self.palette(0)
c2 = (int(255 - float(255 - r) * y), int(255 - float(255 - g) * y), int(255 - float(255 - b) * y))
else:
# Troughs of sine wave are black
y += 1.0  # Translate Y to 0.0 (bottom) to 1.0 (center)
r, g, b = self.palette(0)
c2 = (int(float(r) * y),
int(float(g) * y),
int(float(b) * y))
self.layout.set(self._start + i, c2)

self._moveStep += amt
self._moveStep += 1
if(self._moveStep >= self._size):
self._moveStep = 0 ```
Example #3
 Source File: vector_space.py    From indras_net with GNU General Public License v3.0 6 votes
```def stance_pct_to_pre(pct, x_or_y):
"""
pct is our % of the way to the y-axis from
the x-axis around the unit circle. (If x_or_y == Y, it is the opposite.)
It will return the x, y coordinates of the point that % of the way.
I.e., .5 returns NEUT_VEC, 0 returns X_VEC.
"""
if x_or_y == Y:
pct = 1 - pct
if pct == 0:
return VectorSpace.X_PRE
elif pct == .5:
return VectorSpace.NEUT_PRE
elif pct == 1:
return VectorSpace.Y_PRE
else:
angle = 90 * pct
return VectorSpace(x, y) ```
Example #4
```def swirl(x, y, step):
x -= (u_width / 2)
y -= (u_height / 2)
dist = math.sqrt(pow(x, 2) + pow(y, 2)) / 2.0
angle = (step / 10.0) + (dist * 1.5)
s = math.sin(angle)
c = math.cos(angle)
xs = x * c - y * s
ys = x * s + y * c
r = abs(xs + ys)
r = r * 12.0
r -= 20
return (r, r + (s * 130), r + (c * 130))

# roto-zooming checker board ```
Example #5
```def distance(pointA, pointB):
"""
Calculate the great circle distance between two points
on the earth (specified in decimal degrees)

http://stackoverflow.com/questions/15736995/how-can-i-quickly-estimate-the-distance-between-two-latitude-longitude-points
"""
# convert decimal degrees to radians
lon1, lat1, lon2, lat2 = map(math.radians, [pointA[1], pointA[0], pointB[1], pointB[0]])

# haversine formula
dlon = lon2 - lon1
dlat = lat2 - lat1
a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
c = 2 * math.asin(math.sqrt(a))
r = 3956  # Radius of earth in miles. Use 6371 for kilometers
return c * r ```
Example #6
```def checker(x, y, step):
x -= (u_width / 2)
y -= (u_height / 2)
angle = (step / 10.0)
s = math.sin(angle)
c = math.cos(angle)
xs = x * c - y * s
ys = x * s + y * c
xs -= math.sin(step / 200.0) * 40.0
ys -= math.cos(step / 200.0) * 40.0
scale = step % 20
scale /= 20
scale = (math.sin(step / 50.0) / 8.0) + 0.25
xs *= scale
ys *= scale
xo = abs(xs) - int(abs(xs))
yo = abs(ys) - int(abs(ys))
v = 0 if (math.floor(xs) + math.floor(ys)) % 2 else 1 if xo > .1 and yo > .1 else .5
r, g, b = hue_to_rgb[step % 255]
return (r * (v * 255), g * (v * 255), b * (v * 255))

# weeee waaaah ```
Example #7
 Source File: L.E.S.M.A. - Fabrica de Noobs Speedtest.py    From L.E.S.M.A with Apache License 2.0 6 votes
```def distance(origin, destination):
"""Determine distance between 2 sets of [lat,lon] in km"""

lat1, lon1 = origin
lat2, lon2 = destination

a = (math.sin(dlat / 2) * math.sin(dlat / 2) +
math.cos(math.radians(lat2)) * math.sin(dlon / 2) *
math.sin(dlon / 2))
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

return d ```
Example #8
 Source File: util.py    From neuropythy with GNU Affero General Public License v3.0 6 votes
```def rotation_matrix_3D(u, th):
"""
rotation_matrix_3D(u, t) yields a 3D numpy matrix that rotates any vector about the axis u
"""
# normalize the axis:
u = normalize(u)
# We use the Euler-Rodrigues formula;
# see https://en.wikipedia.org/wiki/Euler-Rodrigues_formula
a = math.cos(0.5 * th)
s = math.sin(0.5 * th)
(b, c, d) = -s * u
(a2, b2, c2, d2) = (a*a, b*b, c*c, d*d)
(bc, ad, ac, ab, bd, cd) = (b*c, a*d, a*c, a*b, b*d, c*d)
return np.array([[a2 + b2 - c2 - d2, 2*(bc + ad),         2*(bd - ac)],
[2*(bc - ad),       a2 + c2 - b2 - d2,   2*(cd + ab)],
[2*(bd + ac),       2*(cd - ab),         a2 + d2 - b2 - c2]]) ```
Example #9
```def random_quat(rand=None):
"""Return uniform random unit quaternion.
rand: array like or None
Three independent random variables that are uniformly distributed
between 0 and 1.
>>> q = random_quat()
>>> np.allclose(1.0, vector_norm(q))
True
>>> q = random_quat(np.random.random(3))
>>> q.shape
(4,)
"""
if rand is None:
rand = np.random.rand(3)
else:
assert len(rand) == 3
r1 = np.sqrt(1.0 - rand[0])
r2 = np.sqrt(rand[0])
pi2 = math.pi * 2.0
t1 = pi2 * rand[1]
t2 = pi2 * rand[2]
return np.array(
(np.sin(t1) * r1, np.cos(t1) * r1, np.sin(t2) * r2, np.cos(t2) * r2),
dtype=np.float32,
) ```
Example #10
```def rbbox_to_corners(corners, rbbox):
# generate clockwise corners and rotate it clockwise
angle = rbbox[4]
a_cos = math.cos(angle)
a_sin = math.sin(angle)
center_x = rbbox[0]
center_y = rbbox[1]
x_d = rbbox[2]
y_d = rbbox[3]
corners_x = cuda.local.array((4, ), dtype=numba.float32)
corners_y = cuda.local.array((4, ), dtype=numba.float32)
corners_x[0] = -x_d / 2
corners_x[1] = -x_d / 2
corners_x[2] = x_d / 2
corners_x[3] = x_d / 2
corners_y[0] = -y_d / 2
corners_y[1] = y_d / 2
corners_y[2] = y_d / 2
corners_y[3] = -y_d / 2
for i in range(4):
corners[2 *
i] = a_cos * corners_x[i] + a_sin * corners_y[i] + center_x
corners[2 * i
+ 1] = -a_sin * corners_x[i] + a_cos * corners_y[i] + center_y ```
Example #11
 Source File: loss.py    From torch-toolbox with BSD 3-Clause "New" or "Revised" License 6 votes
```def __init__(
self,
classes,
m=0.5,
s=64,
easy_margin=True,
weight=None,
size_average=None,
ignore_index=-100,
reduce=None,
reduction='mean'):
super(ArcLoss, self).__init__(weight, size_average, reduce, reduction)
self.ignore_index = ignore_index
assert s > 0.
assert 0 <= m <= (math.pi / 2)
self.s = s
self.m = m
self.cos_m = math.cos(m)
self.sin_m = math.sin(m)
self.mm = math.sin(math.pi - m) * m
self.threshold = math.cos(math.pi - m)
self.classes = classes
self.easy_margin = easy_margin ```
Example #12
 Source File: loss.py    From torch-toolbox with BSD 3-Clause "New" or "Revised" License 6 votes
```def _get_body(self, x, target):
cos_t = torch.gather(x, 1, target.unsqueeze(1))  # cos(theta_yi)
if self.easy_margin:
cond = torch.relu(cos_t)
else:
cond_v = cos_t - self.threshold
cond = torch.relu(cond_v)
cond = cond.bool()
# Apex would convert FP16 to FP32 here
# cos(theta_yi + m)
new_zy = torch.cos(torch.acos(cos_t) + self.m).type(cos_t.dtype)
if self.easy_margin:
zy_keep = cos_t
else:
zy_keep = cos_t - self.mm  # (cos(theta_yi) - sin(pi - m)*m)
new_zy = torch.where(cond, new_zy, zy_keep)
diff = new_zy - cos_t  # cos(theta_yi + m) - cos(theta_yi)
gt_one_hot = F.one_hot(target, num_classes=self.classes)
body = gt_one_hot * diff
return body ```
Example #13
```def rotate_bbox(box, a):
'''Rotate a bounding box 4-tuple by an angle in degrees'''
corners = ( (box[0], box[1]), (box[0], box[3]), (box[2], box[3]), (box[2], box[1]) )
sa = math.sin(a)
ca = math.cos(a)

rot = []
for p in corners:
rx = p[0]*ca + p[1]*sa
ry = -p[0]*sa + p[1]*ca
rot.append((rx,ry))

# Find the extrema of the rotated points
rot = list(zip(*rot))
rx0 = min(rot[0])
rx1 = max(rot[0])
ry0 = min(rot[1])
ry1 = max(rot[1])

#print('## RBB:', box, rot)

return (rx0, ry0, rx1, ry1) ```
Example #14
```def update(self):

# Update ball position
self.rect.x = self.x
self.rect.y = self.y

if self.y <= self.top_edge:
self.direction = (180-self.direction) % 360
self.sound.edge_sound.play()
if self.y > self.bottom_edge - 1*self.height:
self.direction = (180-self.direction) % 360
self.sound.edge_sound.play() ```
Example #15
```def latlngup_to_ecef(l):
"Converts L from WGS84 lat/long/up to ECEF"

lat = dtor(l[0])
lng = dtor(l[1])
alt = l[2]

slat = math.sin(lat)
slng = math.sin(lng)
clat = math.cos(lat)
clng = math.cos(lng)

d = math.sqrt(1 - (slat * slat * WGS84_ECC_SQ))
rn = WGS84_A / d

x = (rn + alt) * clat * clng
y = (rn + alt) * clat * slng
z = (rn * (1 - WGS84_ECC_SQ) + alt) * slat

return (x,y,z) ```
Example #16
```def latlngup_to_ecef(l):
"Converts L from WGS84 lat/long/up to ECEF"

lat = dtor(l[0])
lng = dtor(l[1])
alt = l[2]

slat = math.sin(lat)
slng = math.sin(lng)
clat = math.cos(lat)
clng = math.cos(lng)

d = math.sqrt(1 - (slat * slat * WGS84_ECC_SQ))
rn = WGS84_A / d

x = (rn + alt) * clat * clng
y = (rn + alt) * clat * slng
z = (rn * (1 - WGS84_ECC_SQ) + alt) * slat

return (x,y,z) ```
Example #17
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def bandreject_biquad(
waveform: Tensor,
sample_rate: int,
central_freq: float,
Q: float = 0.707
) -> Tensor:
r"""Design two-pole band-reject filter.  Similar to SoX implementation.

Args:
waveform (Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
central_freq (float): central frequency (in Hz)
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
https://www.w3.org/2011/audio/audio-eq-cookbook.html#APF
"""
w0 = 2 * math.pi * central_freq / sample_rate
alpha = math.sin(w0) / 2 / Q

b0 = 1.
b1 = -2 * math.cos(w0)
b2 = 1.
a0 = 1 + alpha
a1 = -2 * math.cos(w0)
a2 = 1 - alpha
return biquad(waveform, b0, b1, b2, a0, a1, a2) ```
Example #18
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def bandpass_biquad(
waveform: Tensor,
sample_rate: int,
central_freq: float,
Q: float = 0.707,
const_skirt_gain: bool = False
) -> Tensor:
r"""Design two-pole band-pass filter.  Similar to SoX implementation.

Args:
waveform (Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
central_freq (float): central frequency (in Hz)
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)
const_skirt_gain (bool, optional) : If ``True``, uses a constant skirt gain (peak gain = Q).
If ``False``, uses a constant 0dB peak gain. (Default: ``False``)

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
https://www.w3.org/2011/audio/audio-eq-cookbook.html#APF
"""
w0 = 2 * math.pi * central_freq / sample_rate
alpha = math.sin(w0) / 2 / Q

temp = math.sin(w0) / 2 if const_skirt_gain else alpha
b0 = temp
b1 = 0.
b2 = -temp
a0 = 1 + alpha
a1 = -2 * math.cos(w0)
a2 = 1 - alpha
return biquad(waveform, b0, b1, b2, a0, a1, a2) ```
Example #19
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def treble_biquad(
waveform: Tensor,
sample_rate: int,
gain: float,
central_freq: float = 3000,
Q: float = 0.707
) -> Tensor:
r"""Design a treble tone-control effect.  Similar to SoX implementation.

Args:
waveform (Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
gain (float): desired gain at the boost (or attenuation) in dB.
central_freq (float, optional): central frequency (in Hz). (Default: ``3000``)
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``).

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
https://www.w3.org/2011/audio/audio-eq-cookbook.html#APF
"""
w0 = 2 * math.pi * central_freq / sample_rate
alpha = math.sin(w0) / 2 / Q
A = math.exp(gain / 40 * math.log(10))

temp1 = 2 * math.sqrt(A) * alpha
temp2 = (A - 1) * math.cos(w0)
temp3 = (A + 1) * math.cos(w0)

b0 = A * ((A + 1) + temp2 + temp1)
b1 = -2 * A * ((A - 1) + temp3)
b2 = A * ((A + 1) + temp2 - temp1)
a0 = (A + 1) - temp2 + temp1
a1 = 2 * ((A - 1) - temp3)
a2 = (A + 1) - temp2 - temp1

return biquad(waveform, b0, b1, b2, a0, a1, a2) ```
Example #20
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def lowpass_biquad(
waveform: Tensor,
sample_rate: int,
cutoff_freq: float,
Q: float = 0.707
) -> Tensor:
r"""Design biquad lowpass filter and perform filtering.  Similar to SoX implementation.

Args:
waveform (torch.Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
cutoff_freq (float): filter cutoff frequency
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)

Returns:
Tensor: Waveform of dimension of `(..., time)`
"""
w0 = 2 * math.pi * cutoff_freq / sample_rate
alpha = math.sin(w0) / 2 / Q

b0 = (1 - math.cos(w0)) / 2
b1 = 1 - math.cos(w0)
b2 = b0
a0 = 1 + alpha
a1 = -2 * math.cos(w0)
a2 = 1 - alpha
return biquad(waveform, b0, b1, b2, a0, a1, a2) ```
Example #21
```def _compute_initial_pos(self, graph):
_offset = 0
n = len(graph)
pos = {id: np.array([_radius * math.cos(theta - math.pi / 2) + _offset,
_radius * math.sin(theta - math.pi / 2) + _offset]
)
for id, theta in enumerate(
np.linspace(0, 2 * math.pi * (1 - 1 / float(n)), num=n))}
return pos ```
Example #22
```def haversine_distance(self, lat1, lon1, lat2, lon2):
R = 6371.0088
dlon = lon2 - lon1
dlat = lat2 - lat1
a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
distance = R * c
return distance * 1000 ```
Example #23
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def allpass_biquad(
waveform: Tensor,
sample_rate: int,
central_freq: float,
Q: float = 0.707
) -> Tensor:
r"""Design two-pole all-pass filter.  Similar to SoX implementation.

Args:
waveform(torch.Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
central_freq (float): central frequency (in Hz)
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
https://www.w3.org/2011/audio/audio-eq-cookbook.html#APF
"""
w0 = 2 * math.pi * central_freq / sample_rate
alpha = math.sin(w0) / 2 / Q

b0 = 1 - alpha
b1 = -2 * math.cos(w0)
b2 = 1 + alpha
a0 = 1 + alpha
a1 = -2 * math.cos(w0)
a2 = 1 - alpha
return biquad(waveform, b0, b1, b2, a0, a1, a2) ```
Example #24
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def bass_biquad(
waveform: Tensor,
sample_rate: int,
gain: float,
central_freq: float = 100,
Q: float = 0.707
) -> Tensor:
r"""Design a bass tone-control effect.  Similar to SoX implementation.

Args:
waveform (Tensor): audio waveform of dimension of `(..., time)`
sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
gain (float): desired gain at the boost (or attenuation) in dB.
central_freq (float, optional): central frequency (in Hz). (Default: ``100``)
Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``).

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
https://www.w3.org/2011/audio/audio-eq-cookbook.html#APF
"""
w0 = 2 * math.pi * central_freq / sample_rate
alpha = math.sin(w0) / 2 / Q
A = math.exp(gain / 40 * math.log(10))

temp1 = 2 * math.sqrt(A) * alpha
temp2 = (A - 1) * math.cos(w0)
temp3 = (A + 1) * math.cos(w0)

b0 = A * ((A + 1) - temp2 + temp1)
b1 = 2 * A * ((A - 1) - temp3)
b2 = A * ((A + 1) - temp2 - temp1)
a0 = (A + 1) + temp2 + temp1
a1 = -2 * ((A - 1) + temp3)
a2 = (A + 1) + temp2 - temp1

return biquad(waveform, b0 / a0, b1 / a0, b2 / a0, a0 / a0, a1 / a0, a2 / a0) ```
Example #25
 Source File: functional.py    From audio with BSD 2-Clause "Simplified" License 5 votes
```def contrast(
waveform: Tensor,
enhancement_amount: float = 75.
) -> Tensor:
r"""Apply contrast effect.  Similar to SoX implementation.
Comparable with compression, this effect modifies an audio signal to make it sound louder

Args:
waveform (Tensor): audio waveform of dimension of `(..., time)`
enhancement_amount (float): controls the amount of the enhancement
Allowed range of values for enhancement_amount : 0-100
Note that enhancement_amount = 0 still gives a significant contrast enhancement

Returns:
Tensor: Waveform of dimension of `(..., time)`

References:
http://sox.sourceforge.net/sox.html
"""

if not 0 <= enhancement_amount <= 100:
raise ValueError("Allowed range of values for enhancement_amount : 0-100")

contrast = enhancement_amount / 750.

temp1 = waveform * (math.pi / 2)
temp2 = contrast * torch.sin(temp1 * 4)
output_waveform = torch.sin(temp1 + temp2)

return output_waveform ```
Example #26
 Source File: common.py    From sixcells with GNU General Public License v3.0 5 votes
```def hex1():
result = QPolygonF()
l = 0.5/cos30
for i in range(6):
a = i*tau/6 - tau/12
result.append(QPointF(l*math.sin(a), -l*math.cos(a)))
return result ```
Example #27
 Source File: common.py    From sixcells with GNU General Public License v3.0 5 votes
```def _cell_polys():
poly = QPolygonF()
l = 0.46/cos30
inner_poly = QPolygonF()
il = 0.75*l
for i in range(6):
a = i*tau/6 - tau/12
poly.append(QPointF(l*math.sin(a), -l*math.cos(a)))
inner_poly.append(QPointF(il*math.sin(a), -il*math.cos(a)))
return poly, inner_poly ```
Example #28
```def rotate_x(self, deg):
"""Rotate mesh around x-axis

:param float deg: Rotation angle (degree)
:return:
"""
mat = numpy.array([
[1, 0, 0, 0],
[0, 0, 0, 1]
])
self.vectors = self.vectors.dot(mat)
return self ```
Example #29
```def rotate(self,pt,midpt,angle):
import math
cosTheta = math.cos(angle*math.pi/180.0)
sinTheta = math.sin(angle*math.pi/180.0)
px = pt[0] - midpt[0]
py = pt[1] - midpt[1]
px_ = px*cosTheta - py*sinTheta
py_ = px*sinTheta + py*cosTheta
return (px_+midpt[0],py_+midpt[1]) ```
Example #30
```def rotate_y(self, deg):
"""Rotate mesh around y-axis

:param float deg: Rotation angle (degree)
"""