# Python math.cos() Examples

The following are 30 code examples of math.cos(). 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 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 #2
```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 #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
 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 #5
```def adjust_learning_rate(optimizer, epoch, args, batch=None,
nBatch=None, method='multistep'):
if method == 'cosine':
T_total = args.epochs * nBatch
T_cur = (epoch % args.epochs) * nBatch + batch
lr = 0.5 * args.lr * (1 + math.cos(math.pi * T_cur / T_total))
elif method == 'multistep':
if args.data.startswith('cifar'):
lr, decay_rate = args.lr, 0.1
if epoch >= args.epochs * 0.75:
lr *= decay_rate ** 2
elif epoch >= args.epochs * 0.5:
lr *= decay_rate
else:
lr = args.lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
return lr ```
Example #6
 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 #7
```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 #8
```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 #9
 Source File: minitaur_trotting_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _gen_signal(self, t, phase):
"""Generates a sinusoidal reference leg trajectory.

The foot (leg tip) will move in a ellipse specified by extension and swing
amplitude.

Args:
t: Current time in simulation.
phase: The phase offset for the periodic trajectory.

Returns:
The desired leg extension and swing angle at the current time.
"""
period = 1 / self._step_frequency
extension = self._extension_amplitude * math.cos(
2 * math.pi / period * t + phase)
swing = self._swing_amplitude * math.sin(2 * math.pi / period * t + phase)
return extension, swing ```
Example #10
```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 #11
 Source File: minitaur_alternating_legs_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _signal(self, t):
initial_pose = np.array([
INIT_SWING_POS, INIT_SWING_POS, INIT_SWING_POS, INIT_SWING_POS,
INIT_EXTENSION_POS, INIT_EXTENSION_POS, INIT_EXTENSION_POS,
INIT_EXTENSION_POS
])
amplitude = STEP_AMPLITUDE
period = STEP_PERIOD
extension = amplitude * (-1.0 + math.cos(2 * math.pi / period * t))
ith_leg = int(t / period) % 2
first_leg = np.array([0, 0, 0, 0, 0, extension, extension, 0])
second_leg = np.array([0, 0, 0, 0, extension, 0, 0, extension])
if ith_leg:
signal = initial_pose + second_leg
else:
signal = initial_pose + first_leg
return signal ```
Example #12
```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 #13
```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 #14
```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 #15
```def __call__(self, optimizer, i, epoch, best_pred):
T = epoch * self.iters_per_epoch + i
if self.mode == 'cos':
lr = 0.5 * self.lr * (1 + math.cos(1.0 * T / self.N * math.pi))
elif self.mode == 'poly':
lr = self.lr * pow((1 - 1.0 * T / self.N), 0.9)
elif self.mode == 'step':
lr = self.lr * (0.1 ** (epoch // self.lr_step))
else:
raise NotImplemented
# warm up lr schedule
if self.warmup_iters > 0 and T < self.warmup_iters:
lr = lr * 1.0 * T / self.warmup_iters
if epoch > self.epoch:
print('\n=>Epoches %i, learning rate = %.4f, \
previous best = %.4f' % (epoch, lr, best_pred))
self.epoch = epoch
assert lr >= 0
Example #16
```def _gaussian_noise_factor():
"""Return Gaussian noise of mean 0, std dev 1.

Returns
--------
Float samples from Gaussian distribution.

Examples
--------
>>> gaussian_noise_factor()
1.43412557975
>>> gaussian_noise_factor()
-0.0410900866765

"""
return math.sqrt(-2.0 * math.log(random())) * math.cos(2.0 * math.pi * random())

# Mutations

# @TODO: Implement all the common literal mutations. ```
Example #17
```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 #18
 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 #19
 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 #20
```def rotate_z(self, deg):
"""Rotate mesh around z-axis

:param float deg: Rotation angle (degree)
"""
mat = numpy.array([
[0, 0, 1, 0],
[0, 0, 0, 1]
])
self.vectors = self.vectors.dot(mat)
return self ```
Example #21
```def _cos(x):
return math.cos(x), ```
Example #22
```def rotate_y(self, deg):
"""Rotate mesh around y-axis

:param float deg: Rotation angle (degree)
"""
mat = numpy.array([
[0, 1, 0, 0],
[0, 0, 0, 1]
])
self.vectors = self.vectors.dot(mat)
return self ```
Example #23
 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 #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 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 #26
 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 #27
 Source File: graph_canvas.py    From networkx_viewer with GNU General Public License v3.0 5 votes
```def _spline_center(self, x1, y1, x2, y2, m):
"""Given the coordinate for the end points of a spline, calcuate
the mipdoint extruded out m pixles"""
a = (x2 + x1)/2
b = (y2 + y1)/2
beta = (pi/2) - atan2((y2-y1), (x2-x1))

xa = a - m*cos(beta)
ya = b + m*sin(beta)
return (xa, ya) ```
Example #28
```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 #29
```def get_lr(self):
return [self.eta_min + (base_lr - self.eta_min) * (1 + math.cos(math.pi * self.T_cur / self.T_i)) / 2
for base_lr in self.base_lrs] ```
Example #30
```def rotate(self,pt,midpt,angle):