我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.sinh()。
def quadrf(ev, y): L = ev[1] # length k = ev[4] # quadrupole strength if k == 0: R = drift(ev, y) else: wrzlk = sqrt(abs(k)) Omega = wrzlk*L coshom = cosh(Omega) sinhom = sinh(Omega) cosom = cos(Omega) sinom = sin(Omega) R = array([ [cosom, sinom/wrzlk, 0., 0., 0., 0.], [-wrzlk*sinom, cosom, 0., 0., 0., 0.], [0., 0., coshom, sinhom/wrzlk, 0., 0.], [0., 0., wrzlk*sinhom, coshom, 0., 0.], [0., 0., 0., 0., 1., L/(y**2)], [0., 0., 0., 0., 0., 1.] ]) return R
def quadaf(ev, y): L = ev[1] # length k = ev[4] # quadrupole strength if k == 0: R = drift(ev, y) else: wrzlk = sqrt(abs(k)) Omega = wrzlk*L coshom = cosh(Omega) sinhom = sinh(Omega) cosom = cos(Omega) sinom = sin(Omega) R = array([ [coshom, sinhom/wrzlk, 0., 0., 0., 0], [wrzlk*sinhom, coshom, 0., 0., 0., 0], [0., 0., cosom, sinom/wrzlk, 0., 0], [0., 0., -wrzlk*sinom, cosom, 0., 0], [0., 0., 0., 0., 1., L/(y**2)], [0., 0., 0., 0., 0., 1.] ]) return R
def redshift(self, age): """ Invert the above ``self.age(z)`` formula analytically, to calculate the redshift corresponding to the given cosmic time (age). Parameters ---------- age : `~numpy.ndarray` Age of the universe (i.e., cosmic time) Unit: [Gyr] Returns ------- z : `~numpy.ndarray` Redshift corresponding to the specified age. """ age = np.asarray(age) t_H = self.hubble_time term1 = (1/self.Om0) - 1 term2 = np.sinh(3*age * np.sqrt(1-self.Om0) / (2*t_H)) ** 2 z = (term1 / term2) ** (1/3) - 1 return z
def _keplerian_to_keplerian_mean(cls, coord, center): """Conversion from Keplerian to Keplerian Mean The difference is the use of Mean anomaly instead of True anomaly """ a, e, i, ?, ?, ? = coord if e < 1: # Elliptic case E = arccos((e + cos(?)) / (1 + e * cos(?))) # Eccentric anomaly M = E - e * sin(E) # Mean anomaly else: # Hyperbolic case H = arccosh((e + cos(?)) / (1 + e * cos(?))) M = e * sinh(H) - H return np.array([a, e, i, ?, ?, M], dtype=float)
def sinh(self, out=None): assert out is None return self.elemwise(np.sinh)
def Dm(self, z, cm=False, meter=False, pc=False, kpc=False, mpc=False): Ok = self.Ok() sOk = num.sqrt(num.abs(Ok)) Dc = self.Dc(z) Dh = self.Dh() conversion = self.lengthConversion(cm=cm, meter=meter, pc=pc, kpc=kpc, mpc=mpc) if Ok > 0: return Dh / sOk * num.sinh(sOk * Dc / Dh) * conversion elif Ok == 0: return Dc * conversion else: return Dh / sOk * num.sin(sOk * Dc / Dh) * conversion # Angular diameter distance # Ratio of an objects physical transvserse size to its angular size in radians
def test_basic_ufuncs(self): # Test various functions such as sin, cos. (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d assert_equal(np.cos(x), cos(xm)) assert_equal(np.cosh(x), cosh(xm)) assert_equal(np.sin(x), sin(xm)) assert_equal(np.sinh(x), sinh(xm)) assert_equal(np.tan(x), tan(xm)) assert_equal(np.tanh(x), tanh(xm)) assert_equal(np.sqrt(abs(x)), sqrt(xm)) assert_equal(np.log(abs(x)), log(xm)) assert_equal(np.log10(abs(x)), log10(xm)) assert_equal(np.exp(x), exp(xm)) assert_equal(np.arcsin(z), arcsin(zm)) assert_equal(np.arccos(z), arccos(zm)) assert_equal(np.arctan(z), arctan(zm)) assert_equal(np.arctan2(x, y), arctan2(xm, ym)) assert_equal(np.absolute(x), absolute(xm)) assert_equal(np.angle(x + 1j*y), angle(xm + 1j*ym)) assert_equal(np.angle(x + 1j*y, deg=True), angle(xm + 1j*ym, deg=True)) assert_equal(np.equal(x, y), equal(xm, ym)) assert_equal(np.not_equal(x, y), not_equal(xm, ym)) assert_equal(np.less(x, y), less(xm, ym)) assert_equal(np.greater(x, y), greater(xm, ym)) assert_equal(np.less_equal(x, y), less_equal(xm, ym)) assert_equal(np.greater_equal(x, y), greater_equal(xm, ym)) assert_equal(np.conjugate(x), conjugate(xm))
def test_testUfuncRegression(self): # Tests new ufuncs on MaskedArrays. for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate', 'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh', 'arcsinh', 'arccosh', 'arctanh', 'absolute', 'fabs', 'negative', 'floor', 'ceil', 'logical_not', 'add', 'subtract', 'multiply', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod', 'hypot', 'arctan2', 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater', 'logical_and', 'logical_or', 'logical_xor', ]: try: uf = getattr(umath, f) except AttributeError: uf = getattr(fromnumeric, f) mf = getattr(numpy.ma.core, f) args = self.d[:uf.nin] ur = uf(*args) mr = mf(*args) assert_equal(ur.filled(0), mr.filled(0), f) assert_mask_equal(ur.mask, mr.mask, err_msg=f)
def test_testUfuncs1(self): # Test various functions such as sin, cos. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d self.assertTrue(eq(np.cos(x), cos(xm))) self.assertTrue(eq(np.cosh(x), cosh(xm))) self.assertTrue(eq(np.sin(x), sin(xm))) self.assertTrue(eq(np.sinh(x), sinh(xm))) self.assertTrue(eq(np.tan(x), tan(xm))) self.assertTrue(eq(np.tanh(x), tanh(xm))) with np.errstate(divide='ignore', invalid='ignore'): self.assertTrue(eq(np.sqrt(abs(x)), sqrt(xm))) self.assertTrue(eq(np.log(abs(x)), log(xm))) self.assertTrue(eq(np.log10(abs(x)), log10(xm))) self.assertTrue(eq(np.exp(x), exp(xm))) self.assertTrue(eq(np.arcsin(z), arcsin(zm))) self.assertTrue(eq(np.arccos(z), arccos(zm))) self.assertTrue(eq(np.arctan(z), arctan(zm))) self.assertTrue(eq(np.arctan2(x, y), arctan2(xm, ym))) self.assertTrue(eq(np.absolute(x), absolute(xm))) self.assertTrue(eq(np.equal(x, y), equal(xm, ym))) self.assertTrue(eq(np.not_equal(x, y), not_equal(xm, ym))) self.assertTrue(eq(np.less(x, y), less(xm, ym))) self.assertTrue(eq(np.greater(x, y), greater(xm, ym))) self.assertTrue(eq(np.less_equal(x, y), less_equal(xm, ym))) self.assertTrue(eq(np.greater_equal(x, y), greater_equal(xm, ym))) self.assertTrue(eq(np.conjugate(x), conjugate(xm))) self.assertTrue(eq(np.concatenate((x, y)), concatenate((xm, ym)))) self.assertTrue(eq(np.concatenate((x, y)), concatenate((x, y)))) self.assertTrue(eq(np.concatenate((x, y)), concatenate((xm, y)))) self.assertTrue(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
def test_testUfuncRegression(self): f_invalid_ignore = [ 'sqrt', 'arctanh', 'arcsin', 'arccos', 'arccosh', 'arctanh', 'log', 'log10', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod'] for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate', 'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh', 'arcsinh', 'arccosh', 'arctanh', 'absolute', 'fabs', 'negative', 'floor', 'ceil', 'logical_not', 'add', 'subtract', 'multiply', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod', 'hypot', 'arctan2', 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater', 'logical_and', 'logical_or', 'logical_xor']: try: uf = getattr(umath, f) except AttributeError: uf = getattr(fromnumeric, f) mf = getattr(np.ma, f) args = self.d[:uf.nin] with np.errstate(): if f in f_invalid_ignore: np.seterr(invalid='ignore') if f in ['arctanh', 'log', 'log10']: np.seterr(divide='ignore') ur = uf(*args) mr = mf(*args) self.assertTrue(eq(ur.filled(0), mr.filled(0), f)) self.assertTrue(eqmask(ur.mask, mr.mask))
def sinh(x: Number = 0.0) -> Number: return np.sinh(x)
def bark2freq(b): return 650.*np.sinh(b/7.)
def bark2freq(b): return 650*np.sinh(b/7)
def Dn_plane(l, r, N=10): alpha = acosh(l/r) s = 0. for n in range(1, N): 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 Dn_plane(l, r, N=20): alpha = np.arccosh(l/r) sinh = np.sinh s = 0. for n in range(1, N): 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 Dn_plane(l, r, N=100): alpha = acosh(l/r) s = 0. for n in range(1, N): 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 sinh(v): return v.__class__(numpy.sinh(v))
def cir_int_rt_chf(u, t, k, theta, sigma, r0): r = np.sqrt(k ** 2 - 1j * u * 2 * sigma ** 2) cosh_fun = np.cosh(r * t / 2) sinh_fun = np.sinh(r * t / 2) coth_fun = cosh_fun / sinh_fun a_t_v = np.exp(t * theta * (k ** 2) / (sigma ** 2)) / (cosh_fun + (k / r) * sinh_fun) ** ( 2 * k * theta / (sigma ** 2)) b_t_v = 2 * 1j * u / (k + r * coth_fun) return a_t_v * np.exp(b_t_v * r0)
def comoving_transverse_distance(self, z_i, z_f): r""" When multiplied by some angle, the distance between two objects observed at redshift, z_f, with an angular separation given by that angle, viewed by an observer at redshift, z_i (Hogg 1999). Parameters ---------- z_i : float The redshift of the observer. z_f : float The redshift of the observed object. Examples -------- >>> from yt.utilities.cosmology import Cosmology >>> co = Cosmology() >>> print(co.comoving_transverse_distance(0., 1.).in_units("Mpccm")) """ if (self.omega_curvature > 0): return (self.hubble_distance() / np.sqrt(self.omega_curvature) * np.sinh(np.sqrt(self.omega_curvature) * self.comoving_radial_distance(z_i, z_f) / self.hubble_distance())).in_base(self.unit_system) elif (self.omega_curvature < 0): return (self.hubble_distance() / np.sqrt(np.fabs(self.omega_curvature)) * np.sin(np.sqrt(np.fabs(self.omega_curvature)) * self.comoving_radial_distance(z_i, z_f) / self.hubble_distance())).in_base(self.unit_system) else: return self.comoving_radial_distance(z_i, z_f)
def __init__(self, generator: Generator=Autoincrement()): super().__init__(numpy.sinh, generator)
def test_sinh(): fun = lambda x : 3.0 * np.sinh(x) d_fun = grad(fun) check_grads(fun, npr.randn()) check_grads(d_fun, npr.randn())
def integrate_fip(p, v, z, dt, omega2): """ Integrate the equation of motion of the Floating-base Inverted Pendulum. Parameters ---------- p : array, shape=(3,) Initial position. v : array, shape=(3,) Initial velocity. z : array, shape=(3,) ZMP location throughout the integration. dt : scalar Integration step. omega2 : scalar FIP constant. Returns ------- p_next : array, shape=(3,) Position at the end of the integration step. v_next : array, shape=(3,) Velocity at the end of the integration step. Note ---- The Linear Inverted Pendulum Mode (LIPM) is a special case of the FIP, so this function also applies to COP-based controllers. """ omega = sqrt(omega2) a = omega2 * (p - z) + gravity p_next = p + v / omega * sinh(omega * dt) \ + a / omega2 * (cosh(omega * dt) - 1.) v_next = v * cosh(omega * dt) + a / omega * sinh(omega * dt) return p_next, v_next
def test_testUfuncRegression(self): # Tests new ufuncs on MaskedArrays. for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate', 'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh', 'arcsinh', 'arccosh', 'arctanh', 'absolute', 'fabs', 'negative', # 'nonzero', 'around', 'floor', 'ceil', # 'sometrue', 'alltrue', 'logical_not', 'add', 'subtract', 'multiply', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod', 'hypot', 'arctan2', 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater', 'logical_and', 'logical_or', 'logical_xor', ]: try: uf = getattr(umath, f) except AttributeError: uf = getattr(fromnumeric, f) mf = getattr(numpy.ma.core, f) args = self.d[:uf.nin] ur = uf(*args) mr = mf(*args) assert_equal(ur.filled(0), mr.filled(0), f) assert_mask_equal(ur.mask, mr.mask, err_msg=f)
def test_testUfuncRegression(self): f_invalid_ignore = [ 'sqrt', 'arctanh', 'arcsin', 'arccos', 'arccosh', 'arctanh', 'log', 'log10', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod'] for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate', 'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh', 'arcsinh', 'arccosh', 'arctanh', 'absolute', 'fabs', 'negative', # 'nonzero', 'around', 'floor', 'ceil', # 'sometrue', 'alltrue', 'logical_not', 'add', 'subtract', 'multiply', 'divide', 'true_divide', 'floor_divide', 'remainder', 'fmod', 'hypot', 'arctan2', 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater', 'logical_and', 'logical_or', 'logical_xor']: try: uf = getattr(umath, f) except AttributeError: uf = getattr(fromnumeric, f) mf = getattr(np.ma, f) args = self.d[:uf.nin] with np.errstate(): if f in f_invalid_ignore: np.seterr(invalid='ignore') if f in ['arctanh', 'log', 'log10']: np.seterr(divide='ignore') ur = uf(*args) mr = mf(*args) self.assertTrue(eq(ur.filled(0), mr.filled(0), f)) self.assertTrue(eqmask(ur.mask, mr.mask))
def bark2hz(self, Brk): """ Method to compute Hz from Bark scale. Args : Brk : (ndarray) Array containing Bark scaled values. Returns : Fhz : (ndarray) Array containing frequencies in Hz. """ Fhz = 650. * np.sinh(Brk/7.) return Fhz
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 fun_scalar_scalar(self, x): return np.sinh(x)
def _f1(self, z): """ Calculate function f1 from Hellstrom (1991) """ f1 = np.exp(self._beta*z)*(np.cosh(self._gamma*z) - self._delta*np.sinh(self._gamma*z)) return f1
def _f2(self, z): """ Calculate function f2 from Hellstrom (1991) """ f2 = np.exp(self._beta*z)*self._beta12/self._gamma \ * np.sinh(self._gamma*z) return f2
def _f3(self, z): """ Calculate function f3 from Hellstrom (1991) """ f3 = np.exp(self._beta*z)*(np.cosh(self._gamma*z) + self._delta*np.sinh(self._gamma*z)) return f3
def _f4(self, z): """ Calculate function f4 from Hellstrom (1991) """ A = self._delta*self._beta1 + self._beta2*self._beta12/self._gamma f4 = np.exp(self._beta*z) \ * (self._beta1*np.cosh(self._gamma*z) - A*np.sinh(self._gamma*z)) return f4
def _f5(self, z): """ Calculate function f5 from Hellstrom (1991) """ B = self._delta*self._beta2 + self._beta1*self._beta12/self._gamma f5 = np.exp(self._beta*z) \ * (self._beta2*np.cosh(self._gamma*z) + B*np.sinh(self._gamma*z)) return f5
def _F5(self, z): """ Calculate integral of function f5 from Hellstrom (1991) """ B = self._delta*self._beta2 + self._beta1*self._beta12/self._gamma C = self._beta2*self._beta - B*self._gamma S = - (self._beta2*self._gamma - self._beta*B) denom = (self._beta**2 - self._gamma**2) F5 = np.exp(self._beta*z) / denom \ * (C*np.cosh(self._gamma*z) + S*np.sinh(self._gamma*z)) return F5
