mirror of https://github.com/exaloop/codon
693 lines
22 KiB
Python
693 lines
22 KiB
Python
import bisect
|
||
import random
|
||
from math import frexp as _frexp, floor as _floor, fabs as _fabs, erf as _erf
|
||
from math import gcd as _gcd, exp as _exp, log as _log, sqrt as _sqrt, tau as _tau, hypot as _hypot
|
||
|
||
class StatisticsError:
|
||
_hdr: ExcHeader
|
||
|
||
def __init__(self):
|
||
self._hdr = ('StatisticsError', '', '', '', 0, 0)
|
||
|
||
def __init__(self, message: str):
|
||
self._hdr = ('StatisticsError', message, '', '', 0, 0)
|
||
|
||
@property
|
||
def message(self):
|
||
return self._hdr.msg
|
||
|
||
def median[T](data: List[T]) -> float:
|
||
"""
|
||
Return the median (middle value) of numeric data.
|
||
|
||
When the number of data points is odd, return the middle data point.
|
||
When the number of data points is even, the median is interpolated by
|
||
taking the average of the two middle values
|
||
"""
|
||
data = sorted(data)
|
||
n = len(data)
|
||
if n == 0:
|
||
raise StatisticsError("no median for empty data")
|
||
if n%2 == 1:
|
||
return float(data[n//2])
|
||
else:
|
||
i = n//2
|
||
return (data[i - 1] + data[i]) / 2
|
||
|
||
def median_low[T](data: List[T]) -> float:
|
||
"""
|
||
Return the low median of numeric data.
|
||
|
||
When the number of data points is odd, the middle value is returned.
|
||
When it is even, the smaller of the two middle values is returned.
|
||
"""
|
||
data = sorted(data)
|
||
n = len(data)
|
||
if n == 0:
|
||
raise StatisticsError("no median for empty data")
|
||
if n%2 == 1:
|
||
return float(data[n//2])
|
||
else:
|
||
return float(data[n//2 -1])
|
||
|
||
def median_high[T](data: List[T]) -> float:
|
||
"""
|
||
Return the high median of data.
|
||
|
||
When the number of data points is odd, the middle value is returned.
|
||
When it is even, the larger of the two middle values is returned.
|
||
"""
|
||
data = sorted(data)
|
||
n = len(data)
|
||
if n == 0:
|
||
raise StatisticsError("no median for empty data")
|
||
return float(data[n//2])
|
||
|
||
def _find_lteq[T](a: List[T], x: float):
|
||
"""
|
||
Locate the leftmost value exactly equal to x
|
||
"""
|
||
i = bisect.bisect_left(a, x)
|
||
if i != len(a) and a[i] == x:
|
||
return i
|
||
assert False
|
||
|
||
def _find_rteq[T](a: List[T], l: int, x: float):
|
||
"""
|
||
Locate the rightmost value exactly equal to x
|
||
"""
|
||
i = bisect.bisect_right(a, x, lo=l)
|
||
if i != (len(a)+1) and a[i-1] == x:
|
||
return i-1
|
||
assert False
|
||
|
||
def median_grouped[T,S=int](data: List[T], interval: S = 1) -> float:
|
||
"""
|
||
Return the 50th percentile (median) of grouped continuous data.
|
||
"""
|
||
data = sorted(data)
|
||
n = len(data)
|
||
if n == 0:
|
||
raise StatisticsError("no median for empty data")
|
||
elif n == 1:
|
||
return float(data[0])
|
||
|
||
# Find the value at the midpoint.
|
||
x = float(data[n//2])
|
||
L = x - float(interval)/2 # The lower limit of the median interval.
|
||
|
||
# Find the position of leftmost occurrence of x in data
|
||
l1 = _find_lteq(data, x)
|
||
# Find the position of rightmost occurrence of x in data[l1...len(data)]
|
||
# Assuming always l1 <= l2
|
||
l2 = _find_rteq(data, l1, x)
|
||
cf = l1
|
||
f = l2 - l1 + 1
|
||
return L + interval*(n/2 - cf)/f
|
||
|
||
def mode[T](data: List[T]) -> T:
|
||
"""
|
||
Return the most common data point from discrete or nominal data.
|
||
"""
|
||
counter = 0
|
||
elem = data[0]
|
||
|
||
for i in data:
|
||
curr_frequency = data.count(i)
|
||
if curr_frequency > counter:
|
||
counter = curr_frequency
|
||
elem = i
|
||
return elem
|
||
|
||
def multimode[T](data: List[T]):
|
||
"""
|
||
Return a list of the most frequently occurring values.
|
||
|
||
Will return more than one result if there are multiple modes
|
||
or an empty list if *data* is empty.
|
||
"""
|
||
elem = data[0]
|
||
counter = data.count(elem)
|
||
li = sorted(data)
|
||
mulmode = List[T]()
|
||
|
||
for i in li:
|
||
curr_frequency = data.count(i)
|
||
if curr_frequency > counter:
|
||
mulmode = List[T]()
|
||
mulmode.append(i)
|
||
counter = curr_frequency
|
||
elif curr_frequency == counter and i not in mulmode:
|
||
mulmode.append(i)
|
||
return mulmode
|
||
|
||
def quantiles[T](data: List[T], n: int = 4, method: str = 'exclusive') -> List[float]:
|
||
"""
|
||
Divide *data* into *n* continuous intervals with equal probability.
|
||
|
||
Returns a list of (n - 1) cut points separating the intervals.
|
||
|
||
Set *n* to 4 for quartiles (the default). Set *n* to 10 for deciles.
|
||
Set *n* to 100 for percentiles which gives the 99 cuts points that
|
||
separate *data* in to 100 equal sized groups.
|
||
|
||
The *data* can be any iterable containing sample.
|
||
The cut points are linearly interpolated between data points.
|
||
|
||
If *method* is set to *inclusive*, *data* is treated as population
|
||
data. The minimum value is treated as the 0th percentile and the
|
||
maximum value is treated as the 100th percentile.
|
||
"""
|
||
if n < 1:
|
||
raise StatisticsError('n must be at least 1')
|
||
data = sorted(data)
|
||
ld = len(data)
|
||
if ld < 2:
|
||
raise StatisticsError('must have at least two data points')
|
||
|
||
if method == 'inclusive':
|
||
m = ld - 1
|
||
result = List[float]()
|
||
for i in range(1, n):
|
||
j = i * m // n
|
||
delta = (i * m) - (j * n)
|
||
interpolated = (data[j] * (n - delta) + data[j+1] * delta) / n
|
||
result.append(interpolated)
|
||
return result
|
||
if method == 'exclusive':
|
||
m = ld + 1
|
||
result = List[float]()
|
||
for i in range(1, n):
|
||
j = i * m // n # rescale i to m/n
|
||
j = 1 if j < 1 else ld-1 if j > ld-1 else j # clamp to 1 .. ld-1
|
||
delta = (i * m) - (j * n) # exact integer math
|
||
interpolated = (data[j-1] * (n - delta) + data[j] * delta) / n
|
||
result.append(interpolated)
|
||
return result
|
||
raise ValueError(f'Unknown method: {method}')
|
||
|
||
def _lcm(x: int, y: int):
|
||
"""
|
||
Returns the lowest common multiple bewteen x and y
|
||
"""
|
||
greater = 0
|
||
if x > y:
|
||
greater = x
|
||
else:
|
||
greater = y
|
||
|
||
while True:
|
||
if greater % x == 0 and greater % y == 0:
|
||
lcm = greater
|
||
return lcm
|
||
greater += 1
|
||
|
||
|
||
def _sum(data: List[float]) -> float:
|
||
"""
|
||
Return a high-precision sum of the given numeric data as a fraction,
|
||
together with the type to be converted to and the count of items.
|
||
|
||
If optional argument ``start`` is given, it is added to the total.
|
||
If ``data`` is empty, ``start`` (defaulting to 0) is returned.
|
||
|
||
TODO/CAVEATS
|
||
- The start argument should default to 0 or 0.0
|
||
- Assumes input is floats
|
||
"""
|
||
# Neumaier sum
|
||
# https://en.wikipedia.org/wiki/Kahan_summation_algorithm#Further_enhancements
|
||
# https://www.mat.univie.ac.at/~neum/scan/01.pdf (German)
|
||
s = 0.0
|
||
c = 0.0
|
||
i = 0
|
||
N = len(data)
|
||
while i < N:
|
||
x = data[i]
|
||
t = s + x
|
||
if abs(s) >= abs(x):
|
||
c += (s - t) + x
|
||
else:
|
||
c += (x - t) + s
|
||
s = t
|
||
i += 1
|
||
return s + c
|
||
|
||
def mean(data: List[float]) -> float:
|
||
"""
|
||
Return the sample arithmetic mean of data.
|
||
|
||
TODO/CAVEATS
|
||
- Assumes input is floats
|
||
- Does not address NAN or INF
|
||
"""
|
||
n = len(data)
|
||
if n < 1:
|
||
raise StatisticsError('mean requires at least one data point')
|
||
total = _sum(data)
|
||
return total/n
|
||
|
||
'''
|
||
def fmean(data: List[float]) -> float:
|
||
"""
|
||
Convert data to floats and compute the arithmetic mean.
|
||
|
||
TODO/CAVEATS
|
||
@jordan- fsum is not implemented in math.seq yet and the above
|
||
mean(data) deals with only floats. Thus this function is passed for now.
|
||
"""
|
||
pass
|
||
'''
|
||
|
||
def geometric_mean(data: List[float]) -> float:
|
||
"""
|
||
Convert data to floats and compute the geometric mean.
|
||
|
||
Raises a StatisticsError if the input dataset is empty,
|
||
|
||
TODO/CAVEATS:
|
||
- Assumes input is a list of floats
|
||
- Uses mean instead of fmean for now
|
||
- Does not handle data that contains a zero, or if it contains a negative value.
|
||
"""
|
||
if len(data) < 1:
|
||
raise StatisticsError("geometric mean requires a non-empty dataset")
|
||
return _exp(mean(list(map(_log, data))))
|
||
|
||
def _fail_neg(values: List[float], errmsg: str):
|
||
"""
|
||
Iterate over values, failing if any are less than zero.
|
||
"""
|
||
for x in values:
|
||
if x < 0:
|
||
raise StatisticsError(errmsg)
|
||
yield x
|
||
|
||
def harmonic_mean(data: List[float]) -> float:
|
||
"""
|
||
Return the harmonic mean of data.
|
||
|
||
The harmonic mean, sometimes called the subcontrary mean, is the
|
||
reciprocal of the arithmetic mean of the reciprocals of the data,
|
||
and is often appropriate when averaging quantities which are rates
|
||
or ratios.
|
||
"""
|
||
errmsg = "harmonic mean does not support negative values"
|
||
n = len(data)
|
||
if n < 1:
|
||
raise StatisticsError("harmonic_mean requires at least one data point")
|
||
|
||
x = data[0]
|
||
|
||
if n == 1:
|
||
return x
|
||
total = 0.0
|
||
|
||
li = List[float](n)
|
||
for x in _fail_neg(data, errmsg):
|
||
if x == 0.0:
|
||
return 0.0
|
||
li.append(1/x)
|
||
total = _sum(li)
|
||
return n/total
|
||
|
||
def _ss(data: List[float], c: float):
|
||
"""
|
||
Return sum of square deviations of sequence data.
|
||
|
||
If c is None, the mean is calculated in one pass, and the deviations
|
||
from the mean are calculated in a second pass. Otherwise, deviations are
|
||
calculated from c as given.
|
||
"""
|
||
total = _sum([(x-c)**2 for x in data])
|
||
total2 = _sum([(x-c) for x in data])
|
||
|
||
total -= total2**2/len(data)
|
||
return total
|
||
|
||
def pvariance(data: List[float], mu: Optional[float]=None):
|
||
"""
|
||
Return the population variance of `data`.
|
||
|
||
Should contain atleast one value.
|
||
The optional argument mu, if given, should be the mean of
|
||
the data. If it is missing or None, the mean is automatically calculated.
|
||
|
||
TODO/CAVEATS:
|
||
- Assumes input is a list of floats
|
||
"""
|
||
mu1 = ~mu if mu else mean(data)
|
||
|
||
n = len(data)
|
||
if n < 1:
|
||
raise StatisticsError("pvariance requires at least one data point")
|
||
|
||
ss = _ss(data, mu1)
|
||
return ss/n
|
||
|
||
def pstdev(data: List[float], mu: Optional[float]=None):
|
||
"""
|
||
Return the square root of the population variance.
|
||
"""
|
||
mu1 = ~mu if mu else mean(data)
|
||
var = pvariance(data, mu1)
|
||
return _sqrt(var)
|
||
|
||
def variance(data: List[float], xbar: Optional[float]=None):
|
||
"""
|
||
Return the sample variance of data.
|
||
|
||
Shoulw contain atleast two values.
|
||
The optional argument xbar, if given, should be the mean of
|
||
the data. If it is missing or None, the mean is automatically calculated.
|
||
"""
|
||
xbar1 = ~xbar if xbar else mean(data)
|
||
n = len(data)
|
||
if n < 2:
|
||
raise StatisticsError("variance requires at least two data points")
|
||
ss = _ss(data, xbar1)
|
||
return ss/(n-1)
|
||
|
||
def stdev(data, xbar: Optional[float]=None):
|
||
"""
|
||
Return the square root of the sample variance.
|
||
"""
|
||
xbar1 = ~xbar if xbar else mean(data)
|
||
var = variance(data, xbar1)
|
||
return _sqrt(var)
|
||
|
||
class NormalDist:
|
||
"""
|
||
Normal distribution of a random variable
|
||
"""
|
||
PRECISION: float
|
||
_mu: float
|
||
_sigma: float
|
||
|
||
def __eq__(self, other: NormalDist):
|
||
return (self._mu - other._mu) < self.PRECISION and (self._sigma - other._sigma) < self.PRECISION
|
||
|
||
def _init(self, mu: float, sigma: float):
|
||
self.PRECISION = 1e-6
|
||
if sigma < 0.0:
|
||
raise StatisticsError('sigma must be non-negative')
|
||
self._mu = mu
|
||
self._sigma = sigma
|
||
|
||
def __init__(self, mu, sigma):
|
||
self._init(float(mu), float(sigma))
|
||
|
||
def __init__(self, mu):
|
||
self._init(float(mu), 1.0)
|
||
|
||
def __init__(self):
|
||
self._init(0.0, 1.0)
|
||
|
||
@property
|
||
def mean(self):
|
||
"""
|
||
Arithmetic mean of the normal distribution.
|
||
"""
|
||
return self._mu
|
||
|
||
@property
|
||
def median(self):
|
||
"""
|
||
Return the median of the normal distribution
|
||
"""
|
||
return self._mu
|
||
|
||
@property
|
||
def mode(self):
|
||
"""
|
||
Return the mode of the normal distribution
|
||
|
||
The mode is the value x where which the probability density
|
||
function (pdf) takes its maximum value.
|
||
"""
|
||
return self._mu
|
||
|
||
@property
|
||
def stdev(self):
|
||
"""
|
||
Standard deviation of the normal distribution.
|
||
"""
|
||
return self._sigma
|
||
|
||
@property
|
||
def variance(self):
|
||
"""
|
||
Square of the standard deviation.
|
||
"""
|
||
return self._sigma ** 2.0
|
||
|
||
def pdf(self, x):
|
||
"""
|
||
Probability density function. P(x <= X < x+dx) / dx
|
||
"""
|
||
variance = self._sigma ** 2.0
|
||
if not variance:
|
||
raise StatisticsError('pdf() not defined when sigma is zero')
|
||
return _exp((x - self._mu) ** 2.0 / (-2.0 * variance)) / _sqrt(_tau * variance)
|
||
|
||
def cdf(self, x):
|
||
"""
|
||
Cumulative distribution function. P(X <= x)
|
||
"""
|
||
if not self._sigma:
|
||
raise StatisticsError('cdf() not defined when sigma is zero')
|
||
return 0.5 * (1.0 + _erf((x - self._mu) / (self._sigma * _sqrt(2.0))))
|
||
|
||
def _normal_dist_inv_cdf(self, p: float, mu: float, sigma: float):
|
||
"""
|
||
Wichura, M.J. (1988). "Algorithm AS241: The Percentage Points of the
|
||
Normal Distribution". Applied Statistics. Blackwell Publishing. 37
|
||
(3): 477–484. doi:10.2307/2347330. JSTOR 2347330.
|
||
"""
|
||
q = p - 0.5
|
||
num = 0.0
|
||
den = 0.0
|
||
if _fabs(q) <= 0.425:
|
||
r = 0.180625 - q * q
|
||
# Hash sum: 55.88319_28806_14901_4439
|
||
num = (((((((2.5090809287301226727e+3 * r +
|
||
3.3430575583588128105e+4) * r +
|
||
6.7265770927008700853e+4) * r +
|
||
4.5921953931549871457e+4) * r +
|
||
1.3731693765509461125e+4) * r +
|
||
1.9715909503065514427e+3) * r +
|
||
1.3314166789178437745e+2) * r +
|
||
3.3871328727963666080e+0) * q
|
||
den = (((((((5.2264952788528545610e+3 * r +
|
||
2.8729085735721942674e+4) * r +
|
||
3.9307895800092710610e+4) * r +
|
||
2.1213794301586595867e+4) * r +
|
||
5.3941960214247511077e+3) * r +
|
||
6.8718700749205790830e+2) * r +
|
||
4.2313330701600911252e+1) * r +
|
||
1.0)
|
||
x = num / den
|
||
return mu + (x * sigma)
|
||
r = p if q <= 0.0 else 1.0 - p
|
||
r = _sqrt(-_log(r))
|
||
if r <= 5.0:
|
||
r = r - 1.6
|
||
# Hash sum: 49.33206_50330_16102_89036
|
||
num = (((((((7.74545014278341407640e-4 * r +
|
||
2.27238449892691845833e-2) * r +
|
||
2.41780725177450611770e-1) * r +
|
||
1.27045825245236838258e+0) * r +
|
||
3.64784832476320460504e+0) * r +
|
||
5.76949722146069140550e+0) * r +
|
||
4.63033784615654529590e+0) * r +
|
||
1.42343711074968357734e+0)
|
||
den = (((((((1.05075007164441684324e-9 * r +
|
||
5.47593808499534494600e-4) * r +
|
||
1.51986665636164571966e-2) * r +
|
||
1.48103976427480074590e-1) * r +
|
||
6.89767334985100004550e-1) * r +
|
||
1.67638483018380384940e+0) * r +
|
||
2.05319162663775882187e+0) * r +
|
||
1.0)
|
||
else:
|
||
r = r - 5.0
|
||
# Hash sum: 47.52583_31754_92896_71629
|
||
num = (((((((2.01033439929228813265e-7 * r +
|
||
2.71155556874348757815e-5) * r +
|
||
1.24266094738807843860e-3) * r +
|
||
2.65321895265761230930e-2) * r +
|
||
2.96560571828504891230e-1) * r +
|
||
1.78482653991729133580e+0) * r +
|
||
5.46378491116411436990e+0) * r +
|
||
6.65790464350110377720e+0)
|
||
den = (((((((2.04426310338993978564e-15 * r +
|
||
1.42151175831644588870e-7) * r +
|
||
1.84631831751005468180e-5) * r +
|
||
7.86869131145613259100e-4) * r +
|
||
1.48753612908506148525e-2) * r +
|
||
1.36929880922735805310e-1) * r +
|
||
5.99832206555887937690e-1) * r +
|
||
1.0)
|
||
x = num / den
|
||
if q < 0.0:
|
||
x = -x
|
||
return mu + (x * sigma)
|
||
|
||
def inv_cdf(self, p: float):
|
||
"""
|
||
Inverse cumulative distribution function. x : P(X <= x) = p
|
||
|
||
Finds the value of the random variable such that the probability of
|
||
the variable being less than or equal to that value equals the given
|
||
probability.
|
||
"""
|
||
if p <= 0.0 or p >= 1.0:
|
||
raise StatisticsError('p must be in the range 0.0 < p < 1.0')
|
||
if self._sigma <= 0.0:
|
||
raise StatisticsError('cdf() not defined when sigma at or below zero')
|
||
return self._normal_dist_inv_cdf(p, self._mu, self._sigma)
|
||
|
||
def quantiles(self, n: int=4):
|
||
"""
|
||
Divide into *n* continuous intervals with equal probability.
|
||
|
||
Returns a list of (n - 1) cut points separating the intervals.
|
||
|
||
Set *n* to 4 for quartiles (the default). Set *n* to 10 for deciles.
|
||
Set *n* to 100 for percentiles which gives the 99 cuts points that
|
||
separate the normal distribution in to 100 equal sized groups.
|
||
"""
|
||
return [self.inv_cdf(float(i)/float(n)) for i in range(1, n)]
|
||
|
||
def overlap(self, other: NormalDist) -> float:
|
||
"""
|
||
Compute the overlapping coefficient (OVL) between two normal distributions.
|
||
|
||
Measures the agreement between two normal probability distributions.
|
||
Returns a value between 0.0 and 1.0 giving the overlapping area in
|
||
the two underlying probability density functions.
|
||
"""
|
||
X, Y = self, other
|
||
|
||
if (Y._sigma, Y._mu) < (X._sigma, X._mu): # sort to assure commutativity
|
||
X, Y = Y, X
|
||
|
||
X_var, Y_var = X.variance, Y.variance
|
||
|
||
if not X_var or not Y_var:
|
||
raise StatisticsError('overlap() not defined when sigma is zero')
|
||
|
||
dv = Y_var - X_var
|
||
dm = _fabs(Y._mu - X._mu)
|
||
|
||
if not dv:
|
||
return 1.0 - _erf(dm / (2.0 * X._sigma * _sqrt(2.0)))
|
||
|
||
a = X._mu * Y_var - Y._mu * X_var
|
||
b = X._sigma * Y._sigma * _sqrt(dm**2.0 + dv * _log(Y_var / X_var))
|
||
x1 = (a + b) / dv
|
||
x2 = (a - b) / dv
|
||
|
||
return 1.0 - (_fabs(Y.cdf(x1) - X.cdf(x1)) + _fabs(Y.cdf(x2) - X.cdf(x2)))
|
||
|
||
def samples(self, n: int):
|
||
"""
|
||
Generate *n* samples for a given mean and standard deviation.
|
||
"""
|
||
gauss = random.gauss
|
||
return [gauss(self._mu, self._sigma) for i in range(n)]
|
||
|
||
def from_samples(data: List[float]):
|
||
"""
|
||
Make a normal distribution instance from sample data.
|
||
TODO/CAVEATS:
|
||
- Assumes input is a list of floats
|
||
- Uses mean instead of fmean for now
|
||
"""
|
||
xbar = mean(data)
|
||
return NormalDist(xbar, stdev(data, xbar))
|
||
|
||
def __add__(x1: NormalDist, x2: NormalDist):
|
||
"""
|
||
Add a constant or another NormalDist instance.
|
||
If *other* is a constant, translate mu by the constant,
|
||
leaving sigma unchanged.
|
||
If *other* is a NormalDist, add both the means and the variances.
|
||
Mathematically, this works only if the two distributions are
|
||
independent or if they are jointly normally distributed.
|
||
"""
|
||
return NormalDist(x1._mu + x2._mu, _hypot(x1._sigma, x2._sigma))
|
||
|
||
def __add__(x1: NormalDist, x2: float):
|
||
"""
|
||
Add a constant or another NormalDist instance.
|
||
If *other* is a constant, translate mu by the constant,
|
||
leaving sigma unchanged.
|
||
If *other* is a NormalDist, add both the means and the variances.
|
||
Mathematically, this works only if the two distributions are
|
||
independent or if they are jointly normally distributed.
|
||
"""
|
||
return NormalDist(x1._mu + x2, x1._sigma)
|
||
|
||
def __sub__(x1: NormalDist, x2: NormalDist):
|
||
"""
|
||
Subtract a constant or another NormalDist instance.
|
||
If *other* is a constant, translate by the constant mu,
|
||
leaving sigma unchanged.
|
||
If *other* is a NormalDist, subtract the means and add the variances.
|
||
Mathematically, this works only if the two distributions are
|
||
independent or if they are jointly normally distributed.
|
||
"""
|
||
return NormalDist(x1._mu - x2._mu, _hypot(x1._sigma, x2._sigma))
|
||
|
||
def __sub__(x1: NormalDist, x2: float):
|
||
"""
|
||
Subtract a constant or another NormalDist instance.
|
||
If *other* is a constant, translate by the constant mu,
|
||
leaving sigma unchanged.
|
||
If *other* is a NormalDist, subtract the means and add the variances.
|
||
Mathematically, this works only if the two distributions are
|
||
independent or if they are jointly normally distributed.
|
||
"""
|
||
return NormalDist(x1._mu - x2, x1._sigma)
|
||
|
||
def __mul__(x1: NormalDist, x2: float):
|
||
"""
|
||
Multiply both mu and sigma by a constant.
|
||
Used for rescaling, perhaps to change measurement units.
|
||
Sigma is scaled with the absolute value of the constant.
|
||
"""
|
||
return NormalDist(x1._mu * x2, x1._sigma * _fabs(x2))
|
||
|
||
def __truediv__(x1: NormalDist, x2: float):
|
||
"""
|
||
Divide both mu and sigma by a constant.
|
||
Used for rescaling, perhaps to change measurement units.
|
||
Sigma is scaled with the absolute value of the constant.
|
||
"""
|
||
return NormalDist(x1._mu / x2, x1._sigma / _fabs(x2))
|
||
|
||
def __pos__(x1: NormalDist):
|
||
return NormalDist(x1._mu, x1._sigma)
|
||
|
||
def __neg__(x1: NormalDist):
|
||
return NormalDist(-x1._mu, x1._sigma)
|
||
|
||
def __radd__(x1: NormalDist, x2: float):
|
||
return x1 + x2
|
||
|
||
def __rsub__(x1: NormalDist, x2: NormalDist):
|
||
return -(x1 - x2)
|
||
|
||
def __rmul__(x1: NormalDist, x2: float):
|
||
return x1 * x2
|
||
|
||
def __eq__(x1: NormalDist, x2: NormalDist):
|
||
return x1._mu == x2._mu and x1._sigma == x2._sigma
|
||
|
||
def __hash__(self):
|
||
return hash((self._mu, self._sigma))
|
||
|
||
def __repr__(self):
|
||
return f'NormalDist(mu={self._mu}, sigma={self._sigma})'
|