|
|
from math import prod |
|
|
|
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.numbers import pi |
|
|
from sympy.core.singleton import S |
|
|
from sympy.functions.elementary.exponential import exp |
|
|
from sympy.functions.special.gamma_functions import multigamma |
|
|
from sympy.core.sympify import sympify, _sympify |
|
|
from sympy.matrices import (ImmutableMatrix, Inverse, Trace, Determinant, |
|
|
MatrixSymbol, MatrixBase, Transpose, MatrixSet, |
|
|
matrix2numpy) |
|
|
from sympy.stats.rv import (_value_check, RandomMatrixSymbol, NamedArgsMixin, PSpace, |
|
|
_symbol_converter, MatrixDomain, Distribution) |
|
|
from sympy.external import import_module |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MatrixPSpace(PSpace): |
|
|
""" |
|
|
Represents probability space for |
|
|
Matrix Distributions. |
|
|
""" |
|
|
def __new__(cls, sym, distribution, dim_n, dim_m): |
|
|
sym = _symbol_converter(sym) |
|
|
dim_n, dim_m = _sympify(dim_n), _sympify(dim_m) |
|
|
if not (dim_n.is_integer and dim_m.is_integer): |
|
|
raise ValueError("Dimensions should be integers") |
|
|
return Basic.__new__(cls, sym, distribution, dim_n, dim_m) |
|
|
|
|
|
distribution = property(lambda self: self.args[1]) |
|
|
symbol = property(lambda self: self.args[0]) |
|
|
|
|
|
@property |
|
|
def domain(self): |
|
|
return MatrixDomain(self.symbol, self.distribution.set) |
|
|
|
|
|
@property |
|
|
def value(self): |
|
|
return RandomMatrixSymbol(self.symbol, self.args[2], self.args[3], self) |
|
|
|
|
|
@property |
|
|
def values(self): |
|
|
return {self.value} |
|
|
|
|
|
def compute_density(self, expr, *args): |
|
|
rms = expr.atoms(RandomMatrixSymbol) |
|
|
if len(rms) > 1 or (not isinstance(expr, RandomMatrixSymbol)): |
|
|
raise NotImplementedError("Currently, no algorithm has been " |
|
|
"implemented to handle general expressions containing " |
|
|
"multiple matrix distributions.") |
|
|
return self.distribution.pdf(expr) |
|
|
|
|
|
def sample(self, size=(), library='scipy', seed=None): |
|
|
""" |
|
|
Internal sample method |
|
|
|
|
|
Returns dictionary mapping RandomMatrixSymbol to realization value. |
|
|
""" |
|
|
return {self.value: self.distribution.sample(size, library=library, seed=seed)} |
|
|
|
|
|
|
|
|
def rv(symbol, cls, args): |
|
|
args = list(map(sympify, args)) |
|
|
dist = cls(*args) |
|
|
dist.check(*args) |
|
|
dim = dist.dimension |
|
|
pspace = MatrixPSpace(symbol, dist, dim[0], dim[1]) |
|
|
return pspace.value |
|
|
|
|
|
|
|
|
class SampleMatrixScipy: |
|
|
"""Returns the sample from scipy of the given distribution""" |
|
|
def __new__(cls, dist, size, seed=None): |
|
|
return cls._sample_scipy(dist, size, seed) |
|
|
|
|
|
@classmethod |
|
|
def _sample_scipy(cls, dist, size, seed): |
|
|
"""Sample from SciPy.""" |
|
|
|
|
|
from scipy import stats as scipy_stats |
|
|
import numpy |
|
|
scipy_rv_map = { |
|
|
'WishartDistribution': lambda dist, size, rand_state: scipy_stats.wishart.rvs( |
|
|
df=int(dist.n), scale=matrix2numpy(dist.scale_matrix, float), size=size), |
|
|
'MatrixNormalDistribution': lambda dist, size, rand_state: scipy_stats.matrix_normal.rvs( |
|
|
mean=matrix2numpy(dist.location_matrix, float), |
|
|
rowcov=matrix2numpy(dist.scale_matrix_1, float), |
|
|
colcov=matrix2numpy(dist.scale_matrix_2, float), size=size, random_state=rand_state) |
|
|
} |
|
|
|
|
|
sample_shape = { |
|
|
'WishartDistribution': lambda dist: dist.scale_matrix.shape, |
|
|
'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape |
|
|
} |
|
|
|
|
|
dist_list = scipy_rv_map.keys() |
|
|
|
|
|
if dist.__class__.__name__ not in dist_list: |
|
|
return None |
|
|
|
|
|
if seed is None or isinstance(seed, int): |
|
|
rand_state = numpy.random.default_rng(seed=seed) |
|
|
else: |
|
|
rand_state = seed |
|
|
samp = scipy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state) |
|
|
return samp.reshape(size + sample_shape[dist.__class__.__name__](dist)) |
|
|
|
|
|
|
|
|
class SampleMatrixNumpy: |
|
|
"""Returns the sample from numpy of the given distribution""" |
|
|
|
|
|
|
|
|
def __new__(cls, dist, size, seed=None): |
|
|
return cls._sample_numpy(dist, size, seed) |
|
|
|
|
|
@classmethod |
|
|
def _sample_numpy(cls, dist, size, seed): |
|
|
"""Sample from NumPy.""" |
|
|
|
|
|
numpy_rv_map = { |
|
|
} |
|
|
|
|
|
sample_shape = { |
|
|
} |
|
|
|
|
|
dist_list = numpy_rv_map.keys() |
|
|
|
|
|
if dist.__class__.__name__ not in dist_list: |
|
|
return None |
|
|
|
|
|
import numpy |
|
|
if seed is None or isinstance(seed, int): |
|
|
rand_state = numpy.random.default_rng(seed=seed) |
|
|
else: |
|
|
rand_state = seed |
|
|
samp = numpy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state) |
|
|
return samp.reshape(size + sample_shape[dist.__class__.__name__](dist)) |
|
|
|
|
|
|
|
|
class SampleMatrixPymc: |
|
|
"""Returns the sample from pymc of the given distribution""" |
|
|
|
|
|
def __new__(cls, dist, size, seed=None): |
|
|
return cls._sample_pymc(dist, size, seed) |
|
|
|
|
|
@classmethod |
|
|
def _sample_pymc(cls, dist, size, seed): |
|
|
"""Sample from PyMC.""" |
|
|
|
|
|
try: |
|
|
import pymc |
|
|
except ImportError: |
|
|
import pymc3 as pymc |
|
|
pymc_rv_map = { |
|
|
'MatrixNormalDistribution': lambda dist: pymc.MatrixNormal('X', |
|
|
mu=matrix2numpy(dist.location_matrix, float), |
|
|
rowcov=matrix2numpy(dist.scale_matrix_1, float), |
|
|
colcov=matrix2numpy(dist.scale_matrix_2, float), |
|
|
shape=dist.location_matrix.shape), |
|
|
'WishartDistribution': lambda dist: pymc.WishartBartlett('X', |
|
|
nu=int(dist.n), S=matrix2numpy(dist.scale_matrix, float)) |
|
|
} |
|
|
|
|
|
sample_shape = { |
|
|
'WishartDistribution': lambda dist: dist.scale_matrix.shape, |
|
|
'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape |
|
|
} |
|
|
|
|
|
dist_list = pymc_rv_map.keys() |
|
|
|
|
|
if dist.__class__.__name__ not in dist_list: |
|
|
return None |
|
|
import logging |
|
|
logging.getLogger("pymc").setLevel(logging.ERROR) |
|
|
with pymc.Model(): |
|
|
pymc_rv_map[dist.__class__.__name__](dist) |
|
|
samps = pymc.sample(draws=prod(size), chains=1, progressbar=False, random_seed=seed, return_inferencedata=False, compute_convergence_checks=False)['X'] |
|
|
return samps.reshape(size + sample_shape[dist.__class__.__name__](dist)) |
|
|
|
|
|
_get_sample_class_matrixrv = { |
|
|
'scipy': SampleMatrixScipy, |
|
|
'pymc3': SampleMatrixPymc, |
|
|
'pymc': SampleMatrixPymc, |
|
|
'numpy': SampleMatrixNumpy |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MatrixDistribution(Distribution, NamedArgsMixin): |
|
|
""" |
|
|
Abstract class for Matrix Distribution. |
|
|
""" |
|
|
def __new__(cls, *args): |
|
|
args = [ImmutableMatrix(arg) if isinstance(arg, list) |
|
|
else _sympify(arg) for arg in args] |
|
|
return Basic.__new__(cls, *args) |
|
|
|
|
|
@staticmethod |
|
|
def check(*args): |
|
|
pass |
|
|
|
|
|
def __call__(self, expr): |
|
|
if isinstance(expr, list): |
|
|
expr = ImmutableMatrix(expr) |
|
|
return self.pdf(expr) |
|
|
|
|
|
def sample(self, size=(), library='scipy', seed=None): |
|
|
""" |
|
|
Internal sample method |
|
|
|
|
|
Returns dictionary mapping RandomSymbol to realization value. |
|
|
""" |
|
|
|
|
|
libraries = ['scipy', 'numpy', 'pymc3', 'pymc'] |
|
|
if library not in libraries: |
|
|
raise NotImplementedError("Sampling from %s is not supported yet." |
|
|
% str(library)) |
|
|
if not import_module(library): |
|
|
raise ValueError("Failed to import %s" % library) |
|
|
|
|
|
samps = _get_sample_class_matrixrv[library](self, size, seed) |
|
|
|
|
|
if samps is not None: |
|
|
return samps |
|
|
raise NotImplementedError( |
|
|
"Sampling for %s is not currently implemented from %s" |
|
|
% (self.__class__.__name__, library) |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MatrixGammaDistribution(MatrixDistribution): |
|
|
|
|
|
_argnames = ('alpha', 'beta', 'scale_matrix') |
|
|
|
|
|
@staticmethod |
|
|
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.") |
|
|
|
|
|
@property |
|
|
def set(self): |
|
|
k = self.scale_matrix.shape[0] |
|
|
return MatrixSet(k, k, S.Reals) |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return self.scale_matrix.shape |
|
|
|
|
|
def pdf(self, x): |
|
|
alpha, beta, scale_matrix = self.alpha, self.beta, self.scale_matrix |
|
|
p = scale_matrix.shape[0] |
|
|
if isinstance(x, list): |
|
|
x = ImmutableMatrix(x) |
|
|
if not isinstance(x, (MatrixBase, MatrixSymbol)): |
|
|
raise ValueError("%s should be an isinstance of Matrix " |
|
|
"or MatrixSymbol" % str(x)) |
|
|
sigma_inv_x = - Inverse(scale_matrix)*x / beta |
|
|
term1 = exp(Trace(sigma_inv_x))/((beta**(p*alpha)) * multigamma(alpha, p)) |
|
|
term2 = (Determinant(scale_matrix))**(-alpha) |
|
|
term3 = (Determinant(x))**(alpha - S(p + 1)/2) |
|
|
return term1 * term2 * term3 |
|
|
|
|
|
def MatrixGamma(symbol, alpha, beta, scale_matrix): |
|
|
""" |
|
|
Creates a random variable with Matrix Gamma Distribution. |
|
|
|
|
|
The density of the said distribution can be found at [1]. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
alpha: Positive Real number |
|
|
Shape Parameter |
|
|
beta: Positive Real number |
|
|
Scale Parameter |
|
|
scale_matrix: Positive definite real square matrix |
|
|
Scale Matrix |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
RandomSymbol |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import density, MatrixGamma |
|
|
>>> from sympy import MatrixSymbol, symbols |
|
|
>>> a, b = symbols('a b', positive=True) |
|
|
>>> M = MatrixGamma('M', a, b, [[2, 1], [1, 2]]) |
|
|
>>> X = MatrixSymbol('X', 2, 2) |
|
|
>>> density(M)(X).doit() |
|
|
exp(Trace(Matrix([ |
|
|
[-2/3, 1/3], |
|
|
[ 1/3, -2/3]])*X)/b)*Determinant(X)**(a - 3/2)/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2)) |
|
|
>>> density(M)([[1, 0], [0, 1]]).doit() |
|
|
exp(-4/(3*b))/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2)) |
|
|
|
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Matrix_gamma_distribution |
|
|
|
|
|
""" |
|
|
if isinstance(scale_matrix, list): |
|
|
scale_matrix = ImmutableMatrix(scale_matrix) |
|
|
return rv(symbol, MatrixGammaDistribution, (alpha, beta, scale_matrix)) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class WishartDistribution(MatrixDistribution): |
|
|
|
|
|
_argnames = ('n', 'scale_matrix') |
|
|
|
|
|
@staticmethod |
|
|
def check(n, 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(n.is_positive, "Shape parameter should be positive.") |
|
|
|
|
|
@property |
|
|
def set(self): |
|
|
k = self.scale_matrix.shape[0] |
|
|
return MatrixSet(k, k, S.Reals) |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return self.scale_matrix.shape |
|
|
|
|
|
def pdf(self, x): |
|
|
n, scale_matrix = self.n, self.scale_matrix |
|
|
p = scale_matrix.shape[0] |
|
|
if isinstance(x, list): |
|
|
x = ImmutableMatrix(x) |
|
|
if not isinstance(x, (MatrixBase, MatrixSymbol)): |
|
|
raise ValueError("%s should be an isinstance of Matrix " |
|
|
"or MatrixSymbol" % str(x)) |
|
|
sigma_inv_x = - Inverse(scale_matrix)*x / S(2) |
|
|
term1 = exp(Trace(sigma_inv_x))/((2**(p*n/S(2))) * multigamma(n/S(2), p)) |
|
|
term2 = (Determinant(scale_matrix))**(-n/S(2)) |
|
|
term3 = (Determinant(x))**(S(n - p - 1)/2) |
|
|
return term1 * term2 * term3 |
|
|
|
|
|
def Wishart(symbol, n, scale_matrix): |
|
|
""" |
|
|
Creates a random variable with Wishart Distribution. |
|
|
|
|
|
The density of the said distribution can be found at [1]. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
n: Positive Real number |
|
|
Represents degrees of freedom |
|
|
scale_matrix: Positive definite real square matrix |
|
|
Scale Matrix |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
RandomSymbol |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import density, Wishart |
|
|
>>> from sympy import MatrixSymbol, symbols |
|
|
>>> n = symbols('n', positive=True) |
|
|
>>> W = Wishart('W', n, [[2, 1], [1, 2]]) |
|
|
>>> X = MatrixSymbol('X', 2, 2) |
|
|
>>> density(W)(X).doit() |
|
|
exp(Trace(Matrix([ |
|
|
[-1/3, 1/6], |
|
|
[ 1/6, -1/3]])*X))*Determinant(X)**(n/2 - 3/2)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2)) |
|
|
>>> density(W)([[1, 0], [0, 1]]).doit() |
|
|
exp(-2/3)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2)) |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Wishart_distribution |
|
|
|
|
|
""" |
|
|
if isinstance(scale_matrix, list): |
|
|
scale_matrix = ImmutableMatrix(scale_matrix) |
|
|
return rv(symbol, WishartDistribution, (n, scale_matrix)) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MatrixNormalDistribution(MatrixDistribution): |
|
|
|
|
|
_argnames = ('location_matrix', 'scale_matrix_1', 'scale_matrix_2') |
|
|
|
|
|
@staticmethod |
|
|
def check(location_matrix, scale_matrix_1, scale_matrix_2): |
|
|
if not isinstance(scale_matrix_1, MatrixSymbol): |
|
|
_value_check(scale_matrix_1.is_positive_definite, "The shape " |
|
|
"matrix must be positive definite.") |
|
|
if not isinstance(scale_matrix_2, MatrixSymbol): |
|
|
_value_check(scale_matrix_2.is_positive_definite, "The shape " |
|
|
"matrix must be positive definite.") |
|
|
_value_check(scale_matrix_1.is_square, "Scale matrix 1 should be " |
|
|
"be square matrix") |
|
|
_value_check(scale_matrix_2.is_square, "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] == n, "Scale matrix 1 should be" |
|
|
" of shape %s x %s"% (str(n), str(n))) |
|
|
_value_check(scale_matrix_2.shape[0] == p, "Scale matrix 2 should be" |
|
|
" of shape %s x %s"% (str(p), str(p))) |
|
|
|
|
|
@property |
|
|
def set(self): |
|
|
n, p = self.location_matrix.shape |
|
|
return MatrixSet(n, p, S.Reals) |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return self.location_matrix.shape |
|
|
|
|
|
def pdf(self, x): |
|
|
M, U, V = self.location_matrix, self.scale_matrix_1, self.scale_matrix_2 |
|
|
n, p = M.shape |
|
|
if isinstance(x, list): |
|
|
x = ImmutableMatrix(x) |
|
|
if not isinstance(x, (MatrixBase, MatrixSymbol)): |
|
|
raise ValueError("%s should be an isinstance of Matrix " |
|
|
"or MatrixSymbol" % str(x)) |
|
|
term1 = Inverse(V)*Transpose(x - M)*Inverse(U)*(x - M) |
|
|
num = exp(-Trace(term1)/S(2)) |
|
|
den = (2*pi)**(S(n*p)/2) * Determinant(U)**(S(p)/2) * Determinant(V)**(S(n)/2) |
|
|
return num/den |
|
|
|
|
|
def MatrixNormal(symbol, location_matrix, scale_matrix_1, scale_matrix_2): |
|
|
""" |
|
|
Creates a random variable with Matrix Normal Distribution. |
|
|
|
|
|
The density of the said distribution can be found at [1]. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
location_matrix: Real ``n x p`` matrix |
|
|
Represents degrees of freedom |
|
|
scale_matrix_1: Positive definite matrix |
|
|
Scale Matrix of shape ``n x n`` |
|
|
scale_matrix_2: Positive definite matrix |
|
|
Scale Matrix of shape ``p x p`` |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
RandomSymbol |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import MatrixSymbol |
|
|
>>> from sympy.stats import density, MatrixNormal |
|
|
>>> M = MatrixNormal('M', [[1, 2]], [1], [[1, 0], [0, 1]]) |
|
|
>>> X = MatrixSymbol('X', 1, 2) |
|
|
>>> density(M)(X).doit() |
|
|
exp(-Trace((Matrix([ |
|
|
[-1], |
|
|
[-2]]) + X.T)*(Matrix([[-1, -2]]) + X))/2)/(2*pi) |
|
|
>>> density(M)([[3, 4]]).doit() |
|
|
exp(-4)/(2*pi) |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Matrix_normal_distribution |
|
|
|
|
|
""" |
|
|
if isinstance(location_matrix, list): |
|
|
location_matrix = ImmutableMatrix(location_matrix) |
|
|
if isinstance(scale_matrix_1, list): |
|
|
scale_matrix_1 = ImmutableMatrix(scale_matrix_1) |
|
|
if isinstance(scale_matrix_2, list): |
|
|
scale_matrix_2 = ImmutableMatrix(scale_matrix_2) |
|
|
args = (location_matrix, scale_matrix_1, scale_matrix_2) |
|
|
return rv(symbol, MatrixNormalDistribution, args) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MatrixStudentTDistribution(MatrixDistribution): |
|
|
|
|
|
_argnames = ('nu', 'location_matrix', 'scale_matrix_1', 'scale_matrix_2') |
|
|
|
|
|
@staticmethod |
|
|
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") |
|
|
|
|
|
@property |
|
|
def set(self): |
|
|
n, p = self.location_matrix.shape |
|
|
return MatrixSet(n, p, S.Reals) |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return self.location_matrix.shape |
|
|
|
|
|
def pdf(self, x): |
|
|
from sympy.matrices.dense import eye |
|
|
if isinstance(x, list): |
|
|
x = ImmutableMatrix(x) |
|
|
if not isinstance(x, (MatrixBase, MatrixSymbol)): |
|
|
raise ValueError("%s should be an isinstance of Matrix " |
|
|
"or MatrixSymbol" % str(x)) |
|
|
nu, M, Omega, Sigma = self.nu, self.location_matrix, self.scale_matrix_1, self.scale_matrix_2 |
|
|
n, p = M.shape |
|
|
|
|
|
K = multigamma((nu + n + p - 1)/2, p) * Determinant(Omega)**(-n/2) * Determinant(Sigma)**(-p/2) \ |
|
|
/ ((pi)**(n*p/2) * multigamma((nu + p - 1)/2, p)) |
|
|
return K * (Determinant(eye(n) + Inverse(Sigma)*(x - M)*Inverse(Omega)*Transpose(x - M))) \ |
|
|
**(-(nu + n + p -1)/2) |
|
|
|
|
|
|
|
|
|
|
|
def MatrixStudentT(symbol, nu, location_matrix, scale_matrix_1, scale_matrix_2): |
|
|
""" |
|
|
Creates a random variable with Matrix Gamma Distribution. |
|
|
|
|
|
The density of the said distribution can be found at [1]. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
nu: Positive Real number |
|
|
degrees of freedom |
|
|
location_matrix: Positive definite real square matrix |
|
|
Location Matrix of shape ``n x p`` |
|
|
scale_matrix_1: Positive definite real square matrix |
|
|
Scale Matrix of shape ``p x p`` |
|
|
scale_matrix_2: Positive definite real square matrix |
|
|
Scale Matrix of shape ``n x n`` |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
RandomSymbol |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import MatrixSymbol,symbols |
|
|
>>> from sympy.stats import density, MatrixStudentT |
|
|
>>> v = symbols('v',positive=True) |
|
|
>>> M = MatrixStudentT('M', v, [[1, 2]], [[1, 0], [0, 1]], [1]) |
|
|
>>> X = MatrixSymbol('X', 1, 2) |
|
|
>>> density(M)(X) |
|
|
gamma(v/2 + 1)*Determinant((Matrix([[-1, -2]]) + X)*(Matrix([ |
|
|
[-1], |
|
|
[-2]]) + X.T) + Matrix([[1]]))**(-v/2 - 1)/(pi**1.0*gamma(v/2)*Determinant(Matrix([[1]]))**1.0*Determinant(Matrix([ |
|
|
[1, 0], |
|
|
[0, 1]]))**0.5) |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Matrix_t-distribution |
|
|
|
|
|
""" |
|
|
if isinstance(location_matrix, list): |
|
|
location_matrix = ImmutableMatrix(location_matrix) |
|
|
if isinstance(scale_matrix_1, list): |
|
|
scale_matrix_1 = ImmutableMatrix(scale_matrix_1) |
|
|
if isinstance(scale_matrix_2, list): |
|
|
scale_matrix_2 = ImmutableMatrix(scale_matrix_2) |
|
|
args = (nu, location_matrix, scale_matrix_1, scale_matrix_2) |
|
|
return rv(symbol, MatrixStudentTDistribution, args) |
|
|
|
