# Python math.cosh() Examples

The following are 30 code examples of math.cosh(). 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 trig(a, b=' '):
if is_num(a) and isinstance(b, int):

funcs = [math.sin, math.cos, math.tan,
math.asin, math.acos, math.atan,
math.sinh, math.cosh, math.tanh,
math.asinh, math.acosh, math.atanh]

return funcs[b](a)

if is_lst(a):
width = max(len(row) for row in a)
padded_matrix = [list(row) + (width - len(row)) * [b] for row in a]
if all(isinstance(row, str) for row in a) and isinstance(b, str):
normalizer = ''.join
else:
normalizer = list
return norm_trans
return unknown_types(trig, ".t", a, b) ```
Example #2
```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) ```
Example #3
```def thetappp(self,z_in):
T = self.T_k_in
G = self.G_ksi
J = self.J_in4
l = self.l_in
a = self.a
z = z_in
theta_tripleprime = (-(T*m.cosh(z/a)) + T*m.sinh(z/a)*m.tanh(l/(2*a)))/(G*J*a**2)

return theta_tripleprime

#Case 3 - Concentrated Torque at alpha*l with Pinned Ends
#T = Applied Concentrated Torsional Moment, Kip-in
#G = Shear Modulus of Elasticity, Ksi, 11200 for steel
#J = Torsinal Constant of Cross Section, in^4
#l = Span Lenght, in
#a = Torsional Constant
#alpa = load application point/l ```
Example #4
```def thetappp(self,z_in):
T = self.T_k_in
G = self.G_ksi
J = self.J_in4
l = self.l_in
a = self.a
alpha = self.alpha
z = z_in
if 0 <= z_in <= (alpha*l):
theta_tripleprime = -((T*m.cosh(z/a)*(m.cosh((l*alpha)/a) - m.sinh((l*alpha)/a)/m.tanh(l/a)))/(G*J*a**2))
else:
theta_tripleprime = (T*(m.cosh(z/a)/m.tanh(l/a) - m.sinh(z/a))*m.sinh((l*alpha)/a))/(G*J*a**2)
return theta_tripleprime

#Case 4 - Uniformly Distributed Torque with Pinned Ends
#t = Distributed torque, Kip-in / in
#G = Shear Modulus of Elasticity, Ksi, 11200 for steel
#J = Torsinal Constant of Cross Section, in^4
#l = Span Lenght, in
#a = Torsional Constant ```
Example #5
```def thetappp(self,z_in):
t = self.t_k_inpin
G = self.G_ksi
J = self.J_in4
l = self.l_in
a = self.a
z = z_in
theta_tripleprime = (t*(-1 + (l*(m.cosh(z/a)/m.sinh(l/a)))/a))/(G*J*l)

return theta_tripleprime

#Case 6 - Concentrated Torque at alpha*l with Fixed Ends
#T = Applied Concentrated Torsional Moment, Kip-in
#G = Shear Modulus of Elasticity, Ksi, 11200 for steel
#J = Torsinal Constant of Cross Section, in^4
#l = Span Lenght, in
#a = Torsional Constant
#alpa = load application point/l ```
Example #6
```def thetappp(self,z_in):
T = self.T_k_in
G = self.G_ksi
J = self.J_in4
l = self.l_in
a = self.a
alpha = self.alpha
H = self.H
z = z_in

if 0 <= z_in <= (alpha*l):
theta_tripleprime = -((T*(m.cosh(z/a)/a**2 + ((-1.0 + (1.0 + H)*(m.cosh((l*alpha)/a))/m.tanh(l/a))*m.sinh(z/a))/a**2 - (H*(m.sinh(z/a)/m.sinh(l/a)))/a**2 - (m.sinh(z/a)*m.sinh((l*alpha)/a))/a**2 - (H*m.sinh(z/a)*m.sinh((l*alpha)/a))/a**2))/(G*(1.0 + H)*J))
else:
theta_tripleprime = 0
return theta_tripleprime
#Test Area ```
Example #7
```def post_execute(self):
out = {}
if (self.inputs["Operation 1"].default_value == "SIN"):
if (self.inputs["Operation 2"].default_value == "NONE"):
out["Value"] = math.sin(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "HB"):
out["Value"] = math.sinh(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "INV"):
out["Value"] = math.asin(max(min(self.inputs["X"].default_value, 1), -1))
elif (self.inputs["Operation 1"].default_value == "COS"):
if (self.inputs["Operation 2"].default_value == "NONE"):
out["Value"] = math.cos(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "HB"):
out["Value"] = math.cosh(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "INV"):
out["Value"] = math.acos(max(min(self.inputs["X"].default_value, 1), -1))
elif (self.inputs["Operation 1"].default_value == "TAN"):
if (self.inputs["Operation 2"].default_value == "NONE"):
out["Value"] = math.tan(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "HB"):
out["Value"] = math.tanh(self.inputs["X"].default_value)
elif (self.inputs["Operation 2"].default_value == "INV"):
out["Value"] = math.atan(self.inputs["X"].default_value)
return out ```
Example #8
```def genpy(self, paramTypes, args, pos):
return "math.cosh({0})".format(*args) ```
Example #9
```def __call__(self, state, scope, pos, paramTypes, x):
return math.cosh(x) ```
Example #10
```def compute_hyperbolic_area(radius):
beta = 1.00
return 2 * math.pi * (math.cosh(radius / K) - 1.0) * beta ```
Example #11
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example #12
```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))) ```
Example #13
```def __init__(self):
super().__init__()
self.value = 'cosh' ```
Example #14
```def calculate(self, val):
return self.coefficient * ((math.cosh(val))**self.power) ```
Example #15
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example #16
```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))) ```
Example #17
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example #18
```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))) ```
Example #19
```def __call__(self, val):
return __inline_fora(
"""fun(@unnamed_args:(val), *args) {
PyFloat(math.cosh(val.@m))
}"""
)(val) ```
Example #20
```def test_pure_python_math_module(self):
vals = [1, -.5, 1.5, 0, 0.0, -2, -2.2, .2]

# not being tested: math.asinh, math.atanh, math.lgamma, math.erfc, math.acos
def f():
functions = [
math.sqrt, math.cos, math.sin, math.tan, math.asin, math.atan,
math.acosh, math.cosh, math.sinh, math.tanh, math.ceil,
math.erf, math.exp, math.expm1, math.factorial, math.floor,
math.log, math.log10, math.log1p
]
tr = []
for idx1 in range(len(vals)):
v1 = vals[idx1]
for funIdx in range(len(functions)):
function = functions[funIdx]
try:
tr = tr + [function(v1)]
except ValueError as ex:
pass

return tr

r1 = self.evaluateWithExecutor(f)
r2 = f()
self.assertGreater(len(r1), 100)
self.assertTrue(numpy.allclose(r1, r2, 1e-6)) ```
Example #21
```def toGeographic(self, x, y):
lon = math.atan(math.sinh(x)/math.cos(D))
lat = math.asin(math.sin(D)/math.cosh(x))

lon = self.lon + math.degrees(lon)
lat = math.degrees(lat)
return (lat, lon) ```
Example #22
```def make_instance(typeclass, cls, pi, exp, sqrt, log, pow, logBase, sin,
tan, cos, asin, atan, acos, sinh, tanh, cosh, asinh, atanh, acosh):
attrs = {"pi":pi, "exp":exp, "sqrt":sqrt, "log":log, "pow":pow,
"logBase":logBase, "sin":sin, "tan":tan, "cos":cos,
"asin":asin, "atan":atan, "acos":acos, "sinh":sinh,
"tanh":tanh, "cosh":cosh, "asinh":asinh, "atanh":atanh,
"acosh":acosh}
build_instance(Floating, cls, attrs)
return ```
Example #23
```def cosh(x):
"""
cosh :: Floating a => a -> a
"""
return Floating[x].cosh(x) ```
Example #24
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example #25
```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))) ```
Example #26
```def toGeographic(self, x, y):
lon = atan(sinh(x) / cos(D))
lat = asin(sin(D) / cosh(x))

lon = self.lon + degrees(lon)
lat = degrees(lat)
return lat, lon ```
Example #27
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example #28
```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))) ```
Example #29
```def math_commands():
"""Provides list with math commands - we need this when using eval"""

from math import acos, asin, atan, atan2, ceil, cos, cosh, exp, floor, log, pi, pow, sin, sinh, sqrt, tan, tanh

functions = [
"acos",
"asin",
"atan",
"atan2",
"ceil",
"cos",
"cosh",
"exp",
"floor",
"log",
"pi",
"pow",
"sin",
"sinh",
"sqrt",
"tan",
"tanh",
]

mathdefinitions = {}
for f in functions:
mathdefinitions[f] = locals().get(f, None)

return mathdefinitions ```
Example #30
```def theta(self,z_in):