def rational_interpolate(data, degnum, X=symbols('x')): """ Returns a rational interpolation, where the data points are element of any integral domain. The first argument contains the data (as a list of coordinates). The ``degnum`` argument is the degree in the numerator of the rational function. Setting it too high will decrease the maximal degree in the denominator for the same amount of data. Examples ======== >>> from sympy.polys.polyfuncs import rational_interpolate >>> data = [(1, -210), (2, -35), (3, 105), (4, 231), (5, 350), (6, 465)] >>> rational_interpolate(data, 2) (105*x**2 - 525)/(x + 1) Values do not need to be integers: >>> from sympy import sympify >>> x = [1, 2, 3, 4, 5, 6] >>> y = sympify("[-1, 0, 2, 22/5, 7, 68/7]") >>> rational_interpolate(zip(x, y), 2) (3*x**2 - 7*x + 2)/(x + 1) The symbol for the variable can be changed if needed: >>> from sympy import symbols >>> z = symbols('z') >>> rational_interpolate(data, 2, X=z) (105*z**2 - 525)/(z + 1) References ========== .. [1] Algorithm is adapted from: http://axiom-wiki.newsynthesis.org/RationalInterpolation """ from sympy.matrices.dense import ones xdata, ydata = list(zip(*data)) k = len(xdata) - degnum - 1 if k < 0: raise OptionError("Too few values for the required degree.") c = ones(degnum + k + 1, degnum + k + 2) for j in range(max(degnum, k)): for i in range(degnum + k + 1): c[i, j + 1] = c[i, j] * xdata[i] for j in range(k + 1): for i in range(degnum + k + 1): c[i, degnum + k + 1 - j] = -c[i, k - j] * ydata[i] r = c.nullspace()[0] return (sum(r[i] * X**i for i in range(degnum + 1)) / sum(r[i + degnum + 1] * X**i for i in range(k + 1)))
def rational_interpolate(data, degnum, X=symbols('x')): """ Returns a rational interpolation, where the data points are element of any integral domain. The first argument contains the data (as a list of coordinates). The ``degnum`` argument is the degree in the numerator of the rational function. Setting it too high will decrease the maximal degree in the denominator for the same amount of data. Examples ======== >>> from sympy.polys.polyfuncs import rational_interpolate >>> data = [(1, -210), (2, -35), (3, 105), (4, 231), (5, 350), (6, 465)] >>> rational_interpolate(data, 2) (105*x**2 - 525)/(x + 1) Values do not need to be integers: >>> from sympy import sympify >>> x = [1, 2, 3, 4, 5, 6] >>> y = sympify("[-1, 0, 2, 22/5, 7, 68/7]") >>> rational_interpolate(zip(x, y), 2) (3*x**2 - 7*x + 2)/(x + 1) The symbol for the variable can be changed if needed: >>> from sympy import symbols >>> z = symbols('z') >>> rational_interpolate(data, 2, X=z) (105*z**2 - 525)/(z + 1) References ========== .. [1] Algorithm is adapted from: http://axiom-wiki.newsynthesis.org/RationalInterpolation """ from sympy.matrices.dense import ones xdata, ydata = list(zip(*data)) k = len(xdata) - degnum - 1 if k < 0: raise OptionError("Too few values for the required degree.") c = ones(degnum + k + 1, degnum + k + 2) for j in range(max(degnum, k)): for i in range(degnum + k + 1): c[i, j + 1] = c[i, j]*xdata[i] for j in range(k + 1): for i in range(degnum + k + 1): c[i, degnum + k + 1 - j] = -c[i, k - j]*ydata[i] r = c.nullspace()[0] return (sum(r[i] * X**i for i in range(degnum + 1)) / sum(r[i + degnum + 1] * X**i for i in range(k + 1)))
def test_empty_Matrix(): sT(ones(0, 3), "MutableDenseMatrix(0, 3, [])") sT(ones(4, 0), "MutableDenseMatrix(4, 0, [])") sT(ones(0, 0), "MutableDenseMatrix([])")
def test_matrix_tensor_product(): if not np: skip("numpy not installed.") l1 = zeros(4) for i in range(16): l1[i] = 2**i l2 = zeros(4) for i in range(16): l2[i] = i l3 = zeros(2) for i in range(4): l3[i] = i vec = Matrix([1, 2, 3]) #test for Matrix known 4x4 matricies numpyl1 = np.array(l1.tolist()) numpyl2 = np.array(l2.tolist()) numpy_product = np.kron(numpyl1, numpyl2) args = [l1, l2] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2, numpyl1) args = [l2, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for other known matrix of different dimensions numpyl2 = np.array(l3.tolist()) numpy_product = np.kron(numpyl1, numpyl2) args = [l1, l3] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2, numpyl1) args = [l3, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for non square matrix numpyl2 = np.array(vec.tolist()) numpy_product = np.kron(numpyl1, numpyl2) args = [l1, vec] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() numpy_product = np.kron(numpyl2, numpyl1) args = [vec, l1] sympy_product = matrix_tensor_product(*args) assert numpy_product.tolist() == sympy_product.tolist() #test for random matrix with random values that are floats random_matrix1 = np.random.rand(randint(1, 5), randint(1, 5)) random_matrix2 = np.random.rand(randint(1, 5), randint(1, 5)) numpy_product = np.kron(random_matrix1, random_matrix2) args = [Matrix(random_matrix1.tolist()), Matrix(random_matrix2.tolist())] sympy_product = matrix_tensor_product(*args) assert not (sympy_product - Matrix(numpy_product.tolist())).tolist() > \ (ones(sympy_product.rows, sympy_product.cols)*epsilon).tolist() #test for three matrix kronecker sympy_product = matrix_tensor_product(l1, vec, l2) numpy_product = np.kron(l1, np.kron(vec, l2)) assert numpy_product.tolist() == sympy_product.tolist()
def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu): """ Extends GeneralizedMultivariateLogGamma. Parameters ========== syms : list/tuple/set of symbols For identifying each component omega : A square matrix Every element of square matrix must be absolute value of square root of correlation coefficient v : Positive real number lamda : List of positive real numbers mu : List of positive real numbers Returns ======= RandomSymbol Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega >>> from sympy import Matrix, symbols, S >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) >>> y = symbols('y_1:4', positive=True) >>> density(G)(y[0], y[1], y[2]) sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2 References ========== .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis Notes ===== If the GeneralizedMultivariateLogGammaOmega is too long to type use, >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO >>> G = GMVLGO('G', omega, v, l, mu) """ _value_check((omega.is_square, isinstance(omega, Matrix)), "omega must be a" " square matrix") for val in omega.values(): _value_check((val >= 0, val <= 1), "all values in matrix must be between 0 and 1(both inclusive).") _value_check(omega.diagonal().equals(ones(1, omega.shape[0])), "all the elements of diagonal should be 1.") _value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)), "lamda, mu should be of same length and omega should " " be of shape (length of lamda, length of mu)") _value_check(len(lamda) > 1,"the distribution should have at least" " two random variables.") delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1)) return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)
def test_banded(): raises(TypeError, lambda: banded()) raises(TypeError, lambda: banded(1)) raises(TypeError, lambda: banded(1, 2)) raises(TypeError, lambda: banded(1, 2, 3)) raises(TypeError, lambda: banded(1, 2, 3, 4)) raises(ValueError, lambda: banded({0: (1, 2)}, rows=1)) raises(ValueError, lambda: banded({0: (1, 2)}, cols=1)) raises(ValueError, lambda: banded(1, {0: (1, 2)})) raises(ValueError, lambda: banded(2, 1, {0: (1, 2)})) raises(ValueError, lambda: banded(1, 2, {0: (1, 2)})) assert isinstance(banded(2, 4, {}), SparseMatrix) assert banded(2, 4, {}) == zeros(2, 4) assert banded({0: 0, 1: 0}) == zeros(0) assert banded({0: Matrix([1, 2])}) == Matrix([1, 2]) assert banded({1: [1, 2, 3, 0], -1: [4, 5, 6]}) == \ banded({1: (1, 2, 3), -1: (4, 5, 6)}) == \ Matrix([ [0, 1, 0, 0], [4, 0, 2, 0], [0, 5, 0, 3], [0, 0, 6, 0]]) assert banded(3, 4, {-1: 1, 0: 2, 1: 3}) == \ Matrix([ [2, 3, 0, 0], [1, 2, 3, 0], [0, 1, 2, 3]]) s = lambda d: (1 + d)**2 assert banded(5, {0: s, 2: s}) == \ Matrix([ [1, 0, 1, 0, 0], [0, 4, 0, 4, 0], [0, 0, 9, 0, 9], [0, 0, 0, 16, 0], [0, 0, 0, 0, 25]]) assert banded(2, {0: 1}) == \ Matrix([ [1, 0], [0, 1]]) assert banded(2, 3, {0: 1}) == \ Matrix([ [1, 0, 0], [0, 1, 0]]) vert = Matrix([1, 2, 3]) assert banded({0: vert}, cols=3) == \ Matrix([ [1, 0, 0], [2, 1, 0], [3, 2, 1], [0, 3, 2], [0, 0, 3]]) assert banded(4, {0: ones(2)}) == \ Matrix([ [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) raises(ValueError, lambda: banded({0: 2, 1: ones(2)}, rows=5)) assert banded({0: 2, 2: (ones(2),)*3}) == \ Matrix([ [2, 0, 1, 1, 0, 0, 0, 0], [0, 2, 1, 1, 0, 0, 0, 0], [0, 0, 2, 0, 1, 1, 0, 0], [0, 0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 0, 2, 0, 1, 1], [0, 0, 0, 0, 0, 2, 1, 1]]) raises(ValueError, lambda: banded({0: (2, ) * 5, 1: (ones(2), ) * 3})) u2 = Matrix([[1, 1], [0, 1]]) assert banded({0: (2,)*5, 1: (u2,)*3}) == \ Matrix([ [2, 1, 1, 0, 0, 0, 0], [0, 2, 1, 0, 0, 0, 0], [0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 2, 1, 0, 0], [0, 0, 0, 0, 2, 1, 1], [0, 0, 0, 0, 0, 0, 1]]) assert banded({0:(0, ones(2)), 2: 2}) == \ Matrix([ [0, 0, 2], [0, 1, 1], [0, 1, 1]]) raises(ValueError, lambda: banded({0: (0, ones(2)), 1: 2})) assert banded({0: 1}, cols=3) == banded({0: 1}, rows=3) == eye(3) assert banded({1: 1}, rows=3) == Matrix([[0, 1, 0], [0, 0, 1], [0, 0, 0]])