# Python math.pi() Examples

The following are 30 code examples of math.pi(). 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: minitaur_gym_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _get_observation_upper_bound(self):
"""Get the upper bound of the observation.

Returns:
The upper bound of an observation. See GetObservation() for the details
of each element of an observation.
"""
upper_bound = np.zeros(self._get_observation_dimension())
num_motors = self.minitaur.num_motors
upper_bound[0:num_motors] = math.pi  # Joint angle.
upper_bound[num_motors:2 * num_motors] = (
motor.MOTOR_SPEED_LIMIT)  # Joint velocity.
upper_bound[2 * num_motors:3 * num_motors] = (
motor.OBSERVED_TORQUE_LIMIT)  # Joint torque.
upper_bound[3 * num_motors:] = 1.0  # Quaternion of base orientation.
return upper_bound ```
Example #4
 Source File: minitaur.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def MapToMinusPiToPi(angles):
"""Maps a list of angles to [-pi, pi].

Args:
angles: A list of angles in rad.
Returns:
A list of angle mapped to [-pi, pi].
"""
mapped_angles = copy.deepcopy(angles)
for i in range(len(angles)):
mapped_angles[i] = math.fmod(angles[i], TWO_PI)
if mapped_angles[i] >= math.pi:
mapped_angles[i] -= TWO_PI
elif mapped_angles[i] < -math.pi:
mapped_angles[i] += TWO_PI
return mapped_angles ```
Example #5
 Source File: minitaur_randomize_terrain_gym_env_example.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def ResetTerrainExample():
"""An example showing resetting random terrain env."""
num_reset = 10
steps = 100
env = minitaur_randomize_terrain_gym_env.MinitaurRandomizeTerrainGymEnv(
render=True,
leg_model_enabled=False,
motor_velocity_limit=np.inf,
pd_control_enabled=True)
action = [math.pi / 2] * 8
for _ in xrange(num_reset):
env.reset()
for _ in xrange(steps):
_, _, done, _ = env.step(action)
if done:
break ```
Example #6
 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 #7
 Source File: minitaur_trotting_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _signal(self, t):
"""Generates the trotting gait for the robot.

Args:
t: Current time in simulation.

Returns:
A numpy array of the reference leg positions.
"""
# Generates the leg trajectories for the two digonal pair of legs.
ext_first_pair, sw_first_pair = self._gen_signal(t, 0)
ext_second_pair, sw_second_pair = self._gen_signal(t, math.pi)

trotting_signal = np.array([
sw_first_pair, sw_second_pair, sw_second_pair, sw_first_pair,
ext_first_pair, ext_second_pair, ext_second_pair, ext_first_pair
])
signal = np.array(self._init_pose) + trotting_signal
return signal ```
Example #8
 Source File: minitaur_ball_gym_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _get_observation(self):
world_translation_minitaur, world_rotation_minitaur = (
self._pybullet_client.getBasePositionAndOrientation(
world_translation_ball, world_rotation_ball = (
self._pybullet_client.getBasePositionAndOrientation(self._ball_id))
minitaur_translation_world, minitaur_rotation_world = (
self._pybullet_client.invertTransform(world_translation_minitaur,
world_rotation_minitaur))
minitaur_translation_ball, _ = (
self._pybullet_client.multiplyTransforms(minitaur_translation_world,
minitaur_rotation_world,
world_translation_ball,
world_rotation_ball))
distance = math.sqrt(minitaur_translation_ball[0]**2 +
minitaur_translation_ball[1]**2)
angle = math.atan2(minitaur_translation_ball[0],
minitaur_translation_ball[1])
self._observation = [angle - math.pi / 2, distance]
return self._observation ```
Example #9
 Source File: minitaur_reactive_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def _get_observation_upper_bound(self):
"""Get the upper bound of the observation.

Returns:
The upper bound of an observation. See _get_true_observation() for the
details of each element of an observation.
"""
upper_bound_roll = 2 * math.pi
upper_bound_pitch = 2 * math.pi
upper_bound_roll_dot = 2 * math.pi / self._time_step
upper_bound_pitch_dot = 2 * math.pi / self._time_step
upper_bound_motor_angle = 2 * math.pi
upper_bound = [
upper_bound_roll, upper_bound_pitch, upper_bound_roll_dot,
upper_bound_pitch_dot
]

if self._use_angle_in_observation:
upper_bound.extend([upper_bound_motor_angle] * NUM_MOTORS)
return np.array(upper_bound) ```
Example #10
 Source File: minitaur_gym_env_example.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def ResetPoseExample(log_path=None):
"""An example that the minitaur stands still using the reset pose."""
steps = 10000
environment = minitaur_gym_env.MinitaurGymEnv(
urdf_version=minitaur_gym_env.DERPY_V0_URDF_VERSION,
render=True,
leg_model_enabled=False,
motor_velocity_limit=np.inf,
pd_control_enabled=True,
accurate_motor_model_enabled=True,
motor_overheat_protection=True,
hard_reset=False,
log_path=log_path)
action = [math.pi / 2] * 8
for _ in range(steps):
_, _, done, _ = environment.step(action)
time.sleep(1./100.)
if done:
break ```
Example #11
 Source File: minitaur_terrain_randomizer.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def sample(self):
"""Samples new points around some existing point.

Removes the sampling base point and also stores the new jksampled points if
they are far enough from all existing points.
"""
active_point = self._active_list.pop()
for _ in xrange(self._max_sample_size):
# Generate random points near the current active_point between the radius
random_angle = np.random.uniform(0, 2 * math.pi)

# The sampled 2D points near the active point
[np.cos(random_angle), np.sin(random_angle)]) + active_point

if not self._is_in_grid(sample):
continue

if self._is_close_to_existing_points(sample):
continue

self._active_list.append(sample)
self._grid[self._point_to_index_1d(sample)] = sample ```
Example #12
 Source File: minitaur_gym_env_example.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def ResetPoseExample():
"""An example that the minitaur stands still using the reset pose."""
steps = 1000
randomizer = (minitaur_env_randomizer.MinitaurEnvRandomizer())
environment = minitaur_gym_env.MinitaurBulletEnv(
render=True,
leg_model_enabled=False,
motor_velocity_limit=np.inf,
pd_control_enabled=True,
accurate_motor_model_enabled=True,
motor_overheat_protection=True,
env_randomizer =  randomizer,
hard_reset=False)
action = [math.pi / 2] * 8
for _ in range(steps):
_, _, done, _ = environment.step(action)
if done:
break
environment.reset() ```
Example #13
 Source File: minitaur.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def ConvertFromLegModel(self, actions):
"""Convert the actions that use leg model to the real motor actions.

Args:
actions: The theta, phi of the leg model.
Returns:
The eight desired motor angles that can be used in ApplyActions().
"""

motor_angle = copy.deepcopy(actions)
scale_for_singularity = 1
offset_for_singularity = 1.5
half_num_motors = int(self.num_motors / 2)
quater_pi = math.pi / 4
for i in range(self.num_motors):
action_idx = i // 2
forward_backward_component = (-scale_for_singularity * quater_pi * (
actions[action_idx + half_num_motors] + offset_for_singularity))
extension_component = (-1)**i * quater_pi * actions[action_idx]
if i >= half_num_motors:
extension_component = -extension_component
motor_angle[i] = (
math.pi + forward_backward_component + extension_component)
return motor_angle ```
Example #14
 Source File: kuka.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def __init__(self, urdfRootPath=pybullet_data.getDataPath(), timeStep=0.01):
self.urdfRootPath = urdfRootPath
self.timeStep = timeStep
self.maxVelocity = .35
self.maxForce = 200.
self.fingerAForce = 2
self.fingerBForce = 2.5
self.fingerTipForce = 2
self.useInverseKinematics = 1
self.useSimulation = 1
self.useNullSpace =21
self.useOrientation = 1
self.kukaEndEffectorIndex = 6
self.kukaGripperIndex = 7
#lower limits for null space
self.ll=[-.967,-2 ,-2.96,0.19,-2.96,-2.09,-3.05]
#upper limits for null space
self.ul=[.967,2 ,2.96,2.29,2.96,2.09,3.05]
#joint ranges for null space
self.jr=[5.8,4,5.8,4,5.8,4,6]
#restposes for null space
self.rp=[0,0,0,0.5*math.pi,0,-math.pi*0.5*0.66,0]
#joint damping coefficents
self.jd=[0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001,0.00001]
self.reset() ```
Example #15
 Source File: test_pybullet_sim_gym_env.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def ResetPoseExample(steps):
"""An example that the minitaur stands still using the reset pose."""

environment = pybullet_sim_gym_env.PyBulletSimGymEnv(
pybullet_sim_factory=boxstack_pybullet_sim,
debug_visualization=False,
render=True, action_repeat=30)
action = [math.pi / 2] * 8

vid = video_recorder.VideoRecorder(env=environment,path="vid.mp4")

for _ in range(steps):
print(_)
startsim = time.time()
_, _, done, _ = environment.step(action)
stopsim = time.time()
startrender = time.time()
#environment.render(mode='rgb_array')
vid.capture_frame()
stoprender = time.time()
print ("env.step " , (stopsim - startsim))
print ("env.render " , (stoprender - startrender))
if done:
environment.reset() ```
Example #16
```def calculate_camera_variables(eye, lookat, up, fov, aspect_ratio, fov_is_vertical=False):
import numpy as np
import math

W = np.array(lookat) - np.array(eye)
wlen = np.linalg.norm(W)
U = np.cross(W, np.array(up))
U /= np.linalg.norm(U)
V = np.cross(U, W)
V /= np.linalg.norm(V)

if fov_is_vertical:
vlen = wlen * math.tan(0.5 * fov * math.pi / 180.0)
V *= vlen
ulen = vlen * aspect_ratio
U *= ulen
else:
ulen = wlen * math.tan(0.5 * fov * math.pi / 180.0)
U *= ulen
vlen = ulen * aspect_ratio
V *= vlen

return U, V, W ```
Example #17
```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 #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
 Source File: kaldi.py    From audio with BSD 2-Clause "Simplified" License 6 votes
```def _feature_window_function(window_type: str,
window_size: int,
blackman_coeff: float,
device: torch.device,
dtype: int,
) -> Tensor:
r"""Returns a window function with the given type and size
"""
if window_type == HANNING:
elif window_type == HAMMING:
elif window_type == POVEY:
# like hanning but goes to zero at edges
elif window_type == RECTANGULAR:
elif window_type == BLACKMAN:
a = 2 * math.pi / (window_size - 1)
window_function = torch.arange(window_size, device=device, dtype=dtype)
# can't use torch.blackman_window as they use different coefficients
return (blackman_coeff - 0.5 * torch.cos(a * window_function) +
(0.5 - blackman_coeff) * torch.cos(2 * a * window_function)).to(device=device, dtype=dtype)
else:
raise Exception('Invalid window type ' + window_type) ```
Example #21
 Source File: transforms.py    From audio with BSD 2-Clause "Simplified" License 6 votes
```def _fade_in(self, waveform_length: int) -> Tensor:

fade = torch.sin(fade * math.pi - math.pi / 2) / 2 + 0.5

Example #22
```def tunnel(x, y, step):
speed = step / 100.0
x -= (u_width / 2)
y -= (u_height / 2)
xo = math.sin(step / 27.0) * 2
yo = math.cos(step / 18.0) * 2
x += xo
y += yo
if y == 0:
if x < 0:
angle = -(math.pi / 2)
else:
angle = (math.pi / 2)
else:
angle = math.atan(x / y)
if y > 0:
angle += math.pi
angle /= 2 * math.pi  # convert angle to 0...1 range
hyp = math.sqrt(math.pow(x, 2) + math.pow(y, 2))
angle += speed
depth = speed + (hyp / 10)
col1 = hue_to_rgb[step % 255]
col1 = (col1[0] * 0.8, col1[1] * 0.8, col1[2] * 0.8)
col2 = hue_to_rgb[step % 255]
col2 = (col2[0] * 0.3, col2[1] * 0.3, col2[2] * 0.3)
col = col1 if int(abs(angle * 6.0)) % 2 == 0 else col2
td = .3 if int(abs(depth * 3.0)) % 2 == 0 else 0
col = (col[0] + td, col[1] + td, col[2] + td)
return (col[0] * 255, col[1] * 255, col[2] * 255) ```
Example #23
 Source File: agent.py    From indras_net with GNU General Public License v3.0 5 votes
```def ratio_to_sin(ratio):
"""
Take a ratio of y to x and turn it into a sine.
"""
return sin(ratio * pi / 2) ```
Example #24
 Source File: grid_env.py    From indras_net with GNU General Public License v3.0 5 votes
```def get_angle(self, agent1, agent2, grid_view=None):
"""
Use two agents to find the angle they make, using their coordinates
"""
dy = abs(agent1.pos[Y] - agent2.pos[Y])
dx = abs(agent1.pos[X] - agent2.pos[X])
if(dy == 0):
return 180
if(dx == 0):
return 90
else:
angle = rad * (180 / math.pi)
return angle ```
Example #25
```def _transformTheta(self, theta):
# CONVERTING THETA { THETA' % 360}
theta = 0.0

theta = 0.0

theta = -math.pi/2

theta = math.pi/2

return theta ```
Example #26
```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 #27
 Source File: optimization.py    From cmrc2019 with Creative Commons Attribution Share Alike 4.0 International 5 votes
```def warmup_cosine(x, warmup=0.002):
if x < warmup:
return x/warmup
return 0.5 * (1.0 + torch.cos(math.pi * x)) ```
Example #28
 Source File: modeling.py    From cmrc2019 with Creative Commons Attribution Share Alike 4.0 International 5 votes
```def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):
0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
"""
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0))) ```
Example #29
```def warmup_cosine(x, warmup=0.002):
```def gelu(x):