Python Matrix.col_join方法代码示例

# 需要导入模块: from sympy import Matrix [as 别名]
# 或者: from sympy.Matrix import col_join [as 别名]
print 'Qb: ',Qb
QsT = Matrix([B.transpose(),\
             (A*B).transpose(),\
             (A**2*B).transpose(),\
             (A**3*B).transpose()])
Qs = QsT.transpose()
print 'Qs: ',Qs
print 'A: ',A
print 'B: ',B
print 'C: ',C


'''
Nachweis der Steuerbarkeit des erweiterten Zustandsraummodells
'''
Aquer = A.col_join(C).row_join(sp.zeros(5,1))
Bquer = B.col_join(sp.zeros(1,1))
Cquer = C.row_join(sp.zeros(1,1))


'''
Übertragungsfunktion des Linearisierten Systems
'''
G = C*(sp.eye(4)*s - A)**-1*B

# Steuerbarkeitsmatrix berechnen
n = 5
Qsquer = sp.Matrix()
for i in range(5):
    q = (Aquer**i)*Bquer
    if len(Qsquer) == 0:

# 需要导入模块: from sympy import Matrix [as 别名]
# 或者: from sympy.Matrix import col_join [as 别名]

#.........这里部分代码省略.........
    Notes
    =====

    m : number of generalized speeds
    n : number of generalized coordinates
    o : number of states

    """

    def __init__(self, coord_states, right_hand_side, speeds=None,
                 mass_matrix=None, coordinate_derivatives=None, alg_con=None,
                 output_eqns={}, coord_idxs=None, speed_idxs=None, bodies=None,
                 loads=None):
        """Initializes a SymbolicSystem object"""

        # Extract information on speeds, coordinates and states
        if speeds is None:
            self._states = Matrix(coord_states)

            if coord_idxs is None:
                self._coordinates = None
            else:
                coords = [coord_states[i] for i in coord_idxs]
                self._coordinates = Matrix(coords)

            if speed_idxs is None:
                self._speeds = None
            else:
                speeds_inter = [coord_states[i] for i in speed_idxs]
                self._speeds = Matrix(speeds_inter)
        else:
            self._coordinates = Matrix(coord_states)
            self._speeds = Matrix(speeds)
            self._states = self._coordinates.col_join(self._speeds)

        # Extract equations of motion form
        if coordinate_derivatives is not None:
            self._kin_explicit_rhs = coordinate_derivatives
            self._dyn_implicit_rhs = right_hand_side
            self._dyn_implicit_mat = mass_matrix
            self._comb_implicit_rhs = None
            self._comb_implicit_mat = None
            self._comb_explicit_rhs = None
        elif mass_matrix is not None:
            self._kin_explicit_rhs = None
            self._dyn_implicit_rhs = None
            self._dyn_implicit_mat = None
            self._comb_implicit_rhs = right_hand_side
            self._comb_implicit_mat = mass_matrix
            self._comb_explicit_rhs = None
        else:
            self._kin_explicit_rhs = None
            self._dyn_implicit_rhs = None
            self._dyn_implicit_mat = None
            self._comb_implicit_rhs = None
            self._comb_implicit_mat = None
            self._comb_explicit_rhs = right_hand_side

        # Set the remainder of the inputs as instance attributes
        if alg_con is not None and coordinate_derivatives is not None:
            alg_con = [i + len(coordinate_derivatives) for i in alg_con]
        self._alg_con = alg_con
        self.output_eqns = output_eqns

        # Change the body and loads iterables to tuples if they are not tuples
        # already

# 需要导入模块: from sympy import Matrix [as 别名]
# 或者: from sympy.Matrix import col_join [as 别名]
def buchMol(points, ordering, weightVector=(1, 1, 1)):
    """
	Given X = [(c11,c12,...,c1n),...,(cs1,cs2,...,csn)] affine point set
	and ordering 'lex','grlex','grevlex', or 'weighted' (plus a weight vector)
	computes reduced Groebner basis and Q-basis of the ring mod the ideal
	"""
    from sympy import symbols, Poly, div, Rational, Matrix
    from newLT import monomialOrdering

    dim = len(points[0])
    for pt in points:  # check that all pts have same dimension
        assert len(pt) == dim
    if dim in [1, 2, 3]:
        l = ["x", "x,y", "x,y,z"]
        varlist = symbols(l[dim - 1])
    else:
        varstring = "x0"
        for i in xrange(1, dim):
            varstring += ",x" + str(i)
        varlist = symbols(varstring)
    monClass = monomialOrdering(varlist, ordering, weightVector)
    counter = 0  # keep track of number of rows of matrix & size of S
    G, normalSet, S = [], [], []
    L = [Poly(1, varlist, domain="QQ")]
    M = Matrix(0, len(points), [])
    pivots = {}  # {column:row}
    while L != []:
        # step 2:
        t = L[0]
        for elmt in L:
            if monClass.compare(t.as_dict().keys()[0], elmt.as_dict().keys()[0]):
                t = elmt
        L.remove(t)
        evalVector = Matrix(1, len(points), [t.eval(pt) for pt in points])
        print "hi"
        print M
        print evalVector
        v, a = vecReduce(evalVector, M, pivots)
        print v
        viszero = False
        if firstNonzero(v) == -1:
            viszero = True
        toAdd = t
        for i in xrange(counter):
            toAdd += Poly(-1, varlist) * Poly(a[i], varlist) * S[i]
        if viszero:
            G.append(toAdd)
            for mon in L:
                if div(t, mon)[1] == 0:
                    L.remove(mon)
        else:
            pivSpot = firstNonzero(v)
            pivots[pivSpot] = M.shape[0]
            M = M.col_join(v)
            S.append(toAdd)
            counter += 1
            normalSet.append(t)
            for variable in varlist:
                toCheck = Poly(variable, varlist) * t
                isMultiple = False
                for elmt in L:
                    if div(elmt, toCheck)[1] == 0:
                        isMultiple = True
                        break
                if isMultiple:
                    continue
                for elmt in G:
                    if div(monClass.LT(elmt), toCheck)[1] == 0:
                        isMultiple = True
                        break
                if isMultiple == False:
                    L.append(toCheck)
    return G, normalSet