def make_mass_matrix(robot): """ :param robot: :return: mass matrix """ I, m, l, r = robot.unpack() theta_1 = robot.q[0] theta_2 = robot.q[1] theta_3 = robot.q[2] M_11 = I[1][1] * s(theta_2) ** 2 + I[2][1] * s(theta_2 + theta_3) ** 2 + \ I[0][2] + I[1][2] * c(theta_2) ** 2 + \ I[1][2] * c(theta_2 + theta_3) ** 2 M_12 = 0 M_13 = 0 M_21 = 0 M_22 = I[1][0] + I[2][0] + m[2] * l[0] ** 2 + \ m[1] * r[0] ** 2 + m[1] ** 2 + \ 2 * m[2] * l[0] * r[1] * c(theta_3) M_23 = I[2][0] + m[2] * r[1] ** 2 + \ m[2] * l[0] * r[1] * c(theta_3) M_31 = 0 M_32 = I[2][0] + m[2] * r[1] ** 2 + \ m[2] * l[1] * r[1] * c(theta_3) M_33 = I[2][0] + m[2] * r[1]**2 M = np.matrix([[M_11, M_12, M_13], [M_21, M_22, M_23], [M_31, M_32, M_33]]) return M
def get_jacobian_matricies(robot): """ :param robot: :return: """ I, m, l, r = robot.unpack() theta_1 = robot.q[0] theta_2 = robot.q[1] theta_3 = robot.q[2] J_1 = np.zeros(shape=(6, 3)) J_1[5, 0] = 1 J_2 = np.matrix([[-r[0] * c(theta_2), 0, 0], [0, 0, 0], [0, -r[0], 0], [0, -1, 0], [-s(theta_2), 0, 0], [c(theta_2), 0, 0]]) J_3 = np.matrix([[l[1] * c(theta_2) - r[1] * c(theta_2 + theta_3), 0, 0], [0, l[0] * s(theta_1), 0], [0, -l[1] - l[0] * c(theta_3), -r[1]], [0, -1, -1], [-s(theta_2 + theta_3), 0, 0], [c(theta_2 + theta_3), 0, 0]]) return (J_1, J_2, J_3)
def b(x): if x > s(3) / 4: return b(s(3) / 2 - x) n = 0 n += pi - acos(x) - acos(s(3) / 2 - x) n *= 2 if x < 1 - s(3) / 2: n += 2 * acos(s(3) / 2 + x) return n / 2 / pi
def r_pintor_i(r_p, v_p, planet, t, t_prev): # From PCPF (planet centered/planet fixed) to PCI (planet centered inertial) rot_angle = -np.linalg.norm(planet.omega) * (t + t_prev) # rad L_pi = [[c(rot_angle), s(rot_angle), 0], [-s(rot_angle), c(rot_angle), 0], [0, 0, 1]] r_i = np.inner((L_pi), r_p) v_i = np.inner((L_pi), (v_p + np.cross(planet.omega, r_p))) return r_I, v_I
def data_job_retention(nSelected,nRunOver): """Calculate the retention for a data job""" from uncertainties import ufloat as u from math import sqrt as s nsel = u((nSelected,s(nSelected))) nrun = u((nRunOver,s(nRunOver))) out = nsel/nrun print "(", 100*out, ") %" return out
def mc_job_selection_efficiency(DecProdEff,DecProdEffErr,nSelected,nRunOver): """Calculate the selection efficiency for a MC job""" from uncertainties import ufloat as u from math import sqrt as s e_dpc = u((DecProdEff,DecProdEffErr)) nsel = u((nSelected,s(nSelected))) nrun = u((nRunOver,s(nRunOver))) out = e_dpc*nsel/nrun print "(", 100*out, ") %" return out
def alfadeltartor(R_RA_DEC): # From Geocentric Celestial Reference Frame (GCRF) to PCI (Planet Centered Inertial) R = R_RA_DEC[0] RA = R_RA_DEC[1] DEC = R_RA_DEC[2] x = R * c(DEC) * c(RA) y = R * c(DEC) * s(RA) z = R * s(DEC) return [x, y, z]
def selesaikan(a, b, c): a = float(a) b = float(b) c = float(c) D = (b**2) - (4 * a * c) if D > 0: x1 = (-b + s(D)) / (2 * a) x2 = (-b - s(D)) / (2 * a) hasil = (x1, x2) print(hasil) else: print("Determinan negatif. Persamaan tidak mempunyai akar real")
def r_intor_p(r_i, v_i, planet, t, t_prev): # From PCI (planet centered inertial) to PCPF (planet centered/planet fixed) rot_angle = np.linalg.norm(planet.omega) * (t + t_prev) # rad # print(t,rot_angle) L_pi = [[c(rot_angle), s(rot_angle), 0], [-s(rot_angle), c(rot_angle), 0], [0, 0, 1]] r_p = np.inner(L_pi, r_i) #V_pf_pci = v_i - np.cross(planet.omega, r_i); #planet relative velocity in PCI frame v_p = np.inner(L_pi, (v_i - np.cross(planet.omega, r_i))) return r_p, v_p
def latlongtoNED(H_LAN_LON): lon = H_LAN_LON[2] lat = H_LAN_LON[1] # Compute first in xyz coordinates(z: north pole, x - z plane: contains r, y: completes right - handed set) uDxyz = [-c(lat), 0, -s(lat)] uNxyz = [-s(lat), 0, c(lat)] uExyz = [0, 1, 0] # Rotate by longitude to change to PCPF frame L3 = [[c(lon), -s(lon), 0], [s(lon), c(lon), 0], [0, 0, 1]] uN = np.inner(L3, uNxyz) uE = np.inner(L3, uExyz) uD = np.inner(L3, uDxyz) return [uD, uN, uE]
def poseFromOdom(X0, Y0, THETA0, v, v_var, om, om_var): X = [] Y = [] THETA = [] X.append(X0) Y.append(Y0) THETA.append(THETA0) dt = 0.1 for i in range(1, len(v)): nv = np.random.normal(0, v_var) nom = np.random.normal(0, om_var) x = X[i - 1] + dt * c(THETA[i - 1]) * (v[i] + nv) y = Y[i - 1] + dt * s(THETA[i - 1]) * (v[i] + nv) theta = THETA[i - 1] + dt * (om[i] + nom) X.append(x) Y.append(y) THETA.append(theta) X = np.asarray(X) Y = np.asarray(Y) THETA = np.asarray(THETA) return (X, Y, THETA)
def latlongtor(LATLONGH, planet, alfa_g0, t, t0): #maybe need to add t_prev orbit #From Geodetic to PCI phi = LATLONGH[0] #geodetic latitude lam = LATLONGH[1] #longitude h = LATLONGH[2] #altitude a = planet.Rp_e b = planet.Rp_p e = (1 - b**2 / a**2)**0.5 alfa = lam + alfa_g0 + planet.omega[2] * (t - t0) const = a / (1 - e**2 * s(phi)**2) + h x = const * c(phi) * c(alfa) y = const * c(phi) * s(alfa) z = const * s(phi) return [x, y, z]
def rtolatlong(r_p, planet): # From PCPF to LLA through Bowring's method https://www.mathworks.com/help/aeroblks/ecefpositiontolla.html;jsessionid=2ae36964c7d5f2115d2c21286db0?nocookie=true x_p = r_p[0] y_p = r_p[1] z_p = r_p[2] f = (planet.Rp_e - planet.Rp_p) / planet.Rp_e # flattening e = (1 - (1 - f)**2) # ellipticity (NOTE = considered as square) r = (x_p**2 + y_p**2)**0.5 # Calculate initial guesses for reduced latitude (latr) and planet-detic latitude (latd) latr = at(z_p / ((1 - f) * r)) # reduced latitude latd = at((z_p + (e * (1 - f) * planet.Rp_e * s(latr)**3) / (1 - e)) / (r - e * planet.Rp_e * c(latr)**3)) # Recalculate reduced latitude based on planet-detic latitude latr2 = at((1 - f) * s(latd) / c(latd)) diff = latr - latr2 # Iterate until reduced latitude converges while diff > 1e-10: latr = latr2 latd = at((z_p + (e * (1 - f) * planet.Rp_e * s(latr)**3) / (1 - e)) / (r - e * planet.Rp_e * c(latr)**3)) latr2 = at((1 - f) * s(latd) / c(latd)) diff = latr - latr2 lat = latd #Calculate longitude lon = atan2(y_p, x_p) # -180<lon<180 #Calculate altitude N = planet.Rp_e / ( 1 - e * s(lat)**2)**0.5 # radius of curvature in the vertical prime alt = r * c(lat) + (z_p + e * N * s(lat)) * s(lat) - N return [alt, lat, lon]
def check(c): if c < 2: return False if c == 2: return True for i in range(2, int(s(c)) + 1): if c % i == 0: return False return True
def prime(p): if p == 2: return True if p < 2: return False for pp in range(2, int(s(p)) + 1): if p % pp == 0: return False return True
def isprime(n): count=0 if n<=1: return False if n==2 or n==3: return True else: for i in range(2, int(s(n))+1 ): if(n%i == 0): count=0 return False elif (n%i != 0): count+=1 if count == int(s(n))-1: count=0 return True
def primes_to_max(self): mark_set = set() prime_list = [] for v in range(2, self.num + 1): if v not in mark_set: prime_list.append(v) if v <= s(self.num): time = 2 while v * time <= self.num: mark_set.add(v * time) time += 1 return prime_list
def update_states(self, ft, tx, ty, tz): roll_ddot = ((self.Iy - self.Iz) / self.Ix) * (self.pitch_dot * self.yaw_dot) + tx / self.Ix pitch_ddot = ((self.Iz - self.Ix) / self.Iy) * (self.roll_dot * self.yaw_dot) + ty / self.Iy yaw_ddot = ((self.Ix - self.Iy) / self.Iz) * (self.roll_dot * self.pitch_dot) + tz / self.Iz x_ddot = -(ft / self.m) * (s(self.roll) * s(self.yaw) + c(self.roll) * c(self.yaw) * s(self.pitch)) y_ddot = -(ft / self.m) * (c(self.roll) * s(self.yaw) * s(self.pitch) - c(self.yaw) * s(self.roll)) z_ddot = -1 * (self.g - (ft / self.m) * (c(self.roll) * c(self.pitch))) self.roll_dot += roll_ddot * DT self.roll += self.roll_dot * DT self.pitch_dot += pitch_ddot * DT self.pitch += self.pitch_dot * DT self.yaw_dot += yaw_ddot * DT self.yaw += self.yaw_dot * DT self.x_dot += x_ddot * DT self.x += self.x_dot * DT self.y_dot += y_ddot * DT self.y += self.y_dot * DT self.z_dot += z_ddot * DT self.z += self.z_dot * DT self.states = np.array([ self.roll, self.pitch, self.yaw, self.roll_dot, self.pitch_dot, self.yaw_dot, self.x_dot, self.y_dot, self.z_dot, self.x, self.y, self.z ]).T self.record_states()
def from_dh(dh_params): d, theta, a, alpha = dh_params return Frame( np.array([[ c(theta), -s(theta) * c(alpha), s(theta) * s(alpha), a * c(theta) ], [ s(theta), c(theta) * c(alpha), -c(theta) * s(alpha), a * s(theta) ], [0., s(alpha), c(alpha), d], [0., 0., 0., 1.]]))
def factorization(n): a=[] while n%2==0: a.append(2) n = n//2 for i in range(3,int(s(n))+1,2): while n%i==0: a.append(i) n = n//i if n>2: a.append(n) return a
def color3(h1): h = h1*s(3) w = h1*3 f = open("hex4.txt",'r') l = list(map(list,f.read().split("\n"))) r = len(l) c = len(l[0]) for i in range(len(l)): l[i] = list(map(int,l[i])) pairs = pairs_helper.rect_pixel_pairs(w,h,r,c,True) massignment = [[0 for i in range(c)] for j in range(r)] a = total_cost(pairs,l,r,c) b = total_cost(pairs,massignment,r,c) print(w/3, a/b)
def fk(robot): """ :param robot: :return: """ I, m, l, r = robot.unpack() theta_1 = robot.q[0] theta_2 = robot.q[1] theta_3 = robot.q[2] pose_1 = (0, 0, l[0]) pose_2 = (l[1] * c(theta_2) * c(theta_1), l[1] * c(theta_2) * c(theta_1), l[0] + l[2] * s(theta_2)) pose_3 = ( ( l[1]*c(theta_2) + l[2]*c(theta_2 + theta_3) )*c(theta_1), \ ( l[1]*c(theta_2) + l[2]*c(theta_2 + theta_3))*s(theta_1), \ ( l[0] + l[1]*s(theta_1) + l[2]*s(theta_2+theta_3)) ) return (pose_1, pose_2, pose_3)
def divisors(num): bottomHalf = set() div = set() for i in range(1, int(s(num)) + 1): if num % i == 0: bottomHalf.add(i) div.update(bottomHalf) for el in bottomHalf: div.add(num // el) div.remove(num) return div
def fk(joints): """ :param robot: :return: """ l = helper.get_lengths() theta_1 = joints[0] theta_2 = joints[1] theta_3 = joints[2] pose_1 = (0,0,l[0]) pose_2 = ( l[1]*c(theta_2)*c(theta_1), l[1]*c(theta_2)*s(theta_1), l[0] + l[2]*s(theta_2) ) pose_3 = ( ( l[1]*c(theta_2) + l[2]*c(theta_2 + theta_3) )*c(theta_1), \ ( l[1]*c(theta_2) + l[2]*c(theta_2 + theta_3))*s(theta_1), \ ( l[0] + l[1]*s(theta_2) + l[2]*s(theta_2+theta_3)) ) return pose_1, pose_2, pose_3
def from_dh_modified(dh_params): d, theta, a, alpha = dh_params return Frame( np.array([[c(theta), -s(theta), 0, a], [ s(theta) * c(alpha), c(theta) * c(alpha), -s(alpha), -s(alpha) * d ], [ s(theta) * s(alpha), c(theta) * s(alpha), c(alpha), c(alpha) * d ], [0., 0., 0., 1.]]))
def ik(robot, pose): """ :param robot: :param pose: :return: """ I, m, l, r = robot.unpack x = pose[0] y = pose[1] z = pose[2] theta_1 = math.atan2(y,z) theta_3 = -math.ac( (x*x + y*y + (z- l[0])**2 -l[1]*l[1] - l[2]*l[2])/ ( 2*l[1]*l[2] ) ) - 0.5*math.pi theta_2 = math.atan2( z- l[0] , math.sqrt(x*x, y*y) ) - math.atan2( l[2]*s(theta_3), l[1] + l[2]*c(theta_3) ) return (theta_1, theta_2, theta_3)
def T(i, j): theta_i = math.radians(dh_table[i][3]) a_j = dh_table[j][1] alpha_j = math.radians(dh_table[j][0]) d_i = dh_table[i][2] return np.array([[c(theta_i), -s(theta_i), 0, a_j], [ c(alpha_j) * s(theta_i), c(alpha_j) * c(theta_i), -s(alpha_j), -d_i * s(alpha_j) ], [ s(alpha_j) * s(theta_i), s(alpha_j) * c(theta_i), c(alpha_j), d_i * c(alpha_j) ], [0, 0, 0, 1]])
#!/usr/bin/python3.4 from modularites.print import * from math import sqrt as s import random as rand p(s(16)) p(s(54)) p(rand.randrange(0, 60))
def f(): x1 = r() * s(3) / 2 angle = r() * 2 * pi x2 = x1 + cos(angle) x2 = x2 % (s(3) / 2) return b(x1) * b(x2)
from math import sqrt as s a=[True]*(10**12) a[0] = a[1] = False for i in range(2,10**12+1,2): a[i]=False for i in range(3,10**12+1,2): if a[i]: for j in range(i,10**12+1,i): a[i]=False #print(a) n=int(input()) x=list(map(int,input().split())) for i in x: if(a[s(i)]): print("YES") else: print("NO")
from math import sqrt as s def check(c): if c < 2: return False if c == 2: return True for i in range(2, int(s(c)) + 1): if c % i == 0: return False return True n = int(input()) for k in range(n): a = int(input()) if check(a): print(a) else: m = 2 for i in range(2, int(s(a)) + 1): while a % i == 0: m = max(2, i) a //= i if check(a) and a > m: print(a) else: print(m)
import math as m print(m.pi) print(m.sqrt(4.0)) print(m.sqrt(2.0)) from math import pi, sqrt print(pi) print(sqrt(4.0)) print(sqrt(2.0)) from math import sqrt as s, pi as p print(p) print(s(4.0)) print(s(2.0)) import urllib.request as r response = r.urlopen('http://www.google.co.kr') print(response.status) from urllib.request import Request, urlopen req = Request('http://www.google.co.kr') response = urlopen(req) print(response.status) from urllib.request import Request as r, urlopen as u
#Generate a list of four digit numbers in a given range with all their digits even and the number is a perfect square. from math import sqrt as s n = int(input("Enter a limit:")) p = 0 for i in range(1000, n): if s(i) == int(s(i)) and i % 2 == 0: print(i)
#! /usr/bin/env python import math as m print m.sqrt(45) from math import sqrt as s print s(45)
import math print(math.sqrt(9)) from math import sqrt print(sqrt(9)) import math as m print(m.sqrt(9)) from math import sqrt as s print(s(9))
import math print(math.sqrt(16)) # lehet úgy is hogy csak azt az adott osztályt hívom be a modulból amire épp szüségem van: from math import sqrt print(math.sqrt(25)) # időtakarékos módszer, ha egyből példányosítom az osztályt: from math import sqrt as s print(s(36)) # mégegy módszer: import math as m print(m.sqrt(49)) # ... és mégegy: #from math import * # ez minden osztályt behív a modulból nem túl jó, mert pl. lehetnek névegyezések más modulokban lévő osztályokkal print(sqrt(64)) help(math.sqrt)
''' We can re-define a function or class while importing ''' from math import sum as s print('Sum: ', s(3, 4))
import math as m # m ist neu der Name des mathematischen Module v = m.sin(m.pi) print v from math import log as ln v = ln(5) print v from math import sin as s, cos as c, log as ln x = m.pi v = s(x)*c(x) + ln(x) print v