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
math
, or try the search function
.

Example #1
Source File: Wave.py From BiblioPixelAnimations with MIT License | 7 votes |
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
Source File: demo.py From unicorn-hat-hd with MIT License | 6 votes |
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 #3
Source File: demo.py From unicorn-hat-hd with MIT License | 6 votes |
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 #4
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 x = math.cos(math.radians(angle)) y = math.sin(math.radians(angle)) return VectorSpace(x, y)
Example #5
Source File: geomath.py From AboveTustin with MIT License | 6 votes |
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
Source File: Wave.py From BiblioPixelAnimations with MIT License | 6 votes |
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 #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 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
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 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]])
Example #9
Source File: transform_utils.py From robosuite with MIT License | 6 votes |
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
Source File: rotate_iou.py From kitti-object-eval-python with MIT License | 6 votes |
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
Source File: shapes.py From symbolator with MIT License | 6 votes |
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)
Example #14
Source File: ball.py From QPong with Apache License 2.0 | 6 votes |
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()
Example #15
Source File: adsb-polar.py From dump1090-tools with ISC License | 6 votes |
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
Source File: adsb-polar-2.py From dump1090-tools with ISC License | 6 votes |
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: demo.py From unicorn-hat-hd with MIT License | 5 votes |
def blues_and_twos(x, y, step): x -= (u_width / 2) y -= (u_height / 2) scale = math.sin(step / 6.0) / 1.5 r = math.sin((x * scale) / 1.0) + math.cos((y * scale) / 1.0) b = math.sin(x * scale / 2.0) + math.cos(y * scale / 2.0) g = r - .8 g = 0 if g < 0 else g b -= r b /= 1.4 return (r * 255, (b + g) * 255, g * 255) # rainbow search spotlights
Example #18
Source File: demo.py From unicorn-hat-hd with MIT License | 5 votes |
def rainbow_search(x, y, step): xs = math.sin((step) / 100.0) * 20.0 ys = math.cos((step) / 100.0) * 20.0 scale = ((math.sin(step / 60.0) + 1.0) / 5.0) + 0.2 r = math.sin((x + xs) * scale) + math.cos((y + xs) * scale) g = math.sin((x + xs) * scale) + math.cos((y + ys) * scale) b = math.sin((x + ys) * scale) + math.cos((y + ys) * scale) return (r * 255, g * 255, b * 255) # zoom tunnel
Example #19
Source File: demo.py From unicorn-hat-hd with MIT License | 5 votes |
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)) shade = hyp / 2.1 shade = 1 if shade > 1 else shade 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) col = (col[0] * shade, col[1] * shade, col[2] * shade) return (col[0] * 255, col[1] * 255, col[2] * 255)
Example #20
Source File: space.py From indras_net with GNU General Public License v3.0 | 5 votes |
def point_from_vector(self, angle, max_move, xy, vector_start=(0, 0)): """ Given a vector with one end at the origin, find the other end -- if off grid, pull it back onto the grid. """ (prev_x, prev_y) = xy (new_x, new_y) = xy # Calculate the new coordinates new_x += int(math.cos(math.radians(angle)) * max_move) new_y += int(math.sin(math.radians(angle)) * max_move) return self.constrain_x(new_x), self.constrain_y(new_y)
Example #21
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 #22
Source File: fashion.py From indras_net with GNU General Public License v3.0 | 5 votes |
def new_color_pref(old_pref, env_color): """ Calculate new color pref with the formula below: new_color = sin(avg(asin(old_pref) + asin(env_color))) """ me = math.asin(old_pref) env = math.asin(env_color) avg = np.average([me, env], weights=weightings) new_color = math.sin(avg) return new_color
Example #23
Source File: graph_layout.py From EDeN with MIT License | 5 votes |
def _compute_initial_pos(self, graph): _radius = 1 _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 #24
Source File: geometry.py From python-panavatar with MIT License | 5 votes |
def deform_wave(params): amplitude = params.img_scale * params.uniform('wave_amplitude', .1, 0.5) wavelength = params.img_scale * params.uniform('wave_wavelength', .2, 2.0) angle = params.uniform('wave_rotation', 1, 2 * math.pi) rotation = math.cos(angle) + 1J * math.sin(angle) direction = amplitude / rotation * 1J return lambda coord: (coord + direction * math.sin((coord * rotation).real / wavelength))
Example #25
Source File: util.py From neuropythy with GNU Affero General Public License v3.0 | 5 votes |
def spherical_distance(pt0, pt1): ''' spherical_distance(a, b) yields the angular distance between points a and b, both of which should be expressed in spherical coordinates as (longitude, latitude). If a and/or b are (2 x n) matrices, then the calculation is performed over all columns. The spherical_distance function uses the Haversine formula; accordingly it may suffer from rounding errors in the case of nearly antipodal points. ''' dtheta = pt1[0] - pt0[0] dphi = pt1[1] - pt0[1] a = np.sin(dphi/2)**2 + np.cos(pt0[1]) * np.cos(pt1[1]) * np.sin(dtheta/2)**2 return 2 * np.arcsin(np.sqrt(a))
Example #26
Source File: util.py From neuropythy with GNU Affero General Public License v3.0 | 5 votes |
def rotation_matrix_2D(th): ''' rotation_matrix_2D(th) yields a 2D numpy rotation matrix th radians counter-clockwise about the origin. ''' s = np.sin(th) c = np.cos(th) return np.array([[c, -s], [s, c]]) # construct a rotation matrix of vector u to vector b around center
Example #27
Source File: util.py From neuropythy with GNU Affero General Public License v3.0 | 5 votes |
def triangle_address(fx, pt): ''' triangle_address(FX, P) yields an address coordinate (t,r) for the point P in the triangle defined by the (3 x d)-sized coordinate matrix FX, in which each row of the matrix is the d-dimensional vector representing the respective triangle vertx for triangle [A,B,C]. The resulting coordinates (t,r) (0 <= t <= 1, 0 <= r <= 1) address the point P such that, if t gives the fraction of the angle from vector AB to vector AC that is made by the angle between vectors AB and AP, and r gives the fraction ||AP||/||AR|| where R is the point of intersection between lines AP and BC. If P is a (d x n)-sized matrix of points, then a (2 x n) matrix of addresses is returned. ''' fx = np.asarray(fx) pt = np.asarray(pt) # The triangle vectors... ab = fx[1] - fx[0] ac = fx[2] - fx[0] bc = fx[2] - fx[1] ap = np.asarray([pt_i - a_i for (pt_i, a_i) in zip(pt, fx[0])]) # get the unnormalized distance... r = np.sqrt((ap ** 2).sum(0)) # now we can find the angle... unit = 1 - r.astype(bool) t0 = vector_angle(ab, ac) t = vector_angle(ap + [ab_i * unit for ab_i in ab], ab) sint = np.sin(t) sindt = np.sin(t0 - t) # finding r0 is tricker--we use this fancy formula based on the law of sines q0 = np.sqrt((bc ** 2).sum(0)) # B->C distance beta = vector_angle(-ab, bc) # Angle at B sinGamma = np.sin(math.pi - beta - t0) sinBeta = np.sin(beta) r0 = q0 * sinBeta * sinGamma / (sinBeta * sindt + sinGamma * sint) return np.asarray([t/t0, r/r0])
Example #28
Source File: minitaur_evaluate.py From soccer-matlab with BSD 2-Clause "Simplified" License | 5 votes |
def evaluate_desired_motorAngle_8Amplitude8Phase(i, params): nMotors = 8 speed = 0.35 for jthMotor in range(nMotors): joint_values[jthMotor] = math.sin(i*speed + params[nMotors + jthMotor])*params[jthMotor]*+1.57 return joint_values
Example #29
Source File: minitaur_evaluate.py From soccer-matlab with BSD 2-Clause "Simplified" License | 5 votes |
def evaluate_desired_motorAngle_2Amplitude4Phase(i, params): speed = 0.35 phaseDiff = params[2] a0 = math.sin(i * speed) * params[0] + 1.57 a1 = math.sin(i * speed + phaseDiff) * params[1] + 1.57 a2 = math.sin(i * speed + params[3]) * params[0] + 1.57 a3 = math.sin(i * speed + params[3] + phaseDiff) * params[1] + 1.57 a4 = math.sin(i * speed + params[4] + phaseDiff) * params[1] + 1.57 a5 = math.sin(i * speed + params[4]) * params[0] + 1.57 a6 = math.sin(i * speed + params[5] + phaseDiff) * params[1] + 1.57 a7 = math.sin(i * speed + params[5]) * params[0] + 1.57 joint_values = [a0, a1, a2, a3, a4, a5, a6, a7] return joint_values
Example #30
Source File: minitaur_evaluate.py From soccer-matlab with BSD 2-Clause "Simplified" License | 5 votes |
def evaluate_desired_motorAngle_hop(i, params): amplitude = params[0] speed = params[1] a1 = math.sin(i*speed)*amplitude+1.57 a2 = math.sin(i*speed+3.14)*amplitude+1.57 joint_values = [a1, 1.57, a2, 1.57, 1.57, a1, 1.57, a2] return joint_values