# Python math.expm1() Examples

The following are 10 code examples of math.expm1(). 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 calculate_sync_order(oscillator_phases):
"""!
@brief Calculates level of global synchronization (order parameter) for input phases.
@details This parameter is tend 1.0 when the oscillatory network close to global synchronization and it tend to 0.0 when
desynchronization is observed in the network.

@param[in] oscillator_phases (list): List of oscillator phases that are used for level of global synchronization.

@return (double) Level of global synchronization (order parameter).

@see calculate_order_parameter()

"""

exp_amount = 0.0
average_phase = 0.0

for phase in oscillator_phases:
exp_amount += math.expm1(abs(1j * phase))
average_phase += phase

exp_amount /= len(oscillator_phases)
average_phase = math.expm1(abs(1j * (average_phase / len(oscillator_phases))))

return abs(average_phase) / abs(exp_amount) ```
Example #2
```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 #3
```def _log1mexp(x):
"""Numerically stable computation of log(1-exp(x))."""
if x < -1:
return math.log1p(-math.exp(x))
elif x < 0:
return math.log(-math.expm1(x))
elif x == 0:
return -np.inf
else:
raise ValueError("Argument must be non-positive.") ```
Example #4
```def stop(self):
super(Returns, self).stop()

if not self._fundmode:
self._value_end = self.strategy.broker.getvalue()
else:
self._value_end = self.strategy.broker.fundvalue

# Compound return
try:
nlrtot = self._value_end / self._value_start
except ZeroDivisionError:
rtot = float('-inf')
else:
if nlrtot < 0.0:
rtot = float('-inf')
else:
rtot = math.log(nlrtot)

self.rets['rtot'] = rtot

# Average return
self.rets['ravg'] = ravg = rtot / self._tcount

# Annualized normalized return
tann = self.p.tann or self._TANN.get(self.timeframe, None)
if tann is None:
tann = self._TANN.get(self.data._timeframe, 1.0)  # assign default

if ravg > float('-inf'):
self.rets['rnorm'] = rnorm = math.expm1(ravg * tann)
else:
self.rets['rnorm'] = rnorm = ravg

self.rets['rnorm100'] = rnorm * 100.0  # human readable % ```
Example #5
```def expm1(x=('FloatPin', 0.1)):
'''Return `e**x - 1`. For small floats `x`, the subtraction in `exp(x) - 1` can result in a significant loss of precision.'''
return math.expm1(x) ```
Example #6
```def _log1mexp(x):
"""Numerically stable computation of log(1-exp(x))."""
if x < -1:
return math.log1p(-math.exp(x))
elif x < 0:
return math.log(-math.expm1(x))
elif x == 0:
return -np.inf
else:
raise ValueError("Argument must be non-positive.") ```
Example #7
```def log1m_exp(val):
"""Numerically stable implementation of `log(1 - exp(val))`."""
if val >= 0.:
return nan
elif val > LOG_2:
return log(-expm1(val))
else:
return log1p(-exp(val)) ```
Example #8
```def _log1mexp(x):
"""Numerically stable computation of log(1-exp(x))."""
if x < -1:
return math.log1p(-math.exp(x))
elif x < 0:
return math.log(-math.expm1(x))
elif x == 0:
return -np.inf
else:
raise ValueError("Argument must be non-positive.") ```
Example #9
`def expm1(node): return merge([node], math.expm1) `
```def _log1mexp(x):