def check(mu, sigma):
_value_check(
len(mu) == len(sigma.col(0)),
"Size of the mean vector and covariance matrix are incorrect.")
#check if covariance matrix is positive definite or not.
_value_check((i > 0 for i in sigma.eigenvals().keys()),
"The covariance matrix must be positive definite. ")
def check(mu, sigma, v):
_value_check(mu.shape[0] == sigma.shape[0],
"Size of the location vector and shape matrix are incorrect.")
# check if covariance matrix is positive definite or not.
if not isinstance(sigma, MatrixSymbol):
_value_check(sigma.is_positive_definite,
"The shape matrix must be positive definite. ")
def __new__(cls, sym, p, success=1, failure=0):
_value_check(p >= 0 and p <= 1, 'Value of p must be between 0 and 1.')
sym = _symbol_converter(sym)
p = _sympify(p)
success = _sym_sympify(success)
failure = _sym_sympify(failure)
return Basic.__new__(cls, sym, p, success, failure)
def check(self, mu, sigma, v):
_value_check(
len(mu) == len(sigma.col(0)),
"Size of the location vector and shape matrix are incorrect.")
#check if covariance matrix is positive definite or not.
_value_check(
all([Gt(i, 0) != False for i in sigma.eigenvals().keys()]),
"The shape matrix must be positive definite. ")
def check(self, mu, sigma):
mu, sigma = Matrix([mu]), Matrix(sigma)
_value_check(
len(mu) == len(sigma.col(0)),
"Size of the mean vector and covariance matrix are incorrect.")
#check if covariance matrix is positive definite or not.
_value_check(
all([Gt(i, 0) != False for i in sigma.eigenvals().keys()]),
"The covariance matrix must be positive definite. ")
def check(alpha):
_value_check(
len(alpha) >= 2, "At least two categories should be passed.")
for a_k in alpha:
_value_check(
(a_k > 0) != False,
"Each concentration parameter"
" should be positive.",
)
def __new__(cls, sym, p, success=1, failure=0):
_value_check(p >= 0 and p <= 1, 'Value of p must be between 0 and 1.')
p = _sympify(p)
sym = _symbol_converter(sym)
success = _sym_sympify(success)
failure = _sym_sympify(failure)
state_space = _set_converter([success, failure])
return Basic.__new__(cls, sym, state_space, BernoulliDistribution(p),
p, success, failure)
def check(self, delta, v, l, mu):
_value_check((delta >= 0, delta <= 1), "delta must be in range [0, 1].")
_value_check((v > 0), "v must be positive")
for lk in l:
_value_check((lk > 0), "lamda must be a positive vector.")
for muk in mu:
_value_check((muk > 0), "mu must be a positive vector.")
_value_check(len(l) > 1,"the distribution should have at least"
" two random variables.")
def check(alpha, beta, scale_matrix):
if not isinstance(scale_matrix, MatrixSymbol):
_value_check(scale_matrix.is_positive_definite, "The shape "
"matrix must be positive definite.")
_value_check(scale_matrix.is_square, "Should " "be square matrix")
_value_check(alpha.is_positive, "Shape parameter should be positive.")
_value_check(beta.is_positive, "Scale parameter should be positive.")
def check(k0, p):
_value_check(k0 > 0, "number of failures must be a positive integer")
for p_k in p:
_value_check((p_k >= 0, p_k <= 1),
"probability must be in range [0, 1].")
_value_check(
sum(p) <= 1, "success probabilities must not be greater than 1.")
def check(k, delta, c):
_value_check(k.is_integer and k.is_positive,
"'k' must be a positive integer")
_value_check(
Gt(delta, 0) and Le(delta, 1),
"'delta' must be a real number in the interval (0,1)")
_value_check(c.is_positive, "'c' must be a positive real number.")
def check(n, alpha, beta):
_value_check((n.is_integer, n.is_nonnegative),
"'n' must be nonnegative integer. n = %s." % str(n))
_value_check((alpha > 0),
"'alpha' must be: alpha > 0 . alpha = %s" % str(alpha))
_value_check((beta > 0),
"'beta' must be: beta > 0 . beta = %s" % str(beta))
def check(n, N, m):
_value_check((N.is_integer, N.is_nonnegative),
"'N' must be nonnegative integer. N = %s." % str(n))
_value_check((n.is_integer, n.is_nonnegative),
"'n' must be nonnegative integer. n = %s." % str(n))
_value_check((m.is_integer, m.is_nonnegative),
"'m' must be nonnegative integer. m = %s." % str(n))
def check(n, p):
_value_check(n > 0,
"number of trials must be a positive integer")
for p_k in p:
_value_check((p_k >= 0, p_k <= 1),
"probability must be in range [0, 1]")
_value_check(Eq(sum(p), 1),
"probabilities must sum to 1")
def check(p, succ, fail):
_value_check((p >= 0, p <= 1), "p should be in range [0, 1].")
def check(density):
for p in density.values():
_value_check((p >= 0, p <= 1),
"Probability at a point must be between 0 and 1.")
_value_check(Eq(sum(density.values()), 1),
"Total Probability must be 1.")
def check(s):
_value_check(s > 1, 's should be greater than 1')
def check(a, b):
_value_check(a > 0, "alpha must be positive")
_value_check(b > 0, "beta must be positive")
def check(pdf, set):
x = Dummy('x')
val = Sum(pdf(x), (x, set._inf, set._sup)).doit()
_value_check(
Eq(val, 1) != S.false, "The pdf is incorrect on the given set.")
def check(mu1, mu2):
_value_check(mu1 >= 0, 'Parameter mu1 must be >= 0')
_value_check(mu2 >= 0, 'Parameter mu2 must be >= 0')
def check(mu, s):
_value_check(s > 0, "s must be positive")
def check(p):
_value_check((p > 0, p < 1), "p should be between 0 and 1")
def check(rate):
_value_check(rate > 0, "Rate must be positive.")
def check(alpha, beta):
_value_check(alpha > 0, "Alpha must be positive")
_value_check(beta > 0, "Beta must be positive")
def check(p):
_value_check(And(p > 0, p < 1), "p should be between 0 and 1")
def check(r, p):
_value_check(r > 0, 'r should be positive')
_value_check(And(p > 0, p < 1), 'p should be between 0 and 1')
def check(s):
_value_check(s > 1, 's should be greater than 1')
def check(rho):
_value_check(rho > 0, 'rho should be positive')
def check(self, mu, lamda, alpha, beta):
_value_check(mu.is_real, "Location must be real.")
_value_check(lamda > 0, "Lambda must be positive")
_value_check(alpha > 0, "alpha must be positive")
_value_check(beta > 0, "beta must be positive")
def check(a1, a2):
_value_check(a1.is_nonnegative, 'Parameter a1 must be >= 0.')
_value_check(a2.is_nonnegative, 'Parameter a2 must be >= 0.')
def check(k, theta):
_value_check(k > 0, "k must be positive")
_value_check(theta > 0, "Theta must be positive")
def check(r, p):
_value_check(r > 0, 'r should be positive')
_value_check((p > 0, p < 1), 'p should be between 0 and 1')
def check(xm, alpha):
_value_check(xm > 0, "Xm must be positive")
_value_check(alpha > 0, "Alpha must be positive")
def check(lamda):
_value_check(lamda > 0, "Lambda must be positive")
def check(nu, location_matrix, scale_matrix_1, scale_matrix_2):
if not isinstance(scale_matrix_1, MatrixSymbol):
_value_check(scale_matrix_1.is_positive_definite != False,
"The shape "
"matrix must be positive definite.")
if not isinstance(scale_matrix_2, MatrixSymbol):
_value_check(scale_matrix_2.is_positive_definite != False,
"The shape "
"matrix must be positive definite.")
_value_check(scale_matrix_1.is_square != False,
"Scale matrix 1 should be "
"be square matrix")
_value_check(scale_matrix_2.is_square != False,
"Scale matrix 2 should be "
"be square matrix")
n = location_matrix.shape[0]
p = location_matrix.shape[1]
_value_check(
scale_matrix_1.shape[0] == p, "Scale matrix 1 should be"
" of shape %s x %s" % (str(p), str(p)))
_value_check(
scale_matrix_2.shape[0] == n, "Scale matrix 2 should be"
" of shape %s x %s" % (str(n), str(n)))
_value_check(nu.is_positive != False,
"Degrees of freedom must be positive")
def check(rho):
_value_check(rho > 0, 'rho should be positive')
def check(k):
_value_check(k.is_integer and k.is_positive,
"'k' must be a positive integer.")
def check(a, b):
_value_check(a > 0, "a must be positive")
_value_check(b > 0, "b must be positive")
def check(mean, std):
_value_check(std > 0, "Standard deviation must be positive")
def check(sides):
_value_check(
(sides.is_positive, sides.is_integer),
"number of sides must be a positive integer.",
)
def check(a):
_value_check((0 < a, a < 1), "a must be between 0 and 1")
def check(n, p, succ, fail):
_value_check((n.is_integer, n.is_nonnegative),
"'n' must be nonnegative integer.")
_value_check((p <= 1, p >= 0), "p should be in range [0, 1].")
def check(p):
_value_check((0 < p, p <= 1), "p must be between 0 and 1")
def check(lamda):
_value_check(lamda > 0, "Lambda must be positive")
def check(p):
_value_check(And(0 < p, p <= 1), "p must be between 0 and 1")
def check(self, mu, sigma):
_value_check(len(mu) == len(sigma.col(0)),
"Size of the mean vector and covariance matrix are incorrect.")
#check if covariance matrix is positive definite or not.
_value_check(all([Gt(i, 0) != False for i in sigma.eigenvals().keys()]),
"The covariance matrix must be positive definite. ")
def check(p):
_value_check(0 < p and p <= 1, "p must be between 0 and 1")