我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用math.sinh()。
def get(self): self.x += self.config.get('dx', 0.1) val = eval(self.config.get('function', 'sin(x)'), { 'sin': math.sin, 'sinh': math.sinh, 'cos': math.cos, 'cosh': math.cosh, 'tan': math.tan, 'tanh': math.tanh, 'asin': math.asin, 'acos': math.acos, 'atan': math.atan, 'asinh': math.asinh, 'acosh': math.acosh, 'atanh': math.atanh, 'log': math.log, 'abs': abs, 'e': math.e, 'pi': math.pi, 'x': self.x }) return self.createEvent('ok', 'Sine wave', val)
def _torsjonsvinkel(mast, j, fh, sign): """Beregner torsjonsvinkel i kontakttrådhøyde grunnet en eksentrisk horisontal last. Funksjonen beregner torsjonsvinkel i grader basert på følgende bjelkeformel: :math:`\\phi = \\frac{T}{2EC_w\\lambda} [\\frac{sinh(\\lambda(x-fh))-sinh(\\lambda x)}{cosh(\\lambda x)} + \\lambda*fh], \\ \\lambda = \\sqrt{\\frac{GI_T}{EC_w}}` :param Mast mast: Aktuell mast som beregnes :param Kraft j: Last som skal påføres ``mast`` :param float fh: Kontakttrådhøyde :math:`[m]` :param float sign: Fortegn for torsjonsmoment :return: Matrise med rotasjonsbidrag :math:`[^{\\circ}]` :rtype: :class:`numpy.array` """ D = numpy.zeros((5, 8, 3)) if j.e[0] < 0: if j.navn.startswith("Sidekraft: KL"): T = (j.f[1] * -j.e[2] + j.f[2] * j.e[1]) * 1000 else: T = sign*(abs(j.f[1] * -j.e[2]) + abs(j.f[2] * j.e[1])) * 1000 E = mast.E G = mast.G I_T = mast.It C_w = mast.Cw lam = math.sqrt(G * I_T / (E * C_w)) fh = fh * 1000 x = -j.e[0] * 1000 D[j.type[1], j.type[0], 2] = (180/math.pi) * T/(E*C_w*lam**3) * ((math.sinh(lam*(x-fh)) - math.sinh(lam*x))/math.cosh(lam*x) + lam*fh) return D
def toGeographic(self, x, y): x /= self.radius y /= self.radius D = y + self.lat_rad lon = atan(sinh(x) / cos(D)) lat = asin(sin(D) / cosh(x)) lon = self.lon + degrees(lon) lat = degrees(lat) return lat, lon
def Cn(l): alpha = acosh(l/r) s = 0. for n in range(1, 100): n = float(n) K = n*(n+1)/(2*n-1)/(2*n+3) s += K*((2*sinh((2*n+1)*alpha)+(2*n+1)*sinh(2*alpha))/(4*(sinh((n+.5)*alpha))**2-(2*n+1)**2*(sinh(alpha))**2) - 1) return 1./((4./3.)*sinh(alpha)*s)
def mercatorToLat(self, mercatorY): return(math.degrees(math.atan(math.sinh(mercatorY))))
def __init__(self, Hs,tp,L,z,d): self.u = Hs/2 * (g*tp/L) * math.cosh(2*pi*(z+d)/L) / (math.cosh(2*pi*d/L)) self.w = Hs/2 * (g*tp/L) * math.sinh(2*pi*(z+d)/L) / (math.cosh(2*pi*d/L)) self.ax = (g*pi*Hs/L) * math.cosh(2*pi*(z+d)/L) / (math.cosh(2*pi*d/L)) self.az = (g*pi*Hs/L) * math.sinh(2*pi*(z+d)/L) / (math.cosh(2*pi*d/L))
def csch(angle): if type(angle) in dtypes: return 1. / math.sinh(angle) return functor1(csch, angle)
def coth(angle): if type(angle) in dtypes: return math.cosh(angle) / math.sinh(angle) return functor1(coth, angle)
def test_trig_hyperb_basic(): for x in (list(range(100)) + list(range(-100,0))): t = x / 4.1 assert cos(mpf(t)).ae(math.cos(t)) assert sin(mpf(t)).ae(math.sin(t)) assert tan(mpf(t)).ae(math.tan(t)) assert cosh(mpf(t)).ae(math.cosh(t)) assert sinh(mpf(t)).ae(math.sinh(t)) assert tanh(mpf(t)).ae(math.tanh(t)) assert sin(1+1j).ae(cmath.sin(1+1j)) assert sin(-4-3.6j).ae(cmath.sin(-4-3.6j)) assert cos(1+1j).ae(cmath.cos(1+1j)) assert cos(-4-3.6j).ae(cmath.cos(-4-3.6j))
def test_complex_functions(): for x in (list(range(10)) + list(range(-10,0))): for y in (list(range(10)) + list(range(-10,0))): z = complex(x, y)/4.3 + 0.01j assert exp(mpc(z)).ae(cmath.exp(z)) assert log(mpc(z)).ae(cmath.log(z)) assert cos(mpc(z)).ae(cmath.cos(z)) assert sin(mpc(z)).ae(cmath.sin(z)) assert tan(mpc(z)).ae(cmath.tan(z)) assert sinh(mpc(z)).ae(cmath.sinh(z)) assert cosh(mpc(z)).ae(cmath.cosh(z)) assert tanh(mpc(z)).ae(cmath.tanh(z))
def test_complex_inverse_functions(): mp.dps = 15 iv.dps = 15 for (z1, z2) in random_complexes(30): # apparently cmath uses a different branch, so we # can't use it for comparison assert sinh(asinh(z1)).ae(z1) # assert acosh(z1).ae(cmath.acosh(z1)) assert atanh(z1).ae(cmath.atanh(z1)) assert atan(z1).ae(cmath.atan(z1)) # the reason we set a big eps here is that the cmath # functions are inaccurate assert asin(z1).ae(cmath.asin(z1), rel_eps=1e-12) assert acos(z1).ae(cmath.acos(z1), rel_eps=1e-12) one = mpf(1) for i in range(-9, 10, 3): for k in range(-9, 10, 3): a = 0.9*j*10**k + 0.8*one*10**i b = cos(acos(a)) assert b.ae(a) b = sin(asin(a)) assert b.ae(a) one = mpf(1) err = 2*10**-15 for i in range(-9, 9, 3): for k in range(-9, 9, 3): a = -0.9*10**k + j*0.8*one*10**i b = cosh(acosh(a)) assert b.ae(a, err) b = sinh(asinh(a)) assert b.ae(a, err)
def test_mpcfun_real_imag(): mp.dps = 15 x = mpf(0.3) y = mpf(0.4) assert exp(mpc(x,0)) == exp(x) assert exp(mpc(0,y)) == mpc(cos(y),sin(y)) assert cos(mpc(x,0)) == cos(x) assert sin(mpc(x,0)) == sin(x) assert cos(mpc(0,y)) == cosh(y) assert sin(mpc(0,y)) == mpc(0,sinh(y)) assert cospi(mpc(x,0)) == cospi(x) assert sinpi(mpc(x,0)) == sinpi(x) assert cospi(mpc(0,y)).ae(cosh(pi*y)) assert sinpi(mpc(0,y)).ae(mpc(0,sinh(pi*y))) c, s = cospi_sinpi(mpc(x,0)) assert c == cospi(x) assert s == sinpi(x) c, s = cospi_sinpi(mpc(0,y)) assert c.ae(cosh(pi*y)) assert s.ae(mpc(0,sinh(pi*y))) c, s = cos_sin(mpc(x,0)) assert c == cos(x) assert s == sin(x) c, s = cos_sin(mpc(0,y)) assert c == cosh(y) assert s == mpc(0,sinh(y))
def setptetaphim(self, pt, eta, phi, m): """ Set the transverse momentum, the pseudorapidity, the angle phi and the mass.""" px, py, pz = pt*cos(phi), pt*sin(phi), pt*sinh(eta) self.setpxpypzm(px,py,pz,m)
def setptetaphie(self, pt, eta, phi, e): """ Set the transverse momentum, the pseudorapidity, the angle phi and the energy.""" px, py, pz = pt*cos(phi), pt*sin(phi), pt*sinh(eta) self.setpxpypze(px,py,pz,e)
def testSinh(self): self.assertRaises(TypeError, math.sinh) self.ftest('sinh(0)', math.sinh(0), 0) self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) self.assertEqual(math.sinh(INF), INF) self.assertEqual(math.sinh(NINF), NINF) self.assertTrue(math.isnan(math.sinh(NAN)))
def sinh(a): """Elementwise hyperbolic sine.""" if not isSparseVector(a): raise TypeError("Argument must be a SparseVector") rv = SparseVector(a.n, {}) for k in a.values.keys(): rv.values[k] = math.sinh(a.values[k]) return rv
def S(V_max,E): S = math.sinh(((V_max-E)) / (TEMPERATURE*k)) return S
def sinh(node): return merge([node], math.sinh)
def sinh(self): out = copy.copy(self) out.surface = np.sinh(out.surface) return out
def analyticParitionFunctionValue(self, temperatureInKelvin): "Canonical Partition Function Value for this Hamiltonian" thermalEnergy = self.mySpace.unitHandler.BOLTZMANNS_CONSTANT_JOULES_PER_KELVIN * temperatureInKelvin thermalEnergy = self.mySpace.unitHandler.energyUnitsFromJoules(thermalEnergy) partitionEnergy = self.mySpace.hbar * self.omega * (.5) return 0.5 * math.sinh(partitionEnergy / thermalEnergy)**-1.0
def sin(x): z = _make_complex(x) z = sinh(complex(-z.imag, z.real)) return complex(z.imag, -z.real)
def cosh(x): _cosh_special = [ [inf+nanj, None, inf, complex(float("inf"), -0.0), None, inf+nanj, inf+nanj], [nan+nanj, None, None, None, None, nan+nanj, nan+nanj], [nan, None, 1, complex(1, -0.0), None, nan, nan], [nan, None, complex(1, -0.0), 1, None, nan, nan], [nan+nanj, None, None, None, None, nan+nanj, nan+nanj], [inf+nanj, None, complex(float("inf"), -0.0), inf, None, inf+nanj, inf+nanj], [nan+nanj, nan+nanj, nan, nan, nan+nanj, nan+nanj, nan+nanj] ] z = _make_complex(x) if not isfinite(z): if math.isinf(z.imag) and not math.isnan(z.real): raise ValueError if math.isinf(z.real) and math.isfinite(z.imag) and z.imag != 0: if z.real > 0: return complex(math.copysign(inf, math.cos(z.imag)), math.copysign(inf, math.sin(z.imag))) return complex(math.copysign(inf, math.cos(z.imag)), -math.copysign(inf, math.sin(z.imag))) return _cosh_special[_special_type(z.real)][_special_type(z.imag)] if abs(z.real) > _LOG_LARGE_DOUBLE: x_minus_one = z.real - math.copysign(1, z.real) ret = complex(e * math.cos(z.imag) * math.cosh(x_minus_one), e * math.sin(z.imag) * math.sinh(x_minus_one)) else: ret = complex(math.cos(z.imag) * math.cosh(z.real), math.sin(z.imag) * math.sinh(z.real)) if math.isinf(ret.real) or math.isinf(ret.imag): raise OverflowError return ret
def sinh(x): _sinh_special = [ [inf+nanj, None, complex(-float("inf"), -0.0), -inf, None, inf+nanj, inf+nanj], [nan+nanj, None, None, None, None, nan+nanj, nan+nanj], [nanj, None, complex(-0.0, -0.0), complex(-0.0, 0.0), None, nanj, nanj], [nanj, None, complex(0.0, -0.0), complex(0.0, 0.0), None, nanj, nanj], [nan+nanj, None, None, None, None, nan+nanj, nan+nanj], [inf+nanj, None, complex(float("inf"), -0.0), inf, None, inf+nanj, inf+nanj], [nan+nanj, nan+nanj, complex(float("nan"), -0.0), nan, nan+nanj, nan+nanj, nan+nanj] ] z = _make_complex(x) if not isfinite(z): if math.isinf(z.imag) and not math.isnan(z.real): raise ValueError if math.isinf(z.real) and math.isfinite(z.imag) and z.imag != 0: if z.real > 0: return complex(math.copysign(inf, math.cos(z.imag)), math.copysign(inf, math.sin(z.imag))) return complex(-math.copysign(inf, math.cos(z.imag)), math.copysign(inf, math.sin(z.imag))) return _sinh_special[_special_type(z.real)][_special_type(z.imag)] if abs(z.real) > _LOG_LARGE_DOUBLE: x_minus_one = z.real - math.copysign(1, z.real) return complex(math.cos(z.imag) * math.sinh(x_minus_one) * e, math.sin(z.imag) * math.cosh(x_minus_one) * e) return complex(math.cos(z.imag) * math.sinh(z.real), math.sin(z.imag) * math.cosh(z.real))
def test_complex_inverse_functions(): for (z1, z2) in random_complexes(30): # apparently cmath uses a different branch, so we # can't use it for comparison assert sinh(asinh(z1)).ae(z1) # assert acosh(z1).ae(cmath.acosh(z1)) assert atanh(z1).ae(cmath.atanh(z1)) assert atan(z1).ae(cmath.atan(z1)) # the reason we set a big eps here is that the cmath # functions are inaccurate assert asin(z1).ae(cmath.asin(z1), rel_eps=1e-12) assert acos(z1).ae(cmath.acos(z1), rel_eps=1e-12) one = mpf(1) for i in range(-9, 10, 3): for k in range(-9, 10, 3): a = 0.9*j*10**k + 0.8*one*10**i b = cos(acos(a)) assert b.ae(a) b = sin(asin(a)) assert b.ae(a) one = mpf(1) err = 2*10**-15 for i in range(-9, 9, 3): for k in range(-9, 9, 3): a = -0.9*10**k + j*0.8*one*10**i b = cosh(acosh(a)) assert b.ae(a, err) b = sinh(asinh(a)) assert b.ae(a, err)
def test_map_realistic(self): nonflat.define(mumass = "0.105658").toPython(mass = """ muons.map(mu1 => muons.map({mu2 => p1x = mu1.pt * cos(mu1.phi); p1y = mu1.pt * sin(mu1.phi); p1z = mu1.pt * sinh(mu1.eta); E1 = sqrt(p1x**2 + p1y**2 + p1z**2 + mumass**2); p2x = mu2.pt * cos(mu2.phi); p2y = mu2.pt * sin(mu2.phi); p2z = mu2.pt * sinh(mu2.eta); E2 = sqrt(p2x**2 + p2y**2 + p2z**2 + mumass**2); px = p1x + p2x; py = p1y + p2y; pz = p1z + p2z; E = E1 + E2; if E**2 - px**2 - py**2 - pz**2 >= 0: sqrt(E**2 - px**2 - py**2 - pz**2) else: None })) """).submit() ########################################################## Core math
def test_sinh(self): self.assertEqual(session.source("Test", x=real(3.14, 6.5)).type("sinh(x)"), real(math.sinh(3.14), math.sinh(6.5))) self.assertEqual(session.source("Test", x=real(3.14, almost(6.5))).type("sinh(x)"), real(math.sinh(3.14), almost(math.sinh(6.5)))) self.assertEqual(session.source("Test", x=real(3.14, almost(inf))).type("sinh(x)"), real(math.sinh(3.14), almost(math.sinh(inf)))) self.assertEqual(session.source("Test", x=real(3.14, inf)).type("sinh(x)"), real(math.sinh(3.14), inf)) self.assertEqual(session.source("Test", x=real).type("sinh(x)"), real(almost(-inf), almost(inf))) self.assertEqual(session.source("Test", x=extended).type("sinh(x)"), real(-inf, inf)) for entry in numerical.toPython(y = "y", a = "sinh(y)").submit(): self.assertEqual(entry.a, math.sinh(entry.y))
def sinh(arg): return generate_intrinsic_function_expression(arg, 'sinh', math.sinh)
def grid_to_geodetic(x, y): e2 = flattening * (2.0 - flattening) n = flattening / (2.0 - flattening) a_roof = axis / (1.0 + n) * (1.0 + n * n / 4.0 + n * n * n * n / 64.0) delta1 = n / 2.0 - 2.0 * n * n / 3.0 + 37.0 * n * n * n / 96.0 - n * n * n * n / 360.0 delta2 = n * n / 48.0 + n * n * n / 15.0 - 437.0 * n * n * n * n / 1440.0 delta3 = 17.0 * n * n * n / 480.0 - 37 * n * n * n * n / 840.0 delta4 = 4397.0 * n * n * n * n / 161280.0 Astar = e2 + e2 * e2 + e2 * e2 * e2 + e2 * e2 * e2 * e2 Bstar = -(7.0 * e2 * e2 + 17.0 * e2 * e2 * e2 + 30.0 * e2 * e2 * e2 * e2) / 6.0 Cstar = (224.0 * e2 * e2 * e2 + 889.0 * e2 * e2 * e2 * e2) / 120.0 Dstar = -(4279.0 * e2 * e2 * e2 * e2) / 1260.0 deg_to_rad = math.pi / 180 lambda_zero = central_meridian * deg_to_rad xi = (x - false_northing) / (scale * a_roof) eta = (y - false_easting) / (scale * a_roof) xi_prim = xi - delta1 * math.sin(2.0 * xi) * math.cosh(2.0 * eta) - \ delta2 * math.sin(4.0 * xi) * math.cosh(4.0 * eta) - \ delta3 * math.sin(6.0 * xi) * math.cosh(6.0 * eta) - \ delta4 * math.sin(8.0 * xi) * math.cosh(8.0 * eta) eta_prim = eta - \ delta1 * math.cos(2.0 * xi) * math.sinh(2.0 * eta) - \ delta2 * math.cos(4.0 * xi) * math.sinh(4.0 * eta) - \ delta3 * math.cos(6.0 * xi) * math.sinh(6.0 * eta) - \ delta4 * math.cos(8.0 * xi) * math.sinh(8.0 * eta) phi_star = math.asin(math.sin(xi_prim) / math.cosh(eta_prim)) delta_lambda = math.atan(math.sinh(eta_prim) / math.cos(xi_prim)) lon_radian = lambda_zero + delta_lambda lat_radian = phi_star + math.sin(phi_star) * math.cos(phi_star) * \ (Astar + Bstar * math.pow(math.sin(phi_star), 2) + Cstar * math.pow(math.sin(phi_star), 4) + Dstar * math.pow(math.sin(phi_star), 6)) return lat_radian * 180.0 / math.pi, lon_radian * 180.0 / math.pi
def test_trig_hyperb_basic(): for x in (range(100) + range(-100,0)): t = x / 4.1 assert cos(mpf(t)).ae(math.cos(t)) assert sin(mpf(t)).ae(math.sin(t)) assert tan(mpf(t)).ae(math.tan(t)) assert cosh(mpf(t)).ae(math.cosh(t)) assert sinh(mpf(t)).ae(math.sinh(t)) assert tanh(mpf(t)).ae(math.tanh(t)) assert sin(1+1j).ae(cmath.sin(1+1j)) assert sin(-4-3.6j).ae(cmath.sin(-4-3.6j)) assert cos(1+1j).ae(cmath.cos(1+1j)) assert cos(-4-3.6j).ae(cmath.cos(-4-3.6j))
def test_complex_functions(): for x in (range(10) + range(-10,0)): for y in (range(10) + range(-10,0)): z = complex(x, y)/4.3 + 0.01j assert exp(mpc(z)).ae(cmath.exp(z)) assert log(mpc(z)).ae(cmath.log(z)) assert cos(mpc(z)).ae(cmath.cos(z)) assert sin(mpc(z)).ae(cmath.sin(z)) assert tan(mpc(z)).ae(cmath.tan(z)) assert sinh(mpc(z)).ae(cmath.sinh(z)) assert cosh(mpc(z)).ae(cmath.cosh(z)) assert tanh(mpc(z)).ae(cmath.tanh(z))
def __conv_WGS84_SWED_RT90(lat, lon): """ Input is lat and lon as two float numbers Output is X and Y coordinates in RT90 as a tuple of float numbers The code below converts to/from the Swedish RT90 koordinate system. The converion functions use "Gauss Conformal Projection (Transverse Marcator)" Krüger Formulas. The constanst are for the Swedish RT90-system. With other constants the conversion should be useful for other geographical areas. """ # Some constants used for conversion to/from Swedish RT90 f = 1.0/298.257222101 e2 = f*(2.0-f) n = f/(2.0-f) L0 = math.radians(15.8062845294) # 15 deg 48 min 22.624306 sec k0 = 1.00000561024 a = 6378137.0 # meter at = a/(1.0+n)*(1.0+ 1.0/4.0* pow(n, 2)+1.0/64.0*pow(n, 4)) FN = -667.711 # m FE = 1500064.274 # m #the conversion lat_rad = math.radians(lat) lon_rad = math.radians(lon) A = e2 B = 1.0/6.0*(5.0*pow(e2, 2) - pow(e2, 3)) C = 1.0/120.0*(104.0*pow(e2, 3) - 45.0*pow(e2, 4)) D = 1.0/1260.0*(1237.0*pow(e2, 4)) DL = lon_rad - L0 E = A + B*pow(math.sin(lat_rad), 2) + \ C*pow(math.sin(lat_rad), 4) + \ D*pow(math.sin(lat_rad), 6) psi = lat_rad - math.sin(lat_rad)*math.cos(lat_rad)*E xi = math.atan2(math.tan(psi), math.cos(DL)) eta = atanh(math.cos(psi)*math.sin(DL)) B1 = 1.0/2.0*n - 2.0/3.0*pow(n, 2) + 5.0/16.0*pow(n, 3) + \ 41.0/180.0*pow(n, 4) B2 = 13.0/48.0*pow(n, 2) - 3.0/5.0*pow(n, 3) + 557.0/1440.0*pow(n, 4) B3 = 61.0/240.0*pow(n, 3) - 103.0/140.0*pow(n, 4) B4 = 49561.0/161280.0*pow(n, 4) X = xi + B1*math.sin(2.0*xi)*math.cosh(2.0*eta) + \ B2*math.sin(4.0*xi)*math.cosh(4.0*eta) + \ B3*math.sin(6.0*xi)*math.cosh(6.0*eta) + \ B4*math.sin(8.0*xi)*math.cosh(8.0*eta) Y = eta + B1*math.cos(2.0*xi)*math.sinh(2.0*eta) + \ B2*math.cos(4.0*xi)*math.sinh(4.0*eta) + \ B3*math.cos(6.0*xi)*math.sinh(6.0*eta) + \ B4*math.cos(8.0*xi)*math.sinh(8.0*eta) X = X*k0*at + FN Y = Y*k0*at + FE return (X, Y)
