Did I find the right examples for you? yes no

All Samples(148)  |  Call(119)  |  Derive(0)  |  Import(29)
Create zero matrix of dimensions dims = (d1,d2)

        def zeros(dims):
    """Create zero matrix of dimensions dims = (d1,d2)"""
    n, m = _dims_to_nm(dims)
    return Matrix(n, m, [S.Zero]*m*n)
        


src/s/y/sympy-HEAD/sympy/polys/solvers.py   sympy(Download)
"""Low-level linear systems solver. """
 
from __future__ import print_function, division
 
from sympy.matrices import Matrix, zeros
def eqs_to_matrix(eqs, ring):
    """Transform from equations to matrix form. """
    xs = ring.gens
    M = zeros(len(eqs), len(xs)+1, cls=RawMatrix)
 

src/s/y/sympy-HEAD/sympy/simplify/hyperexpand.py   sympy(Download)
           z d/dz B = M B.
        """
        from sympy.matrices import Matrix, eye, zeros
 
        afactors = [_x + a for a in self.func.ap]
 
        m = eye(n)
        m = m.col_insert(0, zeros(n, 1))
        l = poly.all_coeffs()[1:]
        l.reverse()
    # We don't need to implement the reduction to polylog here, this
    # is handled by expand_func.
    from sympy.matrices import Matrix, zeros
    from sympy.polys import apart
 
    for b, c in coeffs.items():
        C[trans[b]] = Add(*c)
    M = zeros(len(B))
    for b, l in deriv.items():
        for c, b2 in l:

src/s/y/sympy-0.7.5/sympy/simplify/hyperexpand.py   sympy(Download)
           z d/dz B = M B.
        """
        from sympy.matrices import Matrix, eye, zeros
 
        afactors = [_x + a for a in self.func.ap]
 
        m = eye(n)
        m = m.col_insert(0, zeros(n, 1))
        l = poly.all_coeffs()[1:]
        l.reverse()
    # We don't need to implement the reduction to polylog here, this
    # is handled by expand_func.
    from sympy.matrices import Matrix, zeros
    from sympy.polys import apart
 
    for b, c in coeffs.items():
        C[trans[b]] = Add(*c)
    M = zeros(len(B))
    for b, l in deriv.items():
        for c, b2 in l:

src/s/y/sympy-HEAD/sympy/integrals/prde.py   sympy(Download)
from sympy.core import Dummy, ilcm, Add, Mul, Pow, S
 
from sympy.matrices import Matrix, zeros, eye
 
from sympy import im, sqrt, re
    if all(qi.is_zero for qi in Q):
        dc = -1
        M = zeros(0, 2)
    else:
        dc = max([qi.degree(t) for qi in Q])
        M = Matrix(dc + 1, m, lambda i, j: Q[j].nth(i))
    A, u = constant_system(M, zeros(dc + 1, 1), DE)
            dc = max([qi.degree(DE.t) for qi in Q])
            M = Matrix(dc + 1, m, lambda i, j: Q[j].nth(i))
        A, u = constant_system(M, zeros(dc + 1, 1), DE)
        c = eye(m)
        A = A.row_join(zeros(A.rows, m)).col_join(c.row_join(-c))
        gia, gid in G]
    Q, M = prde_linear_constraints(A, B, G, DE)
    M, _ = constant_system(M, zeros(M.rows, 1), DE)
    # Reduce number of constants at this point
    try:

src/s/y/sympy-0.7.5/sympy/integrals/prde.py   sympy(Download)
from sympy.core import Dummy, ilcm, Add, Mul, Pow, S
 
from sympy.matrices import Matrix, zeros, eye
 
from sympy import im, sqrt, re
    if all(qi.is_zero for qi in Q):
        dc = -1
        M = zeros(0, 2)
    else:
        dc = max([qi.degree(t) for qi in Q])
        M = Matrix(dc + 1, m, lambda i, j: Q[j].nth(i))
    A, u = constant_system(M, zeros(dc + 1, 1), DE)
            dc = max([qi.degree(DE.t) for qi in Q])
            M = Matrix(dc + 1, m, lambda i, j: Q[j].nth(i))
        A, u = constant_system(M, zeros(dc + 1, 1), DE)
        c = eye(m)
        A = A.row_join(zeros(A.rows, m)).col_join(c.row_join(-c))
        gia, gid in G]
    Q, M = prde_linear_constraints(A, B, G, DE)
    M, _ = constant_system(M, zeros(M.rows, 1), DE)
    # Reduce number of constants at this point
    try:

src/s/y/sympy-0.7.5/sympy/matrices/matrices.py   sympy(Download)
    def nullspace(self, simplified=False, simplify=False):
        """Returns list of vectors (Matrix objects) that span nullspace of self
        """
        from sympy.matrices import zeros
 
        # create a set of vectors for the basis
        for i in range(self.cols - len(pivots)):
            basis.append(zeros(self.cols, 1))
        # contains the variable index to which the vector corresponds
        basiskey, cur = [-1]*len(basis), 0
        berkowitz_eigenvals
        """
        from sympy.matrices import zeros
 
        if not self.is_square:
 
        for n in range(N, 1, -1):
            T, k = zeros(n + 1, n), n - 1
 
            R, C = -A[k, :k], A[:k, k]
        vec
        """
        from sympy.matrices import zeros
 
        c = self.cols

src/s/y/sympy-HEAD/sympy/matrices/matrices.py   sympy(Download)
    def nullspace(self, simplified=False, simplify=False):
        """Returns list of vectors (Matrix objects) that span nullspace of self
        """
        from sympy.matrices import zeros
 
        # create a set of vectors for the basis
        for i in range(self.cols - len(pivots)):
            basis.append(zeros(self.cols, 1))
        # contains the variable index to which the vector corresponds
        basiskey, cur = [-1]*len(basis), 0
        berkowitz_eigenvals
        """
        from sympy.matrices import zeros
 
        if not self.is_square:
 
        for n in range(N, 1, -1):
            T, k = zeros(n + 1, n), n - 1
 
            R, C = -A[k, :k], A[:k, k]
        vec
        """
        from sympy.matrices import zeros
 
        c = self.cols

src/s/y/sympy-HEAD/sympy/physics/quantum/matrixutils.py   sympy(Download)
 
from sympy import Matrix, I, Expr, Integer
from sympy.matrices import eye, zeros
from sympy.external import import_module
 
    spmatrix = options.get('spmatrix', 'csr')
    if format == 'sympy':
        return zeros(m, n)
    elif format == 'numpy':
        return _numpy_zeros(m, n, **options)
def matrix_to_zero(e):
    """Convert a zero matrix to the scalar zero."""
    if isinstance(e, Matrix):
        if zeros(*e.shape) == e:
            e = Integer(0)

src/s/y/sympy-HEAD/sympy/physics/quantum/qubit.py   sympy(Download)
from sympy.core.basic import sympify
from sympy.core.compatibility import string_types, xrange
from sympy.matrices import Matrix, zeros
from sympy.printing.pretty.stringpict import prettyForm
 
    output_matrices = []
    for i in range(1 << len(bits)):
        output_matrices.append(zeros(2**nqubits, 1))
 
    # Bitmasks will help sort how to determine possible outcomes.

src/s/y/sympy-HEAD/sympy/physics/quantum/spin.py   sympy(Download)
                   Tuple, Dummy)
from sympy.core.compatibility import u, unicode
from sympy.matrices import zeros
from sympy.printing.pretty.stringpict import prettyForm, stringPict
from sympy.printing.pretty.pretty_symbology import pretty_symbol
    def _represent_base(self, basis, **options):
        j = options.get('j', Rational(1, 2))
        size, mvals = m_values(j)
        result = zeros(size, size)
        for p in range(size):
        evaluate = sympify(options.get('doit'))
        size, mvals = m_values(j)
        result = zeros(size, size)
        for p in range(size):
            for q in range(size):
        gamma = sympify(options.get('gamma', 0))
        size, mvals = m_values(j)
        result = zeros(size, 1)
        # TODO: Use KroneckerDelta if all Euler angles == 0
        # breaks finding angles on L930
            raise ValueError(
                'State must not have symbolic j values to represent')
        result = zeros(self.hilbert_space.dimension, 1)
        if self.j == int(self.j):
            start = self.j**2

  1 | 2 | 3  Next