本文整理汇总了Python中math.cos方法的典型用法代码示例。如果您正苦于以下问题:Python math.cos方法的具体用法?Python math.cos怎么用?Python math.cos使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类math
的用法示例。
在下文中一共展示了math.cos方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: swirl
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例2: checker
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例3: stance_pct_to_pre
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
x = math.cos(math.radians(angle))
y = math.sin(math.radians(angle))
return VectorSpace(x, y)
示例4: distance
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例5: distance
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
def distance(origin, destination):
"""Determine distance between 2 sets of [lat,lon] in km"""
lat1, lon1 = origin
lat2, lon2 = destination
radius = 6371 # km
dlat = math.radians(lat2 - lat1)
dlon = math.radians(lon2 - lon1)
a = (math.sin(dlat / 2) * math.sin(dlat / 2) +
math.cos(math.radians(lat1)) *
math.cos(math.radians(lat2)) * math.sin(dlon / 2) *
math.sin(dlon / 2))
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
d = radius * c
return d
示例6: rotation_matrix_3D
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
def rotation_matrix_3D(u, th):
"""
rotation_matrix_3D(u, t) yields a 3D numpy matrix that rotates any vector about the axis u
t radians counter-clockwise.
"""
# 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]])
示例7: _gen_signal
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例8: _signal
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例9: random_quat
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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,
)
示例10: rbbox_to_corners
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例11: __init__
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例12: _get_body
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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
示例13: rotate_bbox
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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]) )
a = -math.radians(a)
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)
示例14: update
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
def update(self):
radians = math.radians(self.direction)
self.x += self.speed * math.sin(radians)
self.y -= self.speed * math.cos(radians)
# 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()
示例15: _gaussian_noise_factor
# 需要导入模块: import math [as 别名]
# 或者: from math import cos [as 别名]
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.