Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ['Beam',
+            'Truss']
+
+from .beam import Beam
+from .truss import Truss

env-llmeval/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/truss.py

@@ -0,0 +1,735 @@
+"""
+This module can be used to solve problems related
+to 2D Trusses.
+"""
+
+from cmath import inf
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy import Matrix, pi
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import zeros
+from sympy import sin, cos
+
+
+
+class Truss:
+    """
+    A Truss is an assembly of members such as beams,
+    connected by nodes, that create a rigid structure.
+    In engineering, a truss is a structure that
+    consists of two-force members only.
+
+    Trusses are extremely important in engineering applications
+    and can be seen in numerous real-world applications like bridges.
+
+    Examples
+    ========
+
+    There is a Truss consisting of four nodes and five
+    members connecting the nodes. A force P acts
+    downward on the node D and there also exist pinned
+    and roller joints on the nodes A and B respectively.
+
+    .. image:: truss_example.png
+
+    >>> from sympy.physics.continuum_mechanics.truss import Truss
+    >>> t = Truss()
+    >>> t.add_node("node_1", 0, 0)
+    >>> t.add_node("node_2", 6, 0)
+    >>> t.add_node("node_3", 2, 2)
+    >>> t.add_node("node_4", 2, 0)
+    >>> t.add_member("member_1", "node_1", "node_4")
+    >>> t.add_member("member_2", "node_2", "node_4")
+    >>> t.add_member("member_3", "node_1", "node_3")
+    >>> t.add_member("member_4", "node_2", "node_3")
+    >>> t.add_member("member_5", "node_3", "node_4")
+    >>> t.apply_load("node_4", magnitude=10, direction=270)
+    >>> t.apply_support("node_1", type="fixed")
+    >>> t.apply_support("node_2", type="roller")
+    """
+
+    def __init__(self):
+        """
+        Initializes the class
+        """
+        self._nodes = []
+        self._members = {}
+        self._loads = {}
+        self._supports = {}
+        self._node_labels = []
+        self._node_positions = []
+        self._node_position_x = []
+        self._node_position_y = []
+        self._nodes_occupied = {}
+        self._reaction_loads = {}
+        self._internal_forces = {}
+        self._node_coordinates = {}
+
+    @property
+    def nodes(self):
+        """
+        Returns the nodes of the truss along with their positions.
+        """
+        return self._nodes
+
+    @property
+    def node_labels(self):
+        """
+        Returns the node labels of the truss.
+        """
+        return self._node_labels
+
+    @property
+    def node_positions(self):
+        """
+        Returns the positions of the nodes of the truss.
+        """
+        return self._node_positions
+
+    @property
+    def members(self):
+        """
+        Returns the members of the truss along with the start and end points.
+        """
+        return self._members
+
+    @property
+    def member_labels(self):
+        """
+        Returns the members of the truss along with the start and end points.
+        """
+        return self._member_labels
+
+    @property
+    def supports(self):
+        """
+        Returns the nodes with provided supports along with the kind of support provided i.e.
+        pinned or roller.
+        """
+        return self._supports
+
+    @property
+    def loads(self):
+        """
+        Returns the loads acting on the truss.
+        """
+        return self._loads
+
+    @property
+    def reaction_loads(self):
+        """
+        Returns the reaction forces for all supports which are all initialized to 0.
+        """
+        return self._reaction_loads
+
+    @property
+    def internal_forces(self):
+        """
+        Returns the internal forces for all members which are all initialized to 0.
+        """
+        return self._internal_forces
+
+    def add_node(self, label, x, y):
+        """
+        This method adds a node to the truss along with its name/label and its location.
+
+        Parameters
+        ==========
+        label:  String or a Symbol
+            The label for a node. It is the only way to identify a particular node.
+
+        x: Sympifyable
+            The x-coordinate of the position of the node.
+
+        y: Sympifyable
+            The y-coordinate of the position of the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.nodes
+        [('A', 0, 0)]
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        """
+        x = sympify(x)
+        y = sympify(y)
+
+        if label in self._node_labels:
+            raise ValueError("Node needs to have a unique label")
+
+        elif x in self._node_position_x and y in self._node_position_y and self._node_position_x.index(x)==self._node_position_y.index(y):
+            raise ValueError("A node already exists at the given position")
+
+        else :
+            self._nodes.append((label, x, y))
+            self._node_labels.append(label)
+            self._node_positions.append((x, y))
+            self._node_position_x.append(x)
+            self._node_position_y.append(y)
+            self._node_coordinates[label] = [x, y]
+
+    def remove_node(self, label):
+        """
+        This method removes a node from the truss.
+
+        Parameters
+        ==========
+        label:  String or Symbol
+            The label of the node to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.nodes
+        [('A', 0, 0)]
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.remove_node('A')
+        >>> t.nodes
+        [('B', 3, 0)]
+        """
+        for i in range(len(self.nodes)):
+            if self._node_labels[i] == label:
+                x = self._node_position_x[i]
+                y = self._node_position_y[i]
+
+        if label not in self._node_labels:
+            raise ValueError("No such node exists in the truss")
+
+        else:
+            members_duplicate = self._members.copy()
+            for member in members_duplicate:
+                if label == self._members[member][0] or label == self._members[member][1]:
+                    raise ValueError("The node given has members already attached to it")
+            self._nodes.remove((label, x, y))
+            self._node_labels.remove(label)
+            self._node_positions.remove((x, y))
+            self._node_position_x.remove(x)
+            self._node_position_y.remove(y)
+            if label in list(self._loads):
+                self._loads.pop(label)
+            if label in list(self._supports):
+                self._supports.pop(label)
+            self._node_coordinates.pop(label)
+
+    def add_member(self, label, start, end):
+        """
+        This method adds a member between any two nodes in the given truss.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label for a member. It is the only way to identify a particular member.
+
+        start: String or Symbol
+            The label of the starting point/node of the member.
+
+        end: String or Symbol
+            The label of the ending point/node of the member.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.add_node('C', 2, 2)
+        >>> t.add_member('AB', 'A', 'B')
+        >>> t.members
+        {'AB': ['A', 'B']}
+        """
+
+        if start not in self._node_labels or end not in self._node_labels or start==end:
+            raise ValueError("The start and end points of the member must be unique nodes")
+
+        elif label in list(self._members):
+            raise ValueError("A member with the same label already exists for the truss")
+
+        elif self._nodes_occupied.get((start, end)):
+            raise ValueError("A member already exists between the two nodes")
+
+        else:
+            self._members[label] = [start, end]
+            self._nodes_occupied[start, end] = True
+            self._nodes_occupied[end, start] = True
+            self._internal_forces[label] = 0
+
+    def remove_member(self, label):
+        """
+        This method removes a member from the given truss.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label for the member to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.add_node('C', 2, 2)
+        >>> t.add_member('AB', 'A', 'B')
+        >>> t.add_member('AC', 'A', 'C')
+        >>> t.add_member('BC', 'B', 'C')
+        >>> t.members
+        {'AB': ['A', 'B'], 'AC': ['A', 'C'], 'BC': ['B', 'C']}
+        >>> t.remove_member('AC')
+        >>> t.members
+        {'AB': ['A', 'B'], 'BC': ['B', 'C']}
+        """
+        if label not in list(self._members):
+            raise ValueError("No such member exists in the Truss")
+
+        else:
+            self._nodes_occupied.pop((self._members[label][0], self._members[label][1]))
+            self._nodes_occupied.pop((self._members[label][1], self._members[label][0]))
+            self._members.pop(label)
+            self._internal_forces.pop(label)
+
+    def change_node_label(self, label, new_label):
+        """
+        This method changes the label of a node.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label of the node for which the label has
+            to be changed.
+
+        new_label: String or Symbol
+            The new label of the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.change_node_label('A', 'C')
+        >>> t.nodes
+        [('C', 0, 0), ('B', 3, 0)]
+        """
+        if label not in self._node_labels:
+            raise ValueError("No such node exists for the Truss")
+        elif new_label in self._node_labels:
+            raise ValueError("A node with the given label already exists")
+        else:
+            for node in self._nodes:
+                if node[0] == label:
+                    self._nodes[self._nodes.index((label, node[1], node[2]))] = (new_label, node[1], node[2])
+                    self._node_labels[self._node_labels.index(node[0])] = new_label
+                    self._node_coordinates[new_label] = self._node_coordinates[label]
+                    self._node_coordinates.pop(label)
+                    if node[0] in list(self._supports):
+                        self._supports[new_label] = self._supports[node[0]]
+                        self._supports.pop(node[0])
+                    if new_label in list(self._supports):
+                        if self._supports[new_label] == 'pinned':
+                            if 'R_'+str(label)+'_x' in list(self._reaction_loads) and 'R_'+str(label)+'_y' in list(self._reaction_loads):
+                                self._reaction_loads['R_'+str(new_label)+'_x'] = self._reaction_loads['R_'+str(label)+'_x']
+                                self._reaction_loads['R_'+str(new_label)+'_y'] = self._reaction_loads['R_'+str(label)+'_y']
+                                self._reaction_loads.pop('R_'+str(label)+'_x')
+                                self._reaction_loads.pop('R_'+str(label)+'_y')
+                            self._loads[new_label] = self._loads[label]
+                            for load in self._loads[new_label]:
+                                if load[1] == 90:
+                                    load[0] -= Symbol('R_'+str(label)+'_y')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            for load in self._loads[new_label]:
+                                if load[1] == 0:
+                                    load[0] -= Symbol('R_'+str(label)+'_x')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_x'), 0)
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
+                            self._loads.pop(label)
+                        elif self._supports[new_label] == 'roller':
+                            self._loads[new_label] = self._loads[label]
+                            for load in self._loads[label]:
+                                if load[1] == 90:
+                                    load[0] -= Symbol('R_'+str(label)+'_y')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
+                            self._loads.pop(label)
+                    else:
+                        if label in list(self._loads):
+                            self._loads[new_label] = self._loads[label]
+                            self._loads.pop(label)
+                    for member in list(self._members):
+                        if self._members[member][0] == node[0]:
+                            self._members[member][0] = new_label
+                            self._nodes_occupied[(new_label, self._members[member][1])] = True
+                            self._nodes_occupied[(self._members[member][1], new_label)] = True
+                            self._nodes_occupied.pop((label, self._members[member][1]))
+                            self._nodes_occupied.pop((self._members[member][1], label))
+                        elif self._members[member][1] == node[0]:
+                            self._members[member][1] = new_label
+                            self._nodes_occupied[(self._members[member][0], new_label)] = True
+                            self._nodes_occupied[(new_label, self._members[member][0])] = True
+                            self._nodes_occupied.pop((self._members[member][0], label))
+                            self._nodes_occupied.pop((label, self._members[member][0]))
+
+    def change_member_label(self, label, new_label):
+        """
+        This method changes the label of a member.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label of the member for which the label has
+            to be changed.
+
+        new_label: String or Symbol
+            The new label of the member.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.change_node_label('A', 'C')
+        >>> t.nodes
+        [('C', 0, 0), ('B', 3, 0)]
+        >>> t.add_member('BC', 'B', 'C')
+        >>> t.members
+        {'BC': ['B', 'C']}
+        >>> t.change_member_label('BC', 'BC_new')
+        >>> t.members
+        {'BC_new': ['B', 'C']}
+        """
+        if label not in list(self._members):
+            raise ValueError("No such member exists for the Truss")
+
+        else:
+            members_duplicate = list(self._members).copy()
+            for member in members_duplicate:
+                if member == label:
+                    self._members[new_label] = [self._members[member][0], self._members[member][1]]
+                    self._members.pop(label)
+                    self._internal_forces[new_label] = self._internal_forces[label]
+                    self._internal_forces.pop(label)
+
+    def apply_load(self, location, magnitude, direction):
+        """
+        This method applies an external load at a particular node
+
+        Parameters
+        ==========
+        location: String or Symbol
+            Label of the Node at which load is applied.
+
+        magnitude: Sympifyable
+            Magnitude of the load applied. It must always be positive and any changes in
+            the direction of the load are not reflected here.
+
+        direction: Sympifyable
+            The angle, in degrees, that the load vector makes with the horizontal
+            in the counter-clockwise direction. It takes the values 0 to 360,
+            inclusive.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> from sympy import symbols
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> P = symbols('P')
+        >>> t.apply_load('A', P, 90)
+        >>> t.apply_load('A', P/2, 45)
+        >>> t.apply_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45], [P/4, 90]]}
+        """
+        magnitude = sympify(magnitude)
+        direction = sympify(direction)
+
+        if location not in self.node_labels:
+            raise ValueError("Load must be applied at a known node")
+
+        else:
+            if location in list(self._loads):
+                self._loads[location].append([magnitude, direction])
+            else:
+                self._loads[location] = [[magnitude, direction]]
+
+    def remove_load(self, location, magnitude, direction):
+        """
+        This method removes an already
+        present external load at a particular node
+
+        Parameters
+        ==========
+        location: String or Symbol
+            Label of the Node at which load is applied and is to be removed.
+
+        magnitude: Sympifyable
+            Magnitude of the load applied.
+
+        direction: Sympifyable
+            The angle, in degrees, that the load vector makes with the horizontal
+            in the counter-clockwise direction. It takes the values 0 to 360,
+            inclusive.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> from sympy import symbols
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> P = symbols('P')
+        >>> t.apply_load('A', P, 90)
+        >>> t.apply_load('A', P/2, 45)
+        >>> t.apply_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45], [P/4, 90]]}
+        >>> t.remove_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45]]}
+        """
+        magnitude = sympify(magnitude)
+        direction = sympify(direction)
+
+        if location not in self.node_labels:
+            raise ValueError("Load must be removed from a known node")
+
+        else:
+            if [magnitude, direction] not in self._loads[location]:
+                raise ValueError("No load of this magnitude and direction has been applied at this node")
+            else:
+                self._loads[location].remove([magnitude, direction])
+        if self._loads[location] == []:
+            self._loads.pop(location)
+
+    def apply_support(self, location, type):
+        """
+        This method adds a pinned or roller support at a particular node
+
+        Parameters
+        ==========
+
+        location: String or Symbol
+            Label of the Node at which support is added.
+
+        type: String
+            Type of the support being provided at the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.apply_support('A', 'pinned')
+        >>> t.supports
+        {'A': 'pinned'}
+        """
+        if location not in self._node_labels:
+            raise ValueError("Support must be added on a known node")
+
+        else:
+            if location not in list(self._supports):
+                if type == 'pinned':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_x'), 0)
+                    self.apply_load(location, Symbol('R_'+str(location)+'_y'), 90)
+                elif type == 'roller':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            elif self._supports[location] == 'pinned':
+                if type == 'roller':
+                    self.remove_load(location, Symbol('R_'+str(location)+'_x'), 0)
+            elif self._supports[location] == 'roller':
+                if type == 'pinned':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_x'), 0)
+            self._supports[location] = type
+
+    def remove_support(self, location):
+        """
+        This method removes support from a particular node
+
+        Parameters
+        ==========
+
+        location: String or Symbol
+            Label of the Node at which support is to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.apply_support('A', 'pinned')
+        >>> t.supports
+        {'A': 'pinned'}
+        >>> t.remove_support('A')
+        >>> t.supports
+        {}
+        """
+        if location not in self._node_labels:
+            raise ValueError("No such node exists in the Truss")
+
+        elif location not in list(self._supports):
+            raise ValueError("No support has been added to the given node")
+
+        else:
+            if self._supports[location] == 'pinned':
+                self.remove_load(location, Symbol('R_'+str(location)+'_x'), 0)
+                self.remove_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            elif self._supports[location] == 'roller':
+                self.remove_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            self._supports.pop(location)
+
+    def solve(self):
+        """
+        This method solves for all reaction forces of all supports and all internal forces
+        of all the members in the truss, provided the Truss is solvable.
+
+        A Truss is solvable if the following condition is met,
+
+        2n >= r + m
+
+        Where n is the number of nodes, r is the number of reaction forces, where each pinned
+        support has 2 reaction forces and each roller has 1, and m is the number of members.
+
+        The given condition is derived from the fact that a system of equations is solvable
+        only when the number of variables is lesser than or equal to the number of equations.
+        Equilibrium Equations in x and y directions give two equations per node giving 2n number
+        equations. However, the truss needs to be stable as well and may be unstable if 2n > r + m.
+        The number of variables is simply the sum of the number of reaction forces and member
+        forces.
+
+        .. note::
+           The sign convention for the internal forces present in a member revolves around whether each
+           force is compressive or tensile. While forming equations for each node, internal force due
+           to a member on the node is assumed to be away from the node i.e. each force is assumed to
+           be compressive by default. Hence, a positive value for an internal force implies the
+           presence of compressive force in the member and a negative value implies a tensile force.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node("node_1", 0, 0)
+        >>> t.add_node("node_2", 6, 0)
+        >>> t.add_node("node_3", 2, 2)
+        >>> t.add_node("node_4", 2, 0)
+        >>> t.add_member("member_1", "node_1", "node_4")
+        >>> t.add_member("member_2", "node_2", "node_4")
+        >>> t.add_member("member_3", "node_1", "node_3")
+        >>> t.add_member("member_4", "node_2", "node_3")
+        >>> t.add_member("member_5", "node_3", "node_4")
+        >>> t.apply_load("node_4", magnitude=10, direction=270)
+        >>> t.apply_support("node_1", type="pinned")
+        >>> t.apply_support("node_2", type="roller")
+        >>> t.solve()
+        >>> t.reaction_loads
+        {'R_node_1_x': 0, 'R_node_1_y': 20/3, 'R_node_2_y': 10/3}
+        >>> t.internal_forces
+        {'member_1': 20/3, 'member_2': 20/3, 'member_3': -20*sqrt(2)/3, 'member_4': -10*sqrt(5)/3, 'member_5': 10}
+        """
+        count_reaction_loads = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    count_reaction_loads += 2
+                elif self._supports[node[0]]=='roller':
+                    count_reaction_loads += 1
+        if 2*len(self._nodes) != len(self._members) + count_reaction_loads:
+            raise ValueError("The given truss cannot be solved")
+        coefficients_matrix = [[0 for i in range(2*len(self._nodes))] for j in range(2*len(self._nodes))]
+        load_matrix = zeros(2*len(self.nodes), 1)
+        load_matrix_row = 0
+        for node in self._nodes:
+            if node[0] in list(self._loads):
+                for load in self._loads[node[0]]:
+                    if load[0]!=Symbol('R_'+str(node[0])+'_x') and load[0]!=Symbol('R_'+str(node[0])+'_y'):
+                        load_matrix[load_matrix_row] -= load[0]*cos(pi*load[1]/180)
+                        load_matrix[load_matrix_row + 1] -= load[0]*sin(pi*load[1]/180)
+            load_matrix_row += 2
+        cols = 0
+        row = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    coefficients_matrix[row][cols] += 1
+                    coefficients_matrix[row+1][cols+1] += 1
+                    cols += 2
+                elif self._supports[node[0]]=='roller':
+                    coefficients_matrix[row+1][cols] += 1
+                    cols += 1
+            row += 2
+        for member in list(self._members):
+            start = self._members[member][0]
+            end = self._members[member][1]
+            length = sqrt((self._node_coordinates[start][0]-self._node_coordinates[end][0])**2 + (self._node_coordinates[start][1]-self._node_coordinates[end][1])**2)
+            start_index = self._node_labels.index(start)
+            end_index = self._node_labels.index(end)
+            horizontal_component_start = (self._node_coordinates[end][0]-self._node_coordinates[start][0])/length
+            vertical_component_start = (self._node_coordinates[end][1]-self._node_coordinates[start][1])/length
+            horizontal_component_end = (self._node_coordinates[start][0]-self._node_coordinates[end][0])/length
+            vertical_component_end = (self._node_coordinates[start][1]-self._node_coordinates[end][1])/length
+            coefficients_matrix[start_index*2][cols] += horizontal_component_start
+            coefficients_matrix[start_index*2+1][cols] += vertical_component_start
+            coefficients_matrix[end_index*2][cols] += horizontal_component_end
+            coefficients_matrix[end_index*2+1][cols] += vertical_component_end
+            cols += 1
+        forces_matrix = (Matrix(coefficients_matrix)**-1)*load_matrix
+        self._reaction_loads = {}
+        i = 0
+        min_load = inf
+        for node in self._nodes:
+            if node[0] in list(self._loads):
+                for load in self._loads[node[0]]:
+                    if type(load[0]) not in [Symbol, Mul, Add]:
+                        min_load = min(min_load, load[0])
+        for j in range(len(forces_matrix)):
+            if type(forces_matrix[j]) not in [Symbol, Mul, Add]:
+                if abs(forces_matrix[j]/min_load) <1E-10:
+                    forces_matrix[j] = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    self._reaction_loads['R_'+str(node[0])+'_x'] = forces_matrix[i]
+                    self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i+1]
+                    i += 2
+                elif self._supports[node[0]]=='roller':
+                    self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i]
+                    i += 1
+        for member in list(self._members):
+            self._internal_forces[member] = forces_matrix[i]
+            i += 1
+        return

env-llmeval/lib/python3.10/site-packages/sympy/physics/control/tests/test_control_plots.py

@@ -0,0 +1,300 @@
+from math import isclose
+from sympy.core.numbers import I
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.complexes import (Abs, arg)
+from sympy.functions.elementary.exponential import log
+from sympy.abc import s, p, a
+from sympy.external import import_module
+from sympy.physics.control.control_plots import \
+    (pole_zero_numerical_data, pole_zero_plot, step_response_numerical_data,
+    step_response_plot, impulse_response_numerical_data,
+    impulse_response_plot, ramp_response_numerical_data,
+    ramp_response_plot, bode_magnitude_numerical_data,
+    bode_phase_numerical_data, bode_plot)
+from sympy.physics.control.lti import (TransferFunction,
+    Series, Parallel, TransferFunctionMatrix)
+from sympy.testing.pytest import raises, skip
+
+matplotlib = import_module(
+        'matplotlib', import_kwargs={'fromlist': ['pyplot']},
+        catch=(RuntimeError,))
+
+numpy = import_module('numpy')
+
+tf1 = TransferFunction(1, p**2 + 0.5*p + 2, p)
+tf2 = TransferFunction(p, 6*p**2 + 3*p + 1, p)
+tf3 = TransferFunction(p, p**3 - 1, p)
+tf4 = TransferFunction(10, p**3, p)
+tf5 = TransferFunction(5, s**2 + 2*s + 10, s)
+tf6 = TransferFunction(1, 1, s)
+tf7 = TransferFunction(4*s*3 + 9*s**2 + 0.1*s + 11, 8*s**6 + 9*s**4 + 11, s)
+tf8 = TransferFunction(5, s**2 + (2+I)*s + 10, s)
+
+ser1 = Series(tf4, TransferFunction(1, p - 5, p))
+ser2 = Series(tf3, TransferFunction(p, p + 2, p))
+
+par1 = Parallel(tf1, tf2)
+par2 = Parallel(tf1, tf2, tf3)
+
+
+def _to_tuple(a, b):
+    return tuple(a), tuple(b)
+
+def _trim_tuple(a, b):
+    a, b = _to_tuple(a, b)
+    return tuple(a[0: 2] + a[len(a)//2 : len(a)//2 + 1] + a[-2:]), \
+        tuple(b[0: 2] + b[len(b)//2 : len(b)//2 + 1] + b[-2:])
+
+def y_coordinate_equality(plot_data_func, evalf_func, system):
+    """Checks whether the y-coordinate value of the plotted
+    data point is equal to the value of the function at a
+    particular x."""
+    x, y = plot_data_func(system)
+    x, y = _trim_tuple(x, y)
+    y_exp = tuple(evalf_func(system, x_i) for x_i in x)
+    return all(Abs(y_exp_i - y_i) < 1e-8 for y_exp_i, y_i in zip(y_exp, y))
+
+
+def test_errors():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    # Invalid `system` check
+    tfm = TransferFunctionMatrix([[tf6, tf5], [tf5, tf6]])
+    expr = 1/(s**2 - 1)
+    raises(NotImplementedError, lambda: pole_zero_plot(tfm))
+    raises(NotImplementedError, lambda: pole_zero_numerical_data(expr))
+    raises(NotImplementedError, lambda: impulse_response_plot(expr))
+    raises(NotImplementedError, lambda: impulse_response_numerical_data(tfm))
+    raises(NotImplementedError, lambda: step_response_plot(tfm))
+    raises(NotImplementedError, lambda: step_response_numerical_data(expr))
+    raises(NotImplementedError, lambda: ramp_response_plot(expr))
+    raises(NotImplementedError, lambda: ramp_response_numerical_data(tfm))
+    raises(NotImplementedError, lambda: bode_plot(tfm))
+
+    # More than 1 variables
+    tf_a = TransferFunction(a, s + 1, s)
+    raises(ValueError, lambda: pole_zero_plot(tf_a))
+    raises(ValueError, lambda: pole_zero_numerical_data(tf_a))
+    raises(ValueError, lambda: impulse_response_plot(tf_a))
+    raises(ValueError, lambda: impulse_response_numerical_data(tf_a))
+    raises(ValueError, lambda: step_response_plot(tf_a))
+    raises(ValueError, lambda: step_response_numerical_data(tf_a))
+    raises(ValueError, lambda: ramp_response_plot(tf_a))
+    raises(ValueError, lambda: ramp_response_numerical_data(tf_a))
+    raises(ValueError, lambda: bode_plot(tf_a))
+
+    # lower_limit > 0 for response plots
+    raises(ValueError, lambda: impulse_response_plot(tf1, lower_limit=-1))
+    raises(ValueError, lambda: step_response_plot(tf1, lower_limit=-0.1))
+    raises(ValueError, lambda: ramp_response_plot(tf1, lower_limit=-4/3))
+
+    # slope in ramp_response_plot() is negative
+    raises(ValueError, lambda: ramp_response_plot(tf1, slope=-0.1))
+
+    # incorrect frequency or phase unit
+    raises(ValueError, lambda: bode_plot(tf1,freq_unit = 'hz'))
+    raises(ValueError, lambda: bode_plot(tf1,phase_unit = 'degree'))
+
+
+def test_pole_zero():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def pz_tester(sys, expected_value):
+        z, p = pole_zero_numerical_data(sys)
+        z_check = numpy.allclose(z, expected_value[0])
+        p_check = numpy.allclose(p, expected_value[1])
+        return p_check and z_check
+
+    exp1 = [[], [-0.24999999999999994+1.3919410907075054j, -0.24999999999999994-1.3919410907075054j]]
+    exp2 = [[0.0], [-0.25+0.3227486121839514j, -0.25-0.3227486121839514j]]
+    exp3 = [[0.0], [-0.5000000000000004+0.8660254037844395j,
+        -0.5000000000000004-0.8660254037844395j, 0.9999999999999998+0j]]
+    exp4 = [[], [5.0, 0.0, 0.0, 0.0]]
+    exp5 = [[-5.645751311064592, -0.5000000000000008, -0.3542486889354093],
+        [-0.24999999999999986+1.3919410907075052j,
+        -0.24999999999999986-1.3919410907075052j, -0.2499999999999998+0.32274861218395134j,
+        -0.2499999999999998-0.32274861218395134j]]
+    exp6 = [[], [-1.1641600331447917-3.545808351896439j,
+          -0.8358399668552097+2.5458083518964383j]]
+
+    assert pz_tester(tf1, exp1)
+    assert pz_tester(tf2, exp2)
+    assert pz_tester(tf3, exp3)
+    assert pz_tester(ser1, exp4)
+    assert pz_tester(par1, exp5)
+    assert pz_tester(tf8, exp6)
+
+
+def test_bode():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def bode_phase_evalf(system, point):
+        expr = system.to_expr()
+        _w = Dummy("w", real=True)
+        w_expr = expr.subs({system.var: I*_w})
+        return arg(w_expr).subs({_w: point}).evalf()
+
+    def bode_mag_evalf(system, point):
+        expr = system.to_expr()
+        _w = Dummy("w", real=True)
+        w_expr = expr.subs({system.var: I*_w})
+        return 20*log(Abs(w_expr), 10).subs({_w: point}).evalf()
+
+    def test_bode_data(sys):
+        return y_coordinate_equality(bode_magnitude_numerical_data, bode_mag_evalf, sys) \
+            and y_coordinate_equality(bode_phase_numerical_data, bode_phase_evalf, sys)
+
+    assert test_bode_data(tf1)
+    assert test_bode_data(tf2)
+    assert test_bode_data(tf3)
+    assert test_bode_data(tf4)
+    assert test_bode_data(tf5)
+
+
+def check_point_accuracy(a, b):
+    return all(isclose(a_i, b_i, rel_tol=10e-12) for \
+        a_i, b_i in zip(a, b))
+
+
+def test_impulse_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def impulse_res_tester(sys, expected_value):
+        x, y = _to_tuple(*impulse_response_numerical_data(sys,
+            adaptive=False, nb_of_points=10))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.544019738507865, 0.01993849743234938, -0.31140243360893216, -0.022852779906491996, 0.1778306498155759,
+        0.01962941084328499, -0.1013115194573652, -0.014975541213105696, 0.0575789724730714))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.1666666675, 0.08389223412935855,
+        0.02338051973475047, -0.014966807776379383, -0.034645954223054234, -0.040560075735512804,
+        -0.037658628907103885, -0.030149507719590022, -0.021162090730736834, -0.012721292737437523))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (4.369893391586999e-09, 1.1750333000630964,
+        3.2922404058312473, 9.432290008148343, 28.37098083007151, 86.18577464367974, 261.90356653762115,
+        795.6538758627842, 2416.9920942096983, 7342.159505206647))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 6.17283950617284, 24.69135802469136,
+        55.555555555555564, 98.76543209876544, 154.320987654321, 222.22222222222226, 302.46913580246917,
+        395.0617283950618, 500.0))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, -0.10455606138085417,
+        0.06757671513476461, -0.03234567568833768, 0.013582514927757873, -0.005273419510705473,
+        0.0019364083003354075, -0.000680070134067832, 0.00022969845960406913, -7.476094359583917e-05))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-6.016699583000218e-09, 0.35039802056107394, 3.3728423827689884, 12.119846079276684,
+        25.86101014293389, 29.352480635282088, -30.49475907497664, -273.8717189554019, -863.2381702029659,
+        -1747.0262164682233))
+    exp7 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335,
+        4.444444444444445, 5.555555555555555, 6.666666666666667, 7.777777777777779,
+        8.88888888888889, 10.0), (0.0, 18.934638095560974, 5346.93244680907, 1384609.8718249386,
+        358161126.65801865, 92645770015.70108, 23964739753087.42, 6198974342083139.0, 1.603492601616059e+18,
+        4.147764422869658e+20))
+
+    assert impulse_res_tester(tf1, exp1)
+    assert impulse_res_tester(tf2, exp2)
+    assert impulse_res_tester(tf3, exp3)
+    assert impulse_res_tester(tf4, exp4)
+    assert impulse_res_tester(tf5, exp5)
+    assert impulse_res_tester(tf7, exp6)
+    assert impulse_res_tester(ser1, exp7)
+
+
+def test_step_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def step_res_tester(sys, expected_value):
+        x, y = _to_tuple(*step_response_numerical_data(sys,
+            adaptive=False, nb_of_points=10))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-1.9193285738516863e-08, 0.42283495488246126, 0.7840485977945262, 0.5546841805655717,
+        0.33903033806932087, 0.4627251747410237, 0.5909907598988051, 0.5247213989553071,
+        0.4486997874319281, 0.4839358435839171))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.13728409095645816, 0.19474559355325086, 0.1974909129243011, 0.16841657696573073,
+        0.12559777736159378, 0.08153828016664713, 0.04360471317348958, 0.015072994568868221,
+        -0.003636420058445484))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.6314542141914303, 2.9356520038101035, 9.37731009663807, 28.452300356688376,
+        86.25721933273988, 261.9236645044672, 795.6435410577224, 2416.9786984578764, 7342.154119725917))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 2.286236899862826, 18.28989519890261, 61.72839629629631, 146.31916159122088, 285.7796124828532,
+        493.8271703703705, 784.1792566529494, 1170.553292729767, 1666.6667))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-3.999999997894577e-09, 0.6720357068882895, 0.4429938256137113, 0.5182010838004518,
+        0.4944139147159695, 0.5016379853883338, 0.4995466896527733, 0.5001154784851325,
+        0.49997448824584123, 0.5000039745919259))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-1.5433688493882158e-09, 0.3428705539937336, 1.1253619102202777, 3.1849962651016517,
+        9.47532757182671, 28.727231099148135, 87.29426924860557, 265.2138681048606, 805.6636260007757,
+        2447.387582370878))
+
+    assert step_res_tester(tf1, exp1)
+    assert step_res_tester(tf2, exp2)
+    assert step_res_tester(tf3, exp3)
+    assert step_res_tester(tf4, exp4)
+    assert step_res_tester(tf5, exp5)
+    assert step_res_tester(ser2, exp6)
+
+
+def test_ramp_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def ramp_res_tester(sys, num_points, expected_value, slope=1):
+        x, y = _to_tuple(*ramp_response_numerical_data(sys,
+            slope=slope, adaptive=False, nb_of_points=num_points))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 2.0, 4.0, 6.0, 8.0, 10.0), (0.0, 0.7324667795033895, 1.9909720978650398,
+        2.7956587704217783, 3.9224897567931514, 4.85022655284895))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (2.4360213402019326e-08, 0.10175320182493253, 0.33057612497658406, 0.5967937263298935,
+        0.8431511866718248, 1.0398805391471613, 1.1776043125035738, 1.2600994825747305, 1.2981042689274653,
+        1.304684417610106))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (-3.9329040468771836e-08,
+        0.34686634635794555, 2.9998828170537903, 12.33303690737476, 40.993913948137795, 127.84145222317912,
+        391.41713691996, 1192.0006858708389, 3623.9808672503405, 11011.728034546572))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 1.9051973784484078, 30.483158055174524,
+        154.32098765432104, 487.7305288827924, 1190.7483615302544, 2469.1358024691367, 4574.3789056546275,
+        7803.688462124678, 12500.0))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 3.8844361856975635, 9.141792069209865,
+        14.096349157657231, 19.09783068994694, 24.10179770390321, 29.09907319114121, 34.10040420185154,
+        39.09983919254265, 44.10006013058409))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 1.1111111111111112, 2.2222222222222223,
+        3.3333333333333335, 4.444444444444445, 5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0))
+
+    assert ramp_res_tester(tf1, 6, exp1)
+    assert ramp_res_tester(tf2, 10, exp2, 1.2)
+    assert ramp_res_tester(tf3, 10, exp3, 1.5)
+    assert ramp_res_tester(tf4, 10, exp4, 3)
+    assert ramp_res_tester(tf5, 10, exp5, 9)
+    assert ramp_res_tester(tf6, 10, exp6)

env-llmeval/lib/python3.10/site-packages/sympy/physics/control/tests/test_lti.py

@@ -0,0 +1,1245 @@
+from sympy.core.add import Add
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import eye
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import CRootOf
+from sympy.simplify.simplify import simplify
+from sympy.core.containers import Tuple
+from sympy.matrices import ImmutableMatrix, Matrix
+from sympy.physics.control import (TransferFunction, Series, Parallel,
+    Feedback, TransferFunctionMatrix, MIMOSeries, MIMOParallel, MIMOFeedback,
+    bilinear, backward_diff)
+from sympy.testing.pytest import raises
+
+a, x, b, s, g, d, p, k, a0, a1, a2, b0, b1, b2, tau, zeta, wn, T = symbols('a, x, b, s, g, d, p, k,\
+    a0:3, b0:3, tau, zeta, wn, T')
+TF1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+TF2 = TransferFunction(k, 1, s)
+TF3 = TransferFunction(a2*p - s, a2*s + p, s)
+
+
+def test_TransferFunction_construction():
+    tf = TransferFunction(s + 1, s**2 + s + 1, s)
+    assert tf.num == (s + 1)
+    assert tf.den == (s**2 + s + 1)
+    assert tf.args == (s + 1, s**2 + s + 1, s)
+
+    tf1 = TransferFunction(s + 4, s - 5, s)
+    assert tf1.num == (s + 4)
+    assert tf1.den == (s - 5)
+    assert tf1.args == (s + 4, s - 5, s)
+
+    # using different polynomial variables.
+    tf2 = TransferFunction(p + 3, p**2 - 9, p)
+    assert tf2.num == (p + 3)
+    assert tf2.den == (p**2 - 9)
+    assert tf2.args == (p + 3, p**2 - 9, p)
+
+    tf3 = TransferFunction(p**3 + 5*p**2 + 4, p**4 + 3*p + 1, p)
+    assert tf3.args == (p**3 + 5*p**2 + 4, p**4 + 3*p + 1, p)
+
+    # no pole-zero cancellation on its own.
+    tf4 = TransferFunction((s + 3)*(s - 1), (s - 1)*(s + 5), s)
+    assert tf4.den == (s - 1)*(s + 5)
+    assert tf4.args == ((s + 3)*(s - 1), (s - 1)*(s + 5), s)
+
+    tf4_ = TransferFunction(p + 2, p + 2, p)
+    assert tf4_.args == (p + 2, p + 2, p)
+
+    tf5 = TransferFunction(s - 1, 4 - p, s)
+    assert tf5.args == (s - 1, 4 - p, s)
+
+    tf5_ = TransferFunction(s - 1, s - 1, s)
+    assert tf5_.args == (s - 1, s - 1, s)
+
+    tf6 = TransferFunction(5, 6, s)
+    assert tf6.num == 5
+    assert tf6.den == 6
+    assert tf6.args == (5, 6, s)
+
+    tf6_ = TransferFunction(1/2, 4, s)
+    assert tf6_.num == 0.5
+    assert tf6_.den == 4
+    assert tf6_.args == (0.500000000000000, 4, s)
+
+    tf7 = TransferFunction(3*s**2 + 2*p + 4*s, 8*p**2 + 7*s, s)
+    tf8 = TransferFunction(3*s**2 + 2*p + 4*s, 8*p**2 + 7*s, p)
+    assert not tf7 == tf8
+
+    tf7_ = TransferFunction(a0*s + a1*s**2 + a2*s**3, b0*p - b1*s, s)
+    tf8_ = TransferFunction(a0*s + a1*s**2 + a2*s**3, b0*p - b1*s, s)
+    assert tf7_ == tf8_
+    assert -(-tf7_) == tf7_ == -(-(-(-tf7_)))
+
+    tf9 = TransferFunction(a*s**3 + b*s**2 + g*s + d, d*p + g*p**2 + g*s, s)
+    assert tf9.args == (a*s**3 + b*s**2 + d + g*s, d*p + g*p**2 + g*s, s)
+
+    tf10 = TransferFunction(p**3 + d, g*s**2 + d*s + a, p)
+    tf10_ = TransferFunction(p**3 + d, g*s**2 + d*s + a, p)
+    assert tf10.args == (d + p**3, a + d*s + g*s**2, p)
+    assert tf10_ == tf10
+
+    tf11 = TransferFunction(a1*s + a0, b2*s**2 + b1*s + b0, s)
+    assert tf11.num == (a0 + a1*s)
+    assert tf11.den == (b0 + b1*s + b2*s**2)
+    assert tf11.args == (a0 + a1*s, b0 + b1*s + b2*s**2, s)
+
+    # when just the numerator is 0, leave the denominator alone.
+    tf12 = TransferFunction(0, p**2 - p + 1, p)
+    assert tf12.args == (0, p**2 - p + 1, p)
+
+    tf13 = TransferFunction(0, 1, s)
+    assert tf13.args == (0, 1, s)
+
+    # float exponents
+    tf14 = TransferFunction(a0*s**0.5 + a2*s**0.6 - a1, a1*p**(-8.7), s)
+    assert tf14.args == (a0*s**0.5 - a1 + a2*s**0.6, a1*p**(-8.7), s)
+
+    tf15 = TransferFunction(a2**2*p**(1/4) + a1*s**(-4/5), a0*s - p, p)
+    assert tf15.args == (a1*s**(-0.8) + a2**2*p**0.25, a0*s - p, p)
+
+    omega_o, k_p, k_o, k_i = symbols('omega_o, k_p, k_o, k_i')
+    tf18 = TransferFunction((k_p + k_o*s + k_i/s), s**2 + 2*omega_o*s + omega_o**2, s)
+    assert tf18.num == k_i/s + k_o*s + k_p
+    assert tf18.args == (k_i/s + k_o*s + k_p, omega_o**2 + 2*omega_o*s + s**2, s)
+
+    # ValueError when denominator is zero.
+    raises(ValueError, lambda: TransferFunction(4, 0, s))
+    raises(ValueError, lambda: TransferFunction(s, 0, s))
+    raises(ValueError, lambda: TransferFunction(0, 0, s))
+
+    raises(TypeError, lambda: TransferFunction(Matrix([1, 2, 3]), s, s))
+
+    raises(TypeError, lambda: TransferFunction(s**2 + 2*s - 1, s + 3, 3))
+    raises(TypeError, lambda: TransferFunction(p + 1, 5 - p, 4))
+    raises(TypeError, lambda: TransferFunction(3, 4, 8))
+
+
+def test_TransferFunction_functions():
+    # classmethod from_rational_expression
+    expr_1 = Mul(0, Pow(s, -1, evaluate=False), evaluate=False)
+    expr_2 = s/0
+    expr_3 = (p*s**2 + 5*s)/(s + 1)**3
+    expr_4 = 6
+    expr_5 = ((2 + 3*s)*(5 + 2*s))/((9 + 3*s)*(5 + 2*s**2))
+    expr_6 = (9*s**4 + 4*s**2 + 8)/((s + 1)*(s + 9))
+    tf = TransferFunction(s + 1, s**2 + 2, s)
+    delay = exp(-s/tau)
+    expr_7 = delay*tf.to_expr()
+    H1 = TransferFunction.from_rational_expression(expr_7, s)
+    H2 = TransferFunction(s + 1, (s**2 + 2)*exp(s/tau), s)
+    expr_8 = Add(2,  3*s/(s**2 + 1), evaluate=False)
+
+    assert TransferFunction.from_rational_expression(expr_1) == TransferFunction(0, s, s)
+    raises(ZeroDivisionError, lambda: TransferFunction.from_rational_expression(expr_2))
+    raises(ValueError, lambda: TransferFunction.from_rational_expression(expr_3))
+    assert TransferFunction.from_rational_expression(expr_3, s) == TransferFunction((p*s**2 + 5*s), (s + 1)**3, s)
+    assert TransferFunction.from_rational_expression(expr_3, p) == TransferFunction((p*s**2 + 5*s), (s + 1)**3, p)
+    raises(ValueError, lambda: TransferFunction.from_rational_expression(expr_4))
+    assert TransferFunction.from_rational_expression(expr_4, s) == TransferFunction(6, 1, s)
+    assert TransferFunction.from_rational_expression(expr_5, s) == \
+        TransferFunction((2 + 3*s)*(5 + 2*s), (9 + 3*s)*(5 + 2*s**2), s)
+    assert TransferFunction.from_rational_expression(expr_6, s) == \
+        TransferFunction((9*s**4 + 4*s**2 + 8), (s + 1)*(s + 9), s)
+    assert H1 == H2
+    assert TransferFunction.from_rational_expression(expr_8, s) == \
+        TransferFunction(2*s**2 + 3*s + 2, s**2 + 1, s)
+
+    # explicitly cancel poles and zeros.
+    tf0 = TransferFunction(s**5 + s**3 + s, s - s**2, s)
+    a = TransferFunction(-(s**4 + s**2 + 1), s - 1, s)
+    assert tf0.simplify() == simplify(tf0) == a
+
+    tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
+    b = TransferFunction(p + 3, p + 5, p)
+    assert tf1.simplify() == simplify(tf1) == b
+
+    # expand the numerator and the denominator.
+    G1 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
+    G2 = TransferFunction(1, -3, p)
+    c = (a2*s**p + a1*s**s + a0*p**p)*(p**s + s**p)
+    d = (b0*s**s + b1*p**s)*(b2*s*p + p**p)
+    e = a0*p**p*p**s + a0*p**p*s**p + a1*p**s*s**s + a1*s**p*s**s + a2*p**s*s**p + a2*s**(2*p)
+    f = b0*b2*p*s*s**s + b0*p**p*s**s + b1*b2*p*p**s*s + b1*p**p*p**s
+    g = a1*a2*s*s**p + a1*p*s + a2*b1*p*s*s**p + b1*p**2*s
+    G3 = TransferFunction(c, d, s)
+    G4 = TransferFunction(a0*s**s - b0*p**p, (a1*s + b1*s*p)*(a2*s**p + p), p)
+
+    assert G1.expand() == TransferFunction(s**2 - 2*s + 1, s**4 + 2*s**2 + 1, s)
+    assert tf1.expand() == TransferFunction(p**2 + 2*p - 3, p**2 + 4*p - 5, p)
+    assert G2.expand() == G2
+    assert G3.expand() == TransferFunction(e, f, s)
+    assert G4.expand() == TransferFunction(a0*s**s - b0*p**p, g, p)
+
+    # purely symbolic polynomials.
+    p1 = a1*s + a0
+    p2 = b2*s**2 + b1*s + b0
+    SP1 = TransferFunction(p1, p2, s)
+    expect1 = TransferFunction(2.0*s + 1.0, 5.0*s**2 + 4.0*s + 3.0, s)
+    expect1_ = TransferFunction(2*s + 1, 5*s**2 + 4*s + 3, s)
+    assert SP1.subs({a0: 1, a1: 2, b0: 3, b1: 4, b2: 5}) == expect1_
+    assert SP1.subs({a0: 1, a1: 2, b0: 3, b1: 4, b2: 5}).evalf() == expect1
+    assert expect1_.evalf() == expect1
+
+    c1, d0, d1, d2 = symbols('c1, d0:3')
+    p3, p4 = c1*p, d2*p**3 + d1*p**2 - d0
+    SP2 = TransferFunction(p3, p4, p)
+    expect2 = TransferFunction(2.0*p, 5.0*p**3 + 2.0*p**2 - 3.0, p)
+    expect2_ = TransferFunction(2*p, 5*p**3 + 2*p**2 - 3, p)
+    assert SP2.subs({c1: 2, d0: 3, d1: 2, d2: 5}) == expect2_
+    assert SP2.subs({c1: 2, d0: 3, d1: 2, d2: 5}).evalf() == expect2
+    assert expect2_.evalf() == expect2
+
+    SP3 = TransferFunction(a0*p**3 + a1*s**2 - b0*s + b1, a1*s + p, s)
+    expect3 = TransferFunction(2.0*p**3 + 4.0*s**2 - s + 5.0, p + 4.0*s, s)
+    expect3_ = TransferFunction(2*p**3 + 4*s**2 - s + 5, p + 4*s, s)
+    assert SP3.subs({a0: 2, a1: 4, b0: 1, b1: 5}) == expect3_
+    assert SP3.subs({a0: 2, a1: 4, b0: 1, b1: 5}).evalf() == expect3
+    assert expect3_.evalf() == expect3
+
+    SP4 = TransferFunction(s - a1*p**3, a0*s + p, p)
+    expect4 = TransferFunction(7.0*p**3 + s, p - s, p)
+    expect4_ = TransferFunction(7*p**3 + s, p - s, p)
+    assert SP4.subs({a0: -1, a1: -7}) == expect4_
+    assert SP4.subs({a0: -1, a1: -7}).evalf() == expect4
+    assert expect4_.evalf() == expect4
+
+    # Low-frequency (or DC) gain.
+    assert tf0.dc_gain() == 1
+    assert tf1.dc_gain() == Rational(3, 5)
+    assert SP2.dc_gain() == 0
+    assert expect4.dc_gain() == -1
+    assert expect2_.dc_gain() == 0
+    assert TransferFunction(1, s, s).dc_gain() == oo
+
+    # Poles of a transfer function.
+    tf_ = TransferFunction(x**3 - k, k, x)
+    _tf = TransferFunction(k, x**4 - k, x)
+    TF_ = TransferFunction(x**2, x**10 + x + x**2, x)
+    _TF = TransferFunction(x**10 + x + x**2, x**2, x)
+    assert G1.poles() == [I, I, -I, -I]
+    assert G2.poles() == []
+    assert tf1.poles() == [-5, 1]
+    assert expect4_.poles() == [s]
+    assert SP4.poles() == [-a0*s]
+    assert expect3.poles() == [-0.25*p]
+    assert str(expect2.poles()) == str([0.729001428685125, -0.564500714342563 - 0.710198984796332*I, -0.564500714342563 + 0.710198984796332*I])
+    assert str(expect1.poles()) == str([-0.4 - 0.66332495807108*I, -0.4 + 0.66332495807108*I])
+    assert _tf.poles() == [k**(Rational(1, 4)), -k**(Rational(1, 4)), I*k**(Rational(1, 4)), -I*k**(Rational(1, 4))]
+    assert TF_.poles() == [CRootOf(x**9 + x + 1, 0), 0, CRootOf(x**9 + x + 1, 1), CRootOf(x**9 + x + 1, 2),
+        CRootOf(x**9 + x + 1, 3), CRootOf(x**9 + x + 1, 4), CRootOf(x**9 + x + 1, 5), CRootOf(x**9 + x + 1, 6),
+        CRootOf(x**9 + x + 1, 7), CRootOf(x**9 + x + 1, 8)]
+    raises(NotImplementedError, lambda: TransferFunction(x**2, a0*x**10 + x + x**2, x).poles())
+
+    # Stability of a transfer function.
+    q, r = symbols('q, r', negative=True)
+    t = symbols('t', positive=True)
+    TF_ = TransferFunction(s**2 + a0 - a1*p, q*s - r, s)
+    stable_tf = TransferFunction(s**2 + a0 - a1*p, q*s - 1, s)
+    stable_tf_ = TransferFunction(s**2 + a0 - a1*p, q*s - t, s)
+
+    assert G1.is_stable() is False
+    assert G2.is_stable() is True
+    assert tf1.is_stable() is False   # as one pole is +ve, and the other is -ve.
+    assert expect2.is_stable() is False
+    assert expect1.is_stable() is True
+    assert stable_tf.is_stable() is True
+    assert stable_tf_.is_stable() is True
+    assert TF_.is_stable() is False
+    assert expect4_.is_stable() is None   # no assumption provided for the only pole 's'.
+    assert SP4.is_stable() is None
+
+    # Zeros of a transfer function.
+    assert G1.zeros() == [1, 1]
+    assert G2.zeros() == []
+    assert tf1.zeros() == [-3, 1]
+    assert expect4_.zeros() == [7**(Rational(2, 3))*(-s)**(Rational(1, 3))/7, -7**(Rational(2, 3))*(-s)**(Rational(1, 3))/14 -
+        sqrt(3)*7**(Rational(2, 3))*I*(-s)**(Rational(1, 3))/14, -7**(Rational(2, 3))*(-s)**(Rational(1, 3))/14 + sqrt(3)*7**(Rational(2, 3))*I*(-s)**(Rational(1, 3))/14]
+    assert SP4.zeros() == [(s/a1)**(Rational(1, 3)), -(s/a1)**(Rational(1, 3))/2 - sqrt(3)*I*(s/a1)**(Rational(1, 3))/2,
+        -(s/a1)**(Rational(1, 3))/2 + sqrt(3)*I*(s/a1)**(Rational(1, 3))/2]
+    assert str(expect3.zeros()) == str([0.125 - 1.11102430216445*sqrt(-0.405063291139241*p**3 - 1.0),
+        1.11102430216445*sqrt(-0.405063291139241*p**3 - 1.0) + 0.125])
+    assert tf_.zeros() == [k**(Rational(1, 3)), -k**(Rational(1, 3))/2 - sqrt(3)*I*k**(Rational(1, 3))/2,
+        -k**(Rational(1, 3))/2 + sqrt(3)*I*k**(Rational(1, 3))/2]
+    assert _TF.zeros() == [CRootOf(x**9 + x + 1, 0), 0, CRootOf(x**9 + x + 1, 1), CRootOf(x**9 + x + 1, 2),
+        CRootOf(x**9 + x + 1, 3), CRootOf(x**9 + x + 1, 4), CRootOf(x**9 + x + 1, 5), CRootOf(x**9 + x + 1, 6),
+        CRootOf(x**9 + x + 1, 7), CRootOf(x**9 + x + 1, 8)]
+    raises(NotImplementedError, lambda: TransferFunction(a0*x**10 + x + x**2, x**2, x).zeros())
+
+    # negation of TF.
+    tf2 = TransferFunction(s + 3, s**2 - s**3 + 9, s)
+    tf3 = TransferFunction(-3*p + 3, 1 - p, p)
+    assert -tf2 == TransferFunction(-s - 3, s**2 - s**3 + 9, s)
+    assert -tf3 == TransferFunction(3*p - 3, 1 - p, p)
+
+    # taking power of a TF.
+    tf4 = TransferFunction(p + 4, p - 3, p)
+    tf5 = TransferFunction(s**2 + 1, 1 - s, s)
+    expect2 = TransferFunction((s**2 + 1)**3, (1 - s)**3, s)
+    expect1 = TransferFunction((p + 4)**2, (p - 3)**2, p)
+    assert (tf4*tf4).doit() == tf4**2 == pow(tf4, 2) == expect1
+    assert (tf5*tf5*tf5).doit() == tf5**3 == pow(tf5, 3) == expect2
+    assert tf5**0 == pow(tf5, 0) == TransferFunction(1, 1, s)
+    assert Series(tf4).doit()**-1 == tf4**-1 == pow(tf4, -1) == TransferFunction(p - 3, p + 4, p)
+    assert (tf5*tf5).doit()**-1 == tf5**-2 == pow(tf5, -2) == TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
+
+    raises(ValueError, lambda: tf4**(s**2 + s - 1))
+    raises(ValueError, lambda: tf5**s)
+    raises(ValueError, lambda: tf4**tf5)
+
+    # SymPy's own functions.
+    tf = TransferFunction(s - 1, s**2 - 2*s + 1, s)
+    tf6 = TransferFunction(s + p, p**2 - 5, s)
+    assert factor(tf) == TransferFunction(s - 1, (s - 1)**2, s)
+    assert tf.num.subs(s, 2) == tf.den.subs(s, 2) == 1
+    # subs & xreplace
+    assert tf.subs(s, 2) == TransferFunction(s - 1, s**2 - 2*s + 1, s)
+    assert tf6.subs(p, 3) == TransferFunction(s + 3, 4, s)
+    assert tf3.xreplace({p: s}) == TransferFunction(-3*s + 3, 1 - s, s)
+    raises(TypeError, lambda: tf3.xreplace({p: exp(2)}))
+    assert tf3.subs(p, exp(2)) == tf3
+
+    tf7 = TransferFunction(a0*s**p + a1*p**s, a2*p - s, s)
+    assert tf7.xreplace({s: k}) == TransferFunction(a0*k**p + a1*p**k, a2*p - k, k)
+    assert tf7.subs(s, k) == TransferFunction(a0*s**p + a1*p**s, a2*p - s, s)
+
+    # Conversion to Expr with to_expr()
+    tf8 = TransferFunction(a0*s**5 + 5*s**2 + 3, s**6 - 3, s)
+    tf9 = TransferFunction((5 + s), (5 + s)*(6 + s), s)
+    tf10 = TransferFunction(0, 1, s)
+    tf11 = TransferFunction(1, 1, s)
+    assert tf8.to_expr() == Mul((a0*s**5 + 5*s**2 + 3), Pow((s**6 - 3), -1, evaluate=False), evaluate=False)
+    assert tf9.to_expr() == Mul((s + 5), Pow((5 + s)*(6 + s), -1, evaluate=False), evaluate=False)
+    assert tf10.to_expr() == Mul(S(0), Pow(1, -1, evaluate=False), evaluate=False)
+    assert tf11.to_expr() == Pow(1, -1, evaluate=False)
+
+def test_TransferFunction_addition_and_subtraction():
+    tf1 = TransferFunction(s + 6, s - 5, s)
+    tf2 = TransferFunction(s + 3, s + 1, s)
+    tf3 = TransferFunction(s + 1, s**2 + s + 1, s)
+    tf4 = TransferFunction(p, 2 - p, p)
+
+    # addition
+    assert tf1 + tf2 == Parallel(tf1, tf2)
+    assert tf3 + tf1 == Parallel(tf3, tf1)
+    assert -tf1 + tf2 + tf3 == Parallel(-tf1, tf2, tf3)
+    assert tf1 + (tf2 + tf3) == Parallel(tf1, tf2, tf3)
+
+    c = symbols("c", commutative=False)
+    raises(ValueError, lambda: tf1 + Matrix([1, 2, 3]))
+    raises(ValueError, lambda: tf2 + c)
+    raises(ValueError, lambda: tf3 + tf4)
+    raises(ValueError, lambda: tf1 + (s - 1))
+    raises(ValueError, lambda: tf1 + 8)
+    raises(ValueError, lambda: (1 - p**3) + tf1)
+
+    # subtraction
+    assert tf1 - tf2 == Parallel(tf1, -tf2)
+    assert tf3 - tf2 == Parallel(tf3, -tf2)
+    assert -tf1 - tf3 == Parallel(-tf1, -tf3)
+    assert tf1 - tf2 + tf3 == Parallel(tf1, -tf2, tf3)
+
+    raises(ValueError, lambda: tf1 - Matrix([1, 2, 3]))
+    raises(ValueError, lambda: tf3 - tf4)
+    raises(ValueError, lambda: tf1 - (s - 1))
+    raises(ValueError, lambda: tf1 - 8)
+    raises(ValueError, lambda: (s + 5) - tf2)
+    raises(ValueError, lambda: (1 + p**4) - tf1)
+
+
+def test_TransferFunction_multiplication_and_division():
+    G1 = TransferFunction(s + 3, -s**3 + 9, s)
+    G2 = TransferFunction(s + 1, s - 5, s)
+    G3 = TransferFunction(p, p**4 - 6, p)
+    G4 = TransferFunction(p + 4, p - 5, p)
+    G5 = TransferFunction(s + 6, s - 5, s)
+    G6 = TransferFunction(s + 3, s + 1, s)
+    G7 = TransferFunction(1, 1, s)
+
+    # multiplication
+    assert G1*G2 == Series(G1, G2)
+    assert -G1*G5 == Series(-G1, G5)
+    assert -G2*G5*-G6 == Series(-G2, G5, -G6)
+    assert -G1*-G2*-G5*-G6 == Series(-G1, -G2, -G5, -G6)
+    assert G3*G4 == Series(G3, G4)
+    assert (G1*G2)*-(G5*G6) == \
+        Series(G1, G2, TransferFunction(-1, 1, s), Series(G5, G6))
+    assert G1*G2*(G5 + G6) == Series(G1, G2, Parallel(G5, G6))
+
+    c = symbols("c", commutative=False)
+    raises(ValueError, lambda: G3 * Matrix([1, 2, 3]))
+    raises(ValueError, lambda: G1 * c)
+    raises(ValueError, lambda: G3 * G5)
+    raises(ValueError, lambda: G5 * (s - 1))
+    raises(ValueError, lambda: 9 * G5)
+
+    raises(ValueError, lambda: G3 / Matrix([1, 2, 3]))
+    raises(ValueError, lambda: G6 / 0)
+    raises(ValueError, lambda: G3 / G5)
+    raises(ValueError, lambda: G5 / 2)
+    raises(ValueError, lambda: G5 / s**2)
+    raises(ValueError, lambda: (s - 4*s**2) / G2)
+    raises(ValueError, lambda: 0 / G4)
+    raises(ValueError, lambda: G5 / G6)
+    raises(ValueError, lambda: -G3 /G4)
+    raises(ValueError, lambda: G7 / (1 + G6))
+    raises(ValueError, lambda: G7 / (G5 * G6))
+    raises(ValueError, lambda: G7 / (G7 + (G5 + G6)))
+
+
+def test_TransferFunction_is_proper():
+    omega_o, zeta, tau = symbols('omega_o, zeta, tau')
+    G1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    G2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    G3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    G4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert G1.is_proper
+    assert G2.is_proper
+    assert G3.is_proper
+    assert not G4.is_proper
+
+
+def test_TransferFunction_is_strictly_proper():
+    omega_o, zeta, tau = symbols('omega_o, zeta, tau')
+    tf1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    tf2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    tf3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    tf4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert not tf1.is_strictly_proper
+    assert not tf2.is_strictly_proper
+    assert tf3.is_strictly_proper
+    assert not tf4.is_strictly_proper
+
+
+def test_TransferFunction_is_biproper():
+    tau, omega_o, zeta = symbols('tau, omega_o, zeta')
+    tf1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    tf2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    tf3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    tf4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert tf1.is_biproper
+    assert tf2.is_biproper
+    assert not tf3.is_biproper
+    assert not tf4.is_biproper
+
+
+def test_Series_construction():
+    tf = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf3 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf4 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    inp = Function('X_d')(s)
+    out = Function('X')(s)
+
+    s0 = Series(tf, tf2)
+    assert s0.args == (tf, tf2)
+    assert s0.var == s
+
+    s1 = Series(Parallel(tf, -tf2), tf2)
+    assert s1.args == (Parallel(tf, -tf2), tf2)
+    assert s1.var == s
+
+    tf3_ = TransferFunction(inp, 1, s)
+    tf4_ = TransferFunction(-out, 1, s)
+    s2 = Series(tf, Parallel(tf3_, tf4_), tf2)
+    assert s2.args == (tf, Parallel(tf3_, tf4_), tf2)
+
+    s3 = Series(tf, tf2, tf4)
+    assert s3.args == (tf, tf2, tf4)
+
+    s4 = Series(tf3_, tf4_)
+    assert s4.args == (tf3_, tf4_)
+    assert s4.var == s
+
+    s6 = Series(tf2, tf4, Parallel(tf2, -tf), tf4)
+    assert s6.args == (tf2, tf4, Parallel(tf2, -tf), tf4)
+
+    s7 = Series(tf, tf2)
+    assert s0 == s7
+    assert not s0 == s2
+
+    raises(ValueError, lambda: Series(tf, tf3))
+    raises(ValueError, lambda: Series(tf, tf2, tf3, tf4))
+    raises(ValueError, lambda: Series(-tf3, tf2))
+    raises(TypeError, lambda: Series(2, tf, tf4))
+    raises(TypeError, lambda: Series(s**2 + p*s, tf3, tf2))
+    raises(TypeError, lambda: Series(tf3, Matrix([1, 2, 3, 4])))
+
+
+def test_MIMOSeries_construction():
+    tf_1 = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf_2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf_3 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf_1, tf_2, tf_3], [-tf_3, -tf_2, tf_1]])
+    tfm_2 = TransferFunctionMatrix([[-tf_2], [-tf_2], [-tf_3]])
+    tfm_3 = TransferFunctionMatrix([[-tf_3]])
+    tfm_4 = TransferFunctionMatrix([[TF3], [TF2], [-TF1]])
+    tfm_5 = TransferFunctionMatrix.from_Matrix(Matrix([1/p]), p)
+
+    s8 = MIMOSeries(tfm_2, tfm_1)
+    assert s8.args == (tfm_2, tfm_1)
+    assert s8.var == s
+    assert s8.shape == (s8.num_outputs, s8.num_inputs) == (2, 1)
+
+    s9 = MIMOSeries(tfm_3, tfm_2, tfm_1)
+    assert s9.args == (tfm_3, tfm_2, tfm_1)
+    assert s9.var == s
+    assert s9.shape == (s9.num_outputs, s9.num_inputs) == (2, 1)
+
+    s11 = MIMOSeries(tfm_3, MIMOParallel(-tfm_2, -tfm_4), tfm_1)
+    assert s11.args == (tfm_3, MIMOParallel(-tfm_2, -tfm_4), tfm_1)
+    assert s11.shape == (s11.num_outputs, s11.num_inputs) == (2, 1)
+
+    # arg cannot be empty tuple.
+    raises(ValueError, lambda: MIMOSeries())
+
+    # arg cannot contain SISO as well as MIMO systems.
+    raises(TypeError, lambda: MIMOSeries(tfm_1, tf_1))
+
+    # for all the adjacent transfer function matrices:
+    # no. of inputs of first TFM must be equal to the no. of outputs of the second TFM.
+    raises(ValueError, lambda: MIMOSeries(tfm_1, tfm_2, -tfm_1))
+
+    # all the TFMs must use the same complex variable.
+    raises(ValueError, lambda: MIMOSeries(tfm_3, tfm_5))
+
+    # Number or expression not allowed in the arguments.
+    raises(TypeError, lambda: MIMOSeries(2, tfm_2, tfm_3))
+    raises(TypeError, lambda: MIMOSeries(s**2 + p*s, -tfm_2, tfm_3))
+    raises(TypeError, lambda: MIMOSeries(Matrix([1/p]), tfm_3))
+
+
+def test_Series_functions():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    assert tf1*tf2*tf3 == Series(tf1, tf2, tf3) == Series(Series(tf1, tf2), tf3) \
+        == Series(tf1, Series(tf2, tf3))
+    assert tf1*(tf2 + tf3) == Series(tf1, Parallel(tf2, tf3))
+    assert tf1*tf2 + tf5 == Parallel(Series(tf1, tf2), tf5)
+    assert tf1*tf2 - tf5 == Parallel(Series(tf1, tf2), -tf5)
+    assert tf1*tf2 + tf3 + tf5 == Parallel(Series(tf1, tf2), tf3, tf5)
+    assert tf1*tf2 - tf3 - tf5 == Parallel(Series(tf1, tf2), -tf3, -tf5)
+    assert tf1*tf2 - tf3 + tf5 == Parallel(Series(tf1, tf2), -tf3, tf5)
+    assert tf1*tf2 + tf3*tf5 == Parallel(Series(tf1, tf2), Series(tf3, tf5))
+    assert tf1*tf2 - tf3*tf5 == Parallel(Series(tf1, tf2), Series(TransferFunction(-1, 1, s), Series(tf3, tf5)))
+    assert tf2*tf3*(tf2 - tf1)*tf3 == Series(tf2, tf3, Parallel(tf2, -tf1), tf3)
+    assert -tf1*tf2 == Series(-tf1, tf2)
+    assert -(tf1*tf2) == Series(TransferFunction(-1, 1, s), Series(tf1, tf2))
+    raises(ValueError, lambda: tf1*tf2*tf4)
+    raises(ValueError, lambda: tf1*(tf2 - tf4))
+    raises(ValueError, lambda: tf3*Matrix([1, 2, 3]))
+
+    # evaluate=True -> doit()
+    assert Series(tf1, tf2, evaluate=True) == Series(tf1, tf2).doit() == \
+        TransferFunction(k, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Series(tf1, tf2, Parallel(tf1, -tf3), evaluate=True) == Series(tf1, tf2, Parallel(tf1, -tf3)).doit() == \
+        TransferFunction(k*(a2*s + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)**2, s)
+    assert Series(tf2, tf1, -tf3, evaluate=True) == Series(tf2, tf1, -tf3).doit() == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert not Series(tf1, -tf2, evaluate=False) == Series(tf1, -tf2).doit()
+
+    assert Series(Parallel(tf1, tf2), Parallel(tf2, -tf3)).doit() == \
+        TransferFunction((k*(s**2 + 2*s*wn*zeta + wn**2) + 1)*(-a2*p + k*(a2*s + p) + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Series(-tf1, -tf2, -tf3).doit() == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert -Series(tf1, tf2, tf3).doit() == \
+        TransferFunction(-k*(a2*p - s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Series(tf2, tf3, Parallel(tf2, -tf1), tf3).doit() == \
+        TransferFunction(k*(a2*p - s)**2*(k*(s**2 + 2*s*wn*zeta + wn**2) - 1), (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Series(tf1, tf2).rewrite(TransferFunction) == TransferFunction(k, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Series(tf2, tf1, -tf3).rewrite(TransferFunction) == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    S1 = Series(Parallel(tf1, tf2), Parallel(tf2, -tf3))
+    assert S1.is_proper
+    assert not S1.is_strictly_proper
+    assert S1.is_biproper
+
+    S2 = Series(tf1, tf2, tf3)
+    assert S2.is_proper
+    assert S2.is_strictly_proper
+    assert not S2.is_biproper
+
+    S3 = Series(tf1, -tf2, Parallel(tf1, -tf3))
+    assert S3.is_proper
+    assert S3.is_strictly_proper
+    assert not S3.is_biproper
+
+
+def test_MIMOSeries_functions():
+    tfm1 = TransferFunctionMatrix([[TF1, TF2, TF3], [-TF3, -TF2, TF1]])
+    tfm2 = TransferFunctionMatrix([[-TF1], [-TF2], [-TF3]])
+    tfm3 = TransferFunctionMatrix([[-TF1]])
+    tfm4 = TransferFunctionMatrix([[-TF2, -TF3], [-TF1, TF2]])
+    tfm5 = TransferFunctionMatrix([[TF2, -TF2], [-TF3, -TF2]])
+    tfm6 = TransferFunctionMatrix([[-TF3], [TF1]])
+    tfm7 = TransferFunctionMatrix([[TF1], [-TF2]])
+
+    assert tfm1*tfm2 + tfm6 == MIMOParallel(MIMOSeries(tfm2, tfm1), tfm6)
+    assert tfm1*tfm2 + tfm7 + tfm6 == MIMOParallel(MIMOSeries(tfm2, tfm1), tfm7, tfm6)
+    assert tfm1*tfm2 - tfm6 - tfm7 == MIMOParallel(MIMOSeries(tfm2, tfm1), -tfm6, -tfm7)
+    assert tfm4*tfm5 + (tfm4 - tfm5) == MIMOParallel(MIMOSeries(tfm5, tfm4), tfm4, -tfm5)
+    assert tfm4*-tfm6 + (-tfm4*tfm6) == MIMOParallel(MIMOSeries(-tfm6, tfm4), MIMOSeries(tfm6, -tfm4))
+
+    raises(ValueError, lambda: tfm1*tfm2 + TF1)
+    raises(TypeError, lambda: tfm1*tfm2 + a0)
+    raises(TypeError, lambda: tfm4*tfm6 - (s - 1))
+    raises(TypeError, lambda: tfm4*-tfm6 - 8)
+    raises(TypeError, lambda: (-1 + p**5) + tfm1*tfm2)
+
+    # Shape criteria.
+
+    raises(TypeError, lambda: -tfm1*tfm2 + tfm4)
+    raises(TypeError, lambda: tfm1*tfm2 - tfm4 + tfm5)
+    raises(TypeError, lambda: tfm1*tfm2 - tfm4*tfm5)
+
+    assert tfm1*tfm2*-tfm3 == MIMOSeries(-tfm3, tfm2, tfm1)
+    assert (tfm1*-tfm2)*tfm3 == MIMOSeries(tfm3, -tfm2, tfm1)
+
+    # Multiplication of a Series object with a SISO TF not allowed.
+
+    raises(ValueError, lambda: tfm4*tfm5*TF1)
+    raises(TypeError, lambda: tfm4*tfm5*a1)
+    raises(TypeError, lambda: tfm4*-tfm5*(s - 2))
+    raises(TypeError, lambda: tfm5*tfm4*9)
+    raises(TypeError, lambda: (-p**3 + 1)*tfm5*tfm4)
+
+    # Transfer function matrix in the arguments.
+    assert (MIMOSeries(tfm2, tfm1, evaluate=True) == MIMOSeries(tfm2, tfm1).doit()
+        == TransferFunctionMatrix(((TransferFunction(-k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2)**2 - (a2*s + p)**2,
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2, s),),
+        (TransferFunction(k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*p - s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2),
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2, s),))))
+
+    # doit() should not cancel poles and zeros.
+    mat_1 = Matrix([[1/(1+s), (1+s)/(1+s**2+2*s)**3]])
+    mat_2 = Matrix([[(1+s)], [(1+s**2+2*s)**3/(1+s)]])
+    tm_1, tm_2 = TransferFunctionMatrix.from_Matrix(mat_1, s), TransferFunctionMatrix.from_Matrix(mat_2, s)
+    assert (MIMOSeries(tm_2, tm_1).doit()
+        == TransferFunctionMatrix(((TransferFunction(2*(s + 1)**2*(s**2 + 2*s + 1)**3, (s + 1)**2*(s**2 + 2*s + 1)**3, s),),)))
+    assert MIMOSeries(tm_2, tm_1).doit().simplify() == TransferFunctionMatrix(((TransferFunction(2, 1, s),),))
+
+    # calling doit() will expand the internal Series and Parallel objects.
+    assert (MIMOSeries(-tfm3, -tfm2, tfm1, evaluate=True)
+        == MIMOSeries(-tfm3, -tfm2, tfm1).doit()
+        == TransferFunctionMatrix(((TransferFunction(k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (a2*p - s)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (a2*s + p)**2,
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**3, s),),
+        (TransferFunction(-k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*p - s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2),
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**3, s),))))
+    assert (MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5, evaluate=True)
+        == MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5).doit()
+        == TransferFunctionMatrix(((TransferFunction(-k*(-a2*s - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s), TransferFunction(k*(-a2*p - \
+            k*(a2*s + p) + s), a2*s + p, s)), (TransferFunction(-k*(-a2*s - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s), \
+            TransferFunction((-a2*p + s)*(-a2*p - k*(a2*s + p) + s), (a2*s + p)**2, s)))) == MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5).rewrite(TransferFunctionMatrix))
+
+
+def test_Parallel_construction():
+    tf = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf3 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf4 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    inp = Function('X_d')(s)
+    out = Function('X')(s)
+
+    p0 = Parallel(tf, tf2)
+    assert p0.args == (tf, tf2)
+    assert p0.var == s
+
+    p1 = Parallel(Series(tf, -tf2), tf2)
+    assert p1.args == (Series(tf, -tf2), tf2)
+    assert p1.var == s
+
+    tf3_ = TransferFunction(inp, 1, s)
+    tf4_ = TransferFunction(-out, 1, s)
+    p2 = Parallel(tf, Series(tf3_, -tf4_), tf2)
+    assert p2.args == (tf, Series(tf3_, -tf4_), tf2)
+
+    p3 = Parallel(tf, tf2, tf4)
+    assert p3.args == (tf, tf2, tf4)
+
+    p4 = Parallel(tf3_, tf4_)
+    assert p4.args == (tf3_, tf4_)
+    assert p4.var == s
+
+    p5 = Parallel(tf, tf2)
+    assert p0 == p5
+    assert not p0 == p1
+
+    p6 = Parallel(tf2, tf4, Series(tf2, -tf4))
+    assert p6.args == (tf2, tf4, Series(tf2, -tf4))
+
+    p7 = Parallel(tf2, tf4, Series(tf2, -tf), tf4)
+    assert p7.args == (tf2, tf4, Series(tf2, -tf), tf4)
+
+    raises(ValueError, lambda: Parallel(tf, tf3))
+    raises(ValueError, lambda: Parallel(tf, tf2, tf3, tf4))
+    raises(ValueError, lambda: Parallel(-tf3, tf4))
+    raises(TypeError, lambda: Parallel(2, tf, tf4))
+    raises(TypeError, lambda: Parallel(s**2 + p*s, tf3, tf2))
+    raises(TypeError, lambda: Parallel(tf3, Matrix([1, 2, 3, 4])))
+
+
+def test_MIMOParallel_construction():
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2], [TF3]])
+    tfm2 = TransferFunctionMatrix([[-TF3], [TF2], [TF1]])
+    tfm3 = TransferFunctionMatrix([[TF1]])
+    tfm4 = TransferFunctionMatrix([[TF2], [TF1], [TF3]])
+    tfm5 = TransferFunctionMatrix([[TF1, TF2], [TF2, TF1]])
+    tfm6 = TransferFunctionMatrix([[TF2, TF1], [TF1, TF2]])
+    tfm7 = TransferFunctionMatrix.from_Matrix(Matrix([[1/p]]), p)
+
+    p8 = MIMOParallel(tfm1, tfm2)
+    assert p8.args == (tfm1, tfm2)
+    assert p8.var == s
+    assert p8.shape == (p8.num_outputs, p8.num_inputs) == (3, 1)
+
+    p9 = MIMOParallel(MIMOSeries(tfm3, tfm1), tfm2)
+    assert p9.args == (MIMOSeries(tfm3, tfm1), tfm2)
+    assert p9.var == s
+    assert p9.shape == (p9.num_outputs, p9.num_inputs) == (3, 1)
+
+    p10 = MIMOParallel(tfm1, MIMOSeries(tfm3, tfm4), tfm2)
+    assert p10.args == (tfm1, MIMOSeries(tfm3, tfm4), tfm2)
+    assert p10.var == s
+    assert p10.shape == (p10.num_outputs, p10.num_inputs) == (3, 1)
+
+    p11 = MIMOParallel(tfm2, tfm1, tfm4)
+    assert p11.args == (tfm2, tfm1, tfm4)
+    assert p11.shape == (p11.num_outputs, p11.num_inputs) == (3, 1)
+
+    p12 = MIMOParallel(tfm6, tfm5)
+    assert p12.args == (tfm6, tfm5)
+    assert p12.shape == (p12.num_outputs, p12.num_inputs) == (2, 2)
+
+    p13 = MIMOParallel(tfm2, tfm4, MIMOSeries(-tfm3, tfm4), -tfm4)
+    assert p13.args == (tfm2, tfm4, MIMOSeries(-tfm3, tfm4), -tfm4)
+    assert p13.shape == (p13.num_outputs, p13.num_inputs) == (3, 1)
+
+    # arg cannot be empty tuple.
+    raises(TypeError, lambda: MIMOParallel(()))
+
+    # arg cannot contain SISO as well as MIMO systems.
+    raises(TypeError, lambda: MIMOParallel(tfm1, tfm2, TF1))
+
+    # all TFMs must have same shapes.
+    raises(TypeError, lambda: MIMOParallel(tfm1, tfm3, tfm4))
+
+    # all TFMs must be using the same complex variable.
+    raises(ValueError, lambda: MIMOParallel(tfm3, tfm7))
+
+    # Number or expression not allowed in the arguments.
+    raises(TypeError, lambda: MIMOParallel(2, tfm1, tfm4))
+    raises(TypeError, lambda: MIMOParallel(s**2 + p*s, -tfm4, tfm2))
+
+
+def test_Parallel_functions():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    assert tf1 + tf2 + tf3 == Parallel(tf1, tf2, tf3)
+    assert tf1 + tf2 + tf3 + tf5 == Parallel(tf1, tf2, tf3, tf5)
+    assert tf1 + tf2 - tf3 - tf5 == Parallel(tf1, tf2, -tf3, -tf5)
+    assert tf1 + tf2*tf3 == Parallel(tf1, Series(tf2, tf3))
+    assert tf1 - tf2*tf3 == Parallel(tf1, -Series(tf2,tf3))
+    assert -tf1 - tf2 == Parallel(-tf1, -tf2)
+    assert -(tf1 + tf2) == Series(TransferFunction(-1, 1, s), Parallel(tf1, tf2))
+    assert (tf2 + tf3)*tf1 == Series(Parallel(tf2, tf3), tf1)
+    assert (tf1 + tf2)*(tf3*tf5) == Series(Parallel(tf1, tf2), tf3, tf5)
+    assert -(tf2 + tf3)*-tf5 == Series(TransferFunction(-1, 1, s), Parallel(tf2, tf3), -tf5)
+    assert tf2 + tf3 + tf2*tf1 + tf5 == Parallel(tf2, tf3, Series(tf2, tf1), tf5)
+    assert tf2 + tf3 + tf2*tf1 - tf3 == Parallel(tf2, tf3, Series(tf2, tf1), -tf3)
+    assert (tf1 + tf2 + tf5)*(tf3 + tf5) == Series(Parallel(tf1, tf2, tf5), Parallel(tf3, tf5))
+    raises(ValueError, lambda: tf1 + tf2 + tf4)
+    raises(ValueError, lambda: tf1 - tf2*tf4)
+    raises(ValueError, lambda: tf3 + Matrix([1, 2, 3]))
+
+    # evaluate=True -> doit()
+    assert Parallel(tf1, tf2, evaluate=True) == Parallel(tf1, tf2).doit() == \
+        TransferFunction(k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Parallel(tf1, tf2, Series(-tf1, tf3), evaluate=True) == \
+        Parallel(tf1, tf2, Series(-tf1, tf3)).doit() == TransferFunction(k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)**2 + \
+            (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), (a2*s + p)*(s**2 + \
+                2*s*wn*zeta + wn**2)**2, s)
+    assert Parallel(tf2, tf1, -tf3, evaluate=True) == Parallel(tf2, tf1, -tf3).doit() == \
+        TransferFunction(a2*s + k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2) \
+            , (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert not Parallel(tf1, -tf2, evaluate=False) == Parallel(tf1, -tf2).doit()
+
+    assert Parallel(Series(tf1, tf2), Series(tf2, tf3)).doit() == \
+        TransferFunction(k*(a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2) + k*(a2*s + p), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Parallel(-tf1, -tf2, -tf3).doit() == \
+        TransferFunction(-a2*s - k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2), \
+            (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert -Parallel(tf1, tf2, tf3).doit() == \
+        TransferFunction(-a2*s - k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - p - (a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2), \
+            (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Parallel(tf2, tf3, Series(tf2, -tf1), tf3).doit() == \
+        TransferFunction(k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - k*(a2*s + p) + (2*a2*p - 2*s)*(s**2 + 2*s*wn*zeta \
+            + wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Parallel(tf1, tf2).rewrite(TransferFunction) == \
+        TransferFunction(k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Parallel(tf2, tf1, -tf3).rewrite(TransferFunction) == \
+        TransferFunction(a2*s + k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + \
+             wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Parallel(tf1, Parallel(tf2, tf3)) == Parallel(tf1, tf2, tf3) == Parallel(Parallel(tf1, tf2), tf3)
+
+    P1 = Parallel(Series(tf1, tf2), Series(tf2, tf3))
+    assert P1.is_proper
+    assert not P1.is_strictly_proper
+    assert P1.is_biproper
+
+    P2 = Parallel(tf1, -tf2, -tf3)
+    assert P2.is_proper
+    assert not P2.is_strictly_proper
+    assert P2.is_biproper
+
+    P3 = Parallel(tf1, -tf2, Series(tf1, tf3))
+    assert P3.is_proper
+    assert not P3.is_strictly_proper
+    assert P3.is_biproper
+
+
+def test_MIMOParallel_functions():
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2], [TF3]])
+    tfm2 = TransferFunctionMatrix([[-TF2], [tf5], [-TF1]])
+    tfm3 = TransferFunctionMatrix([[tf5], [-tf5], [TF2]])
+    tfm4 = TransferFunctionMatrix([[TF2, -tf5], [TF1, tf5]])
+    tfm5 = TransferFunctionMatrix([[TF1, TF2], [TF3, -tf5]])
+    tfm6 = TransferFunctionMatrix([[-TF2]])
+    tfm7 = TransferFunctionMatrix([[tf4], [-tf4], [tf4]])
+
+    assert tfm1 + tfm2 + tfm3 == MIMOParallel(tfm1, tfm2, tfm3) == MIMOParallel(MIMOParallel(tfm1, tfm2), tfm3)
+    assert tfm2 - tfm1 - tfm3 == MIMOParallel(tfm2, -tfm1, -tfm3)
+    assert tfm2 - tfm3 + (-tfm1*tfm6*-tfm6) == MIMOParallel(tfm2, -tfm3, MIMOSeries(-tfm6, tfm6, -tfm1))
+    assert tfm1 + tfm1 - (-tfm1*tfm6) == MIMOParallel(tfm1, tfm1, -MIMOSeries(tfm6, -tfm1))
+    assert tfm2 - tfm3 - tfm1 + tfm2 == MIMOParallel(tfm2, -tfm3, -tfm1, tfm2)
+    assert tfm1 + tfm2 - tfm3 - tfm1 == MIMOParallel(tfm1, tfm2, -tfm3, -tfm1)
+    raises(ValueError, lambda: tfm1 + tfm2 + TF2)
+    raises(TypeError, lambda: tfm1 - tfm2 - a1)
+    raises(TypeError, lambda: tfm2 - tfm3 - (s - 1))
+    raises(TypeError, lambda: -tfm3 - tfm2 - 9)
+    raises(TypeError, lambda: (1 - p**3) - tfm3 - tfm2)
+    # All TFMs must use the same complex var. tfm7 uses 'p'.
+    raises(ValueError, lambda: tfm3 - tfm2 - tfm7)
+    raises(ValueError, lambda: tfm2 - tfm1 + tfm7)
+    # (tfm1 +/- tfm2) has (3, 1) shape while tfm4 has (2, 2) shape.
+    raises(TypeError, lambda: tfm1 + tfm2 + tfm4)
+    raises(TypeError, lambda: (tfm1 - tfm2) - tfm4)
+
+    assert (tfm1 + tfm2)*tfm6 == MIMOSeries(tfm6, MIMOParallel(tfm1, tfm2))
+    assert (tfm2 - tfm3)*tfm6*-tfm6 == MIMOSeries(-tfm6, tfm6, MIMOParallel(tfm2, -tfm3))
+    assert (tfm2 - tfm1 - tfm3)*(tfm6 + tfm6) == MIMOSeries(MIMOParallel(tfm6, tfm6), MIMOParallel(tfm2, -tfm1, -tfm3))
+    raises(ValueError, lambda: (tfm4 + tfm5)*TF1)
+    raises(TypeError, lambda: (tfm2 - tfm3)*a2)
+    raises(TypeError, lambda: (tfm3 + tfm2)*(s - 6))
+    raises(TypeError, lambda: (tfm1 + tfm2 + tfm3)*0)
+    raises(TypeError, lambda: (1 - p**3)*(tfm1 + tfm3))
+
+    # (tfm3 - tfm2) has (3, 1) shape while tfm4*tfm5 has (2, 2) shape.
+    raises(ValueError, lambda: (tfm3 - tfm2)*tfm4*tfm5)
+    # (tfm1 - tfm2) has (3, 1) shape while tfm5 has (2, 2) shape.
+    raises(ValueError, lambda: (tfm1 - tfm2)*tfm5)
+
+    # TFM in the arguments.
+    assert (MIMOParallel(tfm1, tfm2, evaluate=True) == MIMOParallel(tfm1, tfm2).doit()
+    == MIMOParallel(tfm1, tfm2).rewrite(TransferFunctionMatrix)
+    == TransferFunctionMatrix(((TransferFunction(-k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s),), \
+        (TransferFunction(-a0 + a1*s**2 + a2*s + k*(a0 + s), a0 + s, s),), (TransferFunction(-a2*s - p + (a2*p - s)* \
+        (s**2 + 2*s*wn*zeta + wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s),))))
+
+
+def test_Feedback_construction():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf6 = TransferFunction(s - p, p + s, p)
+
+    f1 = Feedback(TransferFunction(1, 1, s), tf1*tf2*tf3)
+    assert f1.args == (TransferFunction(1, 1, s), Series(tf1, tf2, tf3), -1)
+    assert f1.sys1 == TransferFunction(1, 1, s)
+    assert f1.sys2 == Series(tf1, tf2, tf3)
+    assert f1.var == s
+
+    f2 = Feedback(tf1, tf2*tf3)
+    assert f2.args == (tf1, Series(tf2, tf3), -1)
+    assert f2.sys1 == tf1
+    assert f2.sys2 == Series(tf2, tf3)
+    assert f2.var == s
+
+    f3 = Feedback(tf1*tf2, tf5)
+    assert f3.args == (Series(tf1, tf2), tf5, -1)
+    assert f3.sys1 == Series(tf1, tf2)
+
+    f4 = Feedback(tf4, tf6)
+    assert f4.args == (tf4, tf6, -1)
+    assert f4.sys1 == tf4
+    assert f4.var == p
+
+    f5 = Feedback(tf5, TransferFunction(1, 1, s))
+    assert f5.args == (tf5, TransferFunction(1, 1, s), -1)
+    assert f5.var == s
+    assert f5 == Feedback(tf5)  # When sys2 is not passed explicitly, it is assumed to be unit tf.
+
+    f6 = Feedback(TransferFunction(1, 1, p), tf4)
+    assert f6.args == (TransferFunction(1, 1, p), tf4, -1)
+    assert f6.var == p
+
+    f7 = -Feedback(tf4*tf6, TransferFunction(1, 1, p))
+    assert f7.args == (Series(TransferFunction(-1, 1, p), Series(tf4, tf6)), -TransferFunction(1, 1, p), -1)
+    assert f7.sys1 == Series(TransferFunction(-1, 1, p), Series(tf4, tf6))
+
+    # denominator can't be a Parallel instance
+    raises(TypeError, lambda: Feedback(tf1, tf2 + tf3))
+    raises(TypeError, lambda: Feedback(tf1, Matrix([1, 2, 3])))
+    raises(TypeError, lambda: Feedback(TransferFunction(1, 1, s), s - 1))
+    raises(TypeError, lambda: Feedback(1, 1))
+    # raises(ValueError, lambda: Feedback(TransferFunction(1, 1, s), TransferFunction(1, 1, s)))
+    raises(ValueError, lambda: Feedback(tf2, tf4*tf5))
+    raises(ValueError, lambda: Feedback(tf2, tf1, 1.5))  # `sign` can only be -1 or 1
+    raises(ValueError, lambda: Feedback(tf1, -tf1**-1))  # denominator can't be zero
+    raises(ValueError, lambda: Feedback(tf4, tf5))  # Both systems should use the same `var`
+
+
+def test_Feedback_functions():
+    tf = TransferFunction(1, 1, s)
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf6 = TransferFunction(s - p, p + s, p)
+
+    assert tf / (tf + tf1) == Feedback(tf, tf1)
+    assert tf / (tf + tf1*tf2*tf3) == Feedback(tf, tf1*tf2*tf3)
+    assert tf1 / (tf + tf1*tf2*tf3) == Feedback(tf1, tf2*tf3)
+    assert (tf1*tf2) / (tf + tf1*tf2) == Feedback(tf1*tf2, tf)
+    assert (tf1*tf2) / (tf + tf1*tf2*tf5) == Feedback(tf1*tf2, tf5)
+    assert (tf1*tf2) / (tf + tf1*tf2*tf5*tf3) in (Feedback(tf1*tf2, tf5*tf3), Feedback(tf1*tf2, tf3*tf5))
+    assert tf4 / (TransferFunction(1, 1, p) + tf4*tf6) == Feedback(tf4, tf6)
+    assert tf5 / (tf + tf5) == Feedback(tf5, tf)
+
+    raises(TypeError, lambda: tf1*tf2*tf3 / (1 + tf1*tf2*tf3))
+    raises(ValueError, lambda: tf1*tf2*tf3 / tf3*tf5)
+    raises(ValueError, lambda: tf2*tf3 / (tf + tf2*tf3*tf4))
+
+    assert Feedback(tf, tf1*tf2*tf3).doit() == \
+        TransferFunction((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), k*(a2*p - s) + \
+        (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf, tf1*tf2*tf3).sensitivity == \
+        1/(k*(a2*p - s)/((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf1, tf2*tf3).doit() == \
+        TransferFunction((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), (k*(a2*p - s) + \
+        (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf1, tf2*tf3).sensitivity == \
+        1/(k*(a2*p - s)/((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf1*tf2, tf5).doit() == \
+        TransferFunction(k*(a0 + s)*(s**2 + 2*s*wn*zeta + wn**2), (k*(-a0 + a1*s**2 + a2*s) + \
+        (a0 + s)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf1*tf2, tf5, 1).sensitivity == \
+        1/(-k*(-a0 + a1*s**2 + a2*s)/((a0 + s)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf4, tf6).doit() == \
+        TransferFunction(p*(p + s)*(a0*p + p**a1 - s), p*(p*(p + s) + (-p + s)*(a0*p + p**a1 - s)), p)
+    assert -Feedback(tf4*tf6, TransferFunction(1, 1, p)).doit() == \
+        TransferFunction(-p*(-p + s)*(p + s)*(a0*p + p**a1 - s), p*(p + s)*(p*(p + s) + (-p + s)*(a0*p + p**a1 - s)), p)
+    assert Feedback(tf, tf).doit() == TransferFunction(1, 2, s)
+
+    assert Feedback(tf1, tf2*tf5).rewrite(TransferFunction) == \
+        TransferFunction((a0 + s)*(s**2 + 2*s*wn*zeta + wn**2), (k*(-a0 + a1*s**2 + a2*s) + \
+        (a0 + s)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(TransferFunction(1, 1, p), tf4).rewrite(TransferFunction) == \
+        TransferFunction(p, a0*p + p + p**a1 - s, p)
+
+
+def test_MIMOFeedback_construction():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s**3 - 1, s)
+    tf3 = TransferFunction(s, s + 1, s)
+    tf4 = TransferFunction(s, s**2 + 1, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf3], [tf4, tf1]])
+    tfm_3 = TransferFunctionMatrix([[tf3, tf4], [tf1, tf2]])
+
+    f1 = MIMOFeedback(tfm_1, tfm_2)
+    assert f1.args == (tfm_1, tfm_2, -1)
+    assert f1.sys1 == tfm_1
+    assert f1.sys2 == tfm_2
+    assert f1.var == s
+    assert f1.sign == -1
+    assert -(-f1) == f1
+
+    f2 = MIMOFeedback(tfm_2, tfm_1, 1)
+    assert f2.args == (tfm_2, tfm_1, 1)
+    assert f2.sys1 == tfm_2
+    assert f2.sys2 == tfm_1
+    assert f2.var == s
+    assert f2.sign == 1
+
+    f3 = MIMOFeedback(tfm_1, MIMOSeries(tfm_3, tfm_2))
+    assert f3.args == (tfm_1, MIMOSeries(tfm_3, tfm_2), -1)
+    assert f3.sys1 == tfm_1
+    assert f3.sys2 == MIMOSeries(tfm_3, tfm_2)
+    assert f3.var == s
+    assert f3.sign == -1
+
+    mat = Matrix([[1, 1/s], [0, 1]])
+    sys1 = controller = TransferFunctionMatrix.from_Matrix(mat, s)
+    f4 = MIMOFeedback(sys1, controller)
+    assert f4.args == (sys1, controller, -1)
+    assert f4.sys1 == f4.sys2 == sys1
+
+
+def test_MIMOFeedback_errors():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s**3 - 1, s)
+    tf3 = TransferFunction(s, s - 1, s)
+    tf4 = TransferFunction(s, s**2 + 1, s)
+    tf5 = TransferFunction(1, 1, s)
+    tf6 = TransferFunction(-1, s - 1, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf3], [tf4, tf1]])
+    tfm_3 = TransferFunctionMatrix.from_Matrix(eye(2), var=s)
+    tfm_4 = TransferFunctionMatrix([[tf1, tf5], [tf5, tf5]])
+    tfm_5 = TransferFunctionMatrix([[-tf3, tf3], [tf3, tf6]])
+    # tfm_4 is inverse of tfm_5. Therefore tfm_5*tfm_4 = I
+    tfm_6 = TransferFunctionMatrix([[-tf3]])
+    tfm_7 = TransferFunctionMatrix([[tf3, tf4]])
+
+    # Unsupported Types
+    raises(TypeError, lambda: MIMOFeedback(tf1, tf2))
+    raises(TypeError, lambda: MIMOFeedback(MIMOParallel(tfm_1, tfm_2), tfm_3))
+    # Shape Errors
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_6, 1))
+    raises(ValueError, lambda: MIMOFeedback(tfm_7, tfm_7))
+    # sign not 1/-1
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_2, -2))
+    # Non-Invertible Systems
+    raises(ValueError, lambda: MIMOFeedback(tfm_5, tfm_4, 1))
+    raises(ValueError, lambda: MIMOFeedback(tfm_4, -tfm_5))
+    raises(ValueError, lambda: MIMOFeedback(tfm_3, tfm_3, 1))
+    # Variable not same in both the systems
+    tfm_8 = TransferFunctionMatrix.from_Matrix(eye(2), var=p)
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_8, 1))
+
+
+def test_MIMOFeedback_functions():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s - 1, s)
+    tf3 = TransferFunction(1, 1, s)
+    tf4 = TransferFunction(-1, s - 1, s)
+
+    tfm_1 = TransferFunctionMatrix.from_Matrix(eye(2), var=s)
+    tfm_2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf3]])
+    tfm_3 = TransferFunctionMatrix([[-tf2, tf2], [tf2, tf4]])
+    tfm_4 = TransferFunctionMatrix([[tf1, tf2], [-tf2, tf1]])
+
+    # sensitivity, doit(), rewrite()
+    F_1 = MIMOFeedback(tfm_2, tfm_3)
+    F_2 = MIMOFeedback(tfm_2, MIMOSeries(tfm_4, -tfm_1), 1)
+
+    assert F_1.sensitivity == Matrix([[S.Half, 0], [0, S.Half]])
+    assert F_2.sensitivity == Matrix([[(-2*s**4 + s**2)/(s**2 - s + 1),
+        (2*s**3 - s**2)/(s**2 - s + 1)], [-s**2, s]])
+
+    assert F_1.doit() == \
+        TransferFunctionMatrix(((TransferFunction(1, 2*s, s),
+        TransferFunction(1, 2, s)), (TransferFunction(1, 2, s),
+        TransferFunction(1, 2, s)))) == F_1.rewrite(TransferFunctionMatrix)
+    assert F_2.doit(cancel=False, expand=True) == \
+        TransferFunctionMatrix(((TransferFunction(-s**5 + 2*s**4 - 2*s**3 + s**2, s**5 - 2*s**4 + 3*s**3 - 2*s**2 + s, s),
+        TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)), (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+    assert F_2.doit(cancel=False) == \
+        TransferFunctionMatrix(((TransferFunction(s*(2*s**3 - s**2)*(s**2 - s + 1) + \
+        (-2*s**4 + s**2)*(s**2 - s + 1), s*(s**2 - s + 1)**2, s), TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)),
+        (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+    assert F_2.doit() == \
+        TransferFunctionMatrix(((TransferFunction(s*(-2*s**2 + s*(2*s - 1) + 1), s**2 - s + 1, s),
+        TransferFunction(-2*s**3*(s - 1), s**2 - s + 1, s)), (TransferFunction(0, 1, s), TransferFunction(s*(1 - s), 1, s))))
+    assert F_2.doit(expand=True) == \
+        TransferFunctionMatrix(((TransferFunction(-s**2 + s, s**2 - s + 1, s), TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)),
+        (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+
+    assert -(F_1.doit()) == (-F_1).doit()  # First negating then calculating vs calculating then negating.
+
+
+def test_TransferFunctionMatrix_construction():
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+
+    tfm3_ = TransferFunctionMatrix([[-TF3]])
+    assert tfm3_.shape == (tfm3_.num_outputs, tfm3_.num_inputs) == (1, 1)
+    assert tfm3_.args == Tuple(Tuple(Tuple(-TF3)))
+    assert tfm3_.var == s
+
+    tfm5 = TransferFunctionMatrix([[TF1, -TF2], [TF3, tf5]])
+    assert tfm5.shape == (tfm5.num_outputs, tfm5.num_inputs) == (2, 2)
+    assert tfm5.args == Tuple(Tuple(Tuple(TF1, -TF2), Tuple(TF3, tf5)))
+    assert tfm5.var == s
+
+    tfm7 = TransferFunctionMatrix([[TF1, TF2], [TF3, -tf5], [-tf5, TF2]])
+    assert tfm7.shape == (tfm7.num_outputs, tfm7.num_inputs) == (3, 2)
+    assert tfm7.args == Tuple(Tuple(Tuple(TF1, TF2), Tuple(TF3, -tf5), Tuple(-tf5, TF2)))
+    assert tfm7.var == s
+
+    # all transfer functions will use the same complex variable. tf4 uses 'p'.
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF2], [tf4]]))
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, tf4], [TF3, tf5]]))
+
+    # length of all the lists in the TFM should be equal.
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF3, tf5]]))
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, TF3], [tf5]]))
+
+    # lists should only support transfer functions in them.
+    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, TF2], [TF3, Matrix([1, 2])]]))
+    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, Matrix([1, 2])], [TF3, TF2]]))
+
+    # `arg` should strictly be nested list of TransferFunction
+    raises(ValueError, lambda: TransferFunctionMatrix([TF1, TF2, tf5]))
+    raises(ValueError, lambda: TransferFunctionMatrix([TF1]))
+
+def test_TransferFunctionMatrix_functions():
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    #  Classmethod (from_matrix)
+
+    mat_1 = ImmutableMatrix([
+        [s*(s + 1)*(s - 3)/(s**4 + 1), 2],
+        [p, p*(s + 1)/(s*(s**1 + 1))]
+        ])
+    mat_2 = ImmutableMatrix([[(2*s + 1)/(s**2 - 9)]])
+    mat_3 = ImmutableMatrix([[1, 2], [3, 4]])
+    assert TransferFunctionMatrix.from_Matrix(mat_1, s) == \
+        TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)],
+        [TransferFunction(p, 1, s), TransferFunction(p, s, s)]])
+    assert TransferFunctionMatrix.from_Matrix(mat_2, s) == \
+        TransferFunctionMatrix([[TransferFunction(2*s + 1, s**2 - 9, s)]])
+    assert TransferFunctionMatrix.from_Matrix(mat_3, p) == \
+        TransferFunctionMatrix([[TransferFunction(1, 1, p), TransferFunction(2, 1, p)],
+        [TransferFunction(3, 1, p), TransferFunction(4, 1, p)]])
+
+    #  Negating a TFM
+
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2]])
+    assert -tfm1 == TransferFunctionMatrix([[-TF1], [-TF2]])
+
+    tfm2 = TransferFunctionMatrix([[TF1, TF2, TF3], [tf5, -TF1, -TF3]])
+    assert -tfm2 == TransferFunctionMatrix([[-TF1, -TF2, -TF3], [-tf5, TF1, TF3]])
+
+    # subs()
+
+    H_1 = TransferFunctionMatrix.from_Matrix(mat_1, s)
+    H_2 = TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(s**2 - a), s)]])
+    assert H_1.subs(p, 1) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
+    assert H_1.subs({p: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
+    assert H_1.subs({p: 1, s: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]]) # This should ignore `s` as it is `var`
+    assert H_2.subs(p, 2) == TransferFunctionMatrix([[TransferFunction(2*a*s, k*s**2, s), TransferFunction(2*s, k*(-a + s**2), s)]])
+    assert H_2.subs(k, 1) == TransferFunctionMatrix([[TransferFunction(a*p*s, s**2, s), TransferFunction(p*s, -a + s**2, s)]])
+    assert H_2.subs(a, 0) == TransferFunctionMatrix([[TransferFunction(0, k*s**2, s), TransferFunction(p*s, k*s**2, s)]])
+    assert H_2.subs({p: 1, k: 1, a: a0}) == TransferFunctionMatrix([[TransferFunction(a0*s, s**2, s), TransferFunction(s, -a0 + s**2, s)]])
+
+    # transpose()
+
+    assert H_1.transpose() == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(p, 1, s)], [TransferFunction(2, 1, s), TransferFunction(p, s, s)]])
+    assert H_2.transpose() == TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s)], [TransferFunction(p*s, k*(-a + s**2), s)]])
+    assert H_1.transpose().transpose() == H_1
+    assert H_2.transpose().transpose() == H_2
+
+    # elem_poles()
+
+    assert H_1.elem_poles() == [[[-sqrt(2)/2 - sqrt(2)*I/2, -sqrt(2)/2 + sqrt(2)*I/2, sqrt(2)/2 - sqrt(2)*I/2, sqrt(2)/2 + sqrt(2)*I/2], []],
+        [[], [0]]]
+    assert H_2.elem_poles() == [[[0, 0], [sqrt(a), -sqrt(a)]]]
+    assert tfm2.elem_poles() == [[[wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [], [-p/a2]],
+        [[-a0], [wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [-p/a2]]]
+
+    # elem_zeros()
+
+    assert H_1.elem_zeros() == [[[-1, 0, 3], []], [[], []]]
+    assert H_2.elem_zeros() == [[[0], [0]]]
+    assert tfm2.elem_zeros() == [[[], [], [a2*p]],
+        [[-a2/(2*a1) - sqrt(4*a0*a1 + a2**2)/(2*a1), -a2/(2*a1) + sqrt(4*a0*a1 + a2**2)/(2*a1)], [], [a2*p]]]
+
+    # doit()
+
+    H_3 = TransferFunctionMatrix([[Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]])
+    H_4 = TransferFunctionMatrix([[Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]])
+
+    assert H_3.doit() == TransferFunctionMatrix([[TransferFunction(s**2 - 2*s + 5, s*(s**3 - 3), s)]])
+    assert H_4.doit() == TransferFunctionMatrix([[TransferFunction(1, 4*s**4 - s**2 - 2*s + 5, s)]])
+
+    # _flat()
+
+    assert H_1._flat() == [TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s), TransferFunction(p, 1, s), TransferFunction(p, s, s)]
+    assert H_2._flat() == [TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(-a + s**2), s)]
+    assert H_3._flat() == [Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]
+    assert H_4._flat() == [Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]
+
+    # evalf()
+
+    assert H_1.evalf() == \
+        TransferFunctionMatrix(((TransferFunction(s*(s - 3.0)*(s + 1.0), s**4 + 1.0, s), TransferFunction(2.0, 1, s)), (TransferFunction(1.0*p, 1, s), TransferFunction(p, s, s))))
+    assert H_2.subs({a:3.141, p:2.88, k:2}).evalf() == \
+        TransferFunctionMatrix(((TransferFunction(4.5230399999999999494093572138808667659759521484375, s, s),
+        TransferFunction(2.87999999999999989341858963598497211933135986328125*s, 2.0*s**2 - 6.282000000000000028421709430404007434844970703125, s)),))
+
+    # simplify()
+
+    H_5 = TransferFunctionMatrix([[TransferFunction(s**5 + s**3 + s, s - s**2, s),
+        TransferFunction((s + 3)*(s - 1), (s - 1)*(s + 5), s)]])
+
+    assert H_5.simplify() == simplify(H_5) == \
+        TransferFunctionMatrix(((TransferFunction(-s**4 - s**2 - 1, s - 1, s), TransferFunction(s + 3, s + 5, s)),))
+
+    # expand()
+
+    assert (H_1.expand()
+            == TransferFunctionMatrix(((TransferFunction(s**3 - 2*s**2 - 3*s, s**4 + 1, s), TransferFunction(2, 1, s)),
+            (TransferFunction(p, 1, s), TransferFunction(p, s, s)))))
+    assert H_5.expand() == \
+        TransferFunctionMatrix(((TransferFunction(s**5 + s**3 + s, -s**2 + s, s), TransferFunction(s**2 + 2*s - 3, s**2 + 4*s - 5, s)),))
+
+def test_TransferFunction_bilinear():
+    # simple transfer function, e.g. ohms law
+    tf = TransferFunction(1, a*s+b, s)
+    numZ, denZ = bilinear(tf, T)
+    # discretized transfer function with coefs from tf.bilinear()
+    tf_test_bilinear = TransferFunction(s*numZ[0]+numZ[1], s*denZ[0]+denZ[1], s)
+    # corresponding tf with manually calculated coefs
+    tf_test_manual = TransferFunction(s*T+T, s*(T*b+2*a)+T*b-2*a, s)
+
+    assert S.Zero == (tf_test_bilinear-tf_test_manual).simplify().num
+
+def test_TransferFunction_backward_diff():
+    # simple transfer function, e.g. ohms law
+    tf = TransferFunction(1, a*s+b, s)
+    numZ, denZ = backward_diff(tf, T)
+    # discretized transfer function with coefs from tf.bilinear()
+    tf_test_bilinear = TransferFunction(s*numZ[0]+numZ[1], s*denZ[0]+denZ[1], s)
+    # corresponding tf with manually calculated coefs
+    tf_test_manual = TransferFunction(s*T, s*(T*b+a)-a, s)
+
+    assert S.Zero == (tf_test_bilinear-tf_test_manual).simplify().num

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/__init__.py

@@ -0,0 +1,66 @@
+__all__ = [
+    'vector',
+
+    'CoordinateSym', 'ReferenceFrame', 'Dyadic', 'Vector', 'Point', 'cross',
+    'dot', 'express', 'time_derivative', 'outer', 'kinematic_equations',
+    'get_motion_params', 'partial_velocity', 'dynamicsymbols', 'vprint',
+    'vsstrrepr', 'vsprint', 'vpprint', 'vlatex', 'init_vprinting', 'curl',
+    'divergence', 'gradient', 'is_conservative', 'is_solenoidal',
+    'scalar_potential', 'scalar_potential_difference',
+
+    'KanesMethod',
+
+    'RigidBody',
+
+    'inertia', 'inertia_of_point_mass', 'linear_momentum', 'angular_momentum',
+    'kinetic_energy', 'potential_energy', 'Lagrangian', 'mechanics_printing',
+    'mprint', 'msprint', 'mpprint', 'mlatex', 'msubs', 'find_dynamicsymbols',
+
+    'Particle',
+
+    'LagrangesMethod',
+
+    'Linearizer',
+
+    'Body',
+
+    'SymbolicSystem',
+
+    'PinJoint', 'PrismaticJoint', 'CylindricalJoint', 'PlanarJoint',
+    'SphericalJoint', 'WeldJoint',
+
+    'JointsMethod'
+]
+
+from sympy.physics import vector
+
+from sympy.physics.vector import (CoordinateSym, ReferenceFrame, Dyadic, Vector, Point,
+        cross, dot, express, time_derivative, outer, kinematic_equations,
+        get_motion_params, partial_velocity, dynamicsymbols, vprint,
+        vsstrrepr, vsprint, vpprint, vlatex, init_vprinting, curl, divergence,
+        gradient, is_conservative, is_solenoidal, scalar_potential,
+        scalar_potential_difference)
+
+from .kane import KanesMethod
+
+from .rigidbody import RigidBody
+
+from .functions import (inertia, inertia_of_point_mass, linear_momentum,
+        angular_momentum, kinetic_energy, potential_energy, Lagrangian,
+        mechanics_printing, mprint, msprint, mpprint, mlatex, msubs,
+        find_dynamicsymbols)
+
+from .particle import Particle
+
+from .lagrange import LagrangesMethod
+
+from .linearize import Linearizer
+
+from .body import Body
+
+from .system import SymbolicSystem
+
+from .jointsmethod import JointsMethod
+
+from .joint import (PinJoint, PrismaticJoint, CylindricalJoint, PlanarJoint,
+                    SphericalJoint, WeldJoint)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/body.py

@@ -0,0 +1,611 @@
+from sympy.core.backend import Symbol
+from sympy.physics.vector import Point, Vector, ReferenceFrame, Dyadic
+from sympy.physics.mechanics import RigidBody, Particle, inertia
+
+__all__ = ['Body']
+
+
+# XXX: We use type:ignore because the classes RigidBody and Particle have
+# inconsistent parallel axis methods that take different numbers of arguments.
+class Body(RigidBody, Particle):  # type: ignore
+    """
+    Body is a common representation of either a RigidBody or a Particle SymPy
+    object depending on what is passed in during initialization. If a mass is
+    passed in and central_inertia is left as None, the Particle object is
+    created. Otherwise a RigidBody object will be created.
+
+    Explanation
+    ===========
+
+    The attributes that Body possesses will be the same as a Particle instance
+    or a Rigid Body instance depending on which was created. Additional
+    attributes are listed below.
+
+    Attributes
+    ==========
+
+    name : string
+        The body's name
+    masscenter : Point
+        The point which represents the center of mass of the rigid body
+    frame : ReferenceFrame
+        The reference frame which the body is fixed in
+    mass : Sympifyable
+        The body's mass
+    inertia : (Dyadic, Point)
+        The body's inertia around its center of mass. This attribute is specific
+        to the rigid body form of Body and is left undefined for the Particle
+        form
+    loads : iterable
+        This list contains information on the different loads acting on the
+        Body. Forces are listed as a (point, vector) tuple and torques are
+        listed as (reference frame, vector) tuples.
+
+    Parameters
+    ==========
+
+    name : String
+        Defines the name of the body. It is used as the base for defining
+        body specific properties.
+    masscenter : Point, optional
+        A point that represents the center of mass of the body or particle.
+        If no point is given, a point is generated.
+    mass : Sympifyable, optional
+        A Sympifyable object which represents the mass of the body. If no
+        mass is passed, one is generated.
+    frame : ReferenceFrame, optional
+        The ReferenceFrame that represents the reference frame of the body.
+        If no frame is given, a frame is generated.
+    central_inertia : Dyadic, optional
+        Central inertia dyadic of the body. If none is passed while creating
+        RigidBody, a default inertia is generated.
+
+    Examples
+    ========
+
+    Default behaviour. This results in the creation of a RigidBody object for
+    which the mass, mass center, frame and inertia attributes are given default
+    values. ::
+
+        >>> from sympy.physics.mechanics import Body
+        >>> body = Body('name_of_body')
+
+    This next example demonstrates the code required to specify all of the
+    values of the Body object. Note this will also create a RigidBody version of
+    the Body object. ::
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.mechanics import ReferenceFrame, Point, inertia
+        >>> from sympy.physics.mechanics import Body
+        >>> mass = Symbol('mass')
+        >>> masscenter = Point('masscenter')
+        >>> frame = ReferenceFrame('frame')
+        >>> ixx = Symbol('ixx')
+        >>> body_inertia = inertia(frame, ixx, 0, 0)
+        >>> body = Body('name_of_body', masscenter, mass, frame, body_inertia)
+
+    The minimal code required to create a Particle version of the Body object
+    involves simply passing in a name and a mass. ::
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.mechanics import Body
+        >>> mass = Symbol('mass')
+        >>> body = Body('name_of_body', mass=mass)
+
+    The Particle version of the Body object can also receive a masscenter point
+    and a reference frame, just not an inertia.
+    """
+
+    def __init__(self, name, masscenter=None, mass=None, frame=None,
+                 central_inertia=None):
+
+        self.name = name
+        self._loads = []
+
+        if frame is None:
+            frame = ReferenceFrame(name + '_frame')
+
+        if masscenter is None:
+            masscenter = Point(name + '_masscenter')
+
+        if central_inertia is None and mass is None:
+            ixx = Symbol(name + '_ixx')
+            iyy = Symbol(name + '_iyy')
+            izz = Symbol(name + '_izz')
+            izx = Symbol(name + '_izx')
+            ixy = Symbol(name + '_ixy')
+            iyz = Symbol(name + '_iyz')
+            _inertia = (inertia(frame, ixx, iyy, izz, ixy, iyz, izx),
+                        masscenter)
+        else:
+            _inertia = (central_inertia, masscenter)
+
+        if mass is None:
+            _mass = Symbol(name + '_mass')
+        else:
+            _mass = mass
+
+        masscenter.set_vel(frame, 0)
+
+        # If user passes masscenter and mass then a particle is created
+        # otherwise a rigidbody. As a result a body may or may not have inertia.
+        if central_inertia is None and mass is not None:
+            self.frame = frame
+            self.masscenter = masscenter
+            Particle.__init__(self, name, masscenter, _mass)
+            self._central_inertia = Dyadic(0)
+        else:
+            RigidBody.__init__(self, name, masscenter, frame, _mass, _inertia)
+
+    @property
+    def loads(self):
+        return self._loads
+
+    @property
+    def x(self):
+        """The basis Vector for the Body, in the x direction."""
+        return self.frame.x
+
+    @property
+    def y(self):
+        """The basis Vector for the Body, in the y direction."""
+        return self.frame.y
+
+    @property
+    def z(self):
+        """The basis Vector for the Body, in the z direction."""
+        return self.frame.z
+
+    @property
+    def inertia(self):
+        """The body's inertia about a point; stored as (Dyadic, Point)."""
+        if self.is_rigidbody:
+            return RigidBody.inertia.fget(self)
+        return (self.central_inertia, self.masscenter)
+
+    @inertia.setter
+    def inertia(self, I):
+        RigidBody.inertia.fset(self, I)
+
+    @property
+    def is_rigidbody(self):
+        if hasattr(self, '_inertia'):
+            return True
+        return False
+
+    def kinetic_energy(self, frame):
+        """Kinetic energy of the body.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame or Body
+            The Body's angular velocity and the velocity of it's mass
+            center are typically defined with respect to an inertial frame but
+            any relevant frame in which the velocities are known can be supplied.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Body, ReferenceFrame, Point
+        >>> from sympy import symbols
+        >>> m, v, r, omega = symbols('m v r omega')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> P = Body('P', masscenter=O, mass=m)
+        >>> P.masscenter.set_vel(N, v * N.y)
+        >>> P.kinetic_energy(N)
+        m*v**2/2
+
+        >>> N = ReferenceFrame('N')
+        >>> b = ReferenceFrame('b')
+        >>> b.set_ang_vel(N, omega * b.x)
+        >>> P = Point('P')
+        >>> P.set_vel(N, v * N.x)
+        >>> B = Body('B', masscenter=P, frame=b)
+        >>> B.kinetic_energy(N)
+        B_ixx*omega**2/2 + B_mass*v**2/2
+
+        See Also
+        ========
+
+        sympy.physics.mechanics : Particle, RigidBody
+
+        """
+        if isinstance(frame, Body):
+            frame = Body.frame
+        if self.is_rigidbody:
+            return RigidBody(self.name, self.masscenter, self.frame, self.mass,
+                            (self.central_inertia, self.masscenter)).kinetic_energy(frame)
+        return Particle(self.name, self.masscenter, self.mass).kinetic_energy(frame)
+
+    def apply_force(self, force, point=None, reaction_body=None, reaction_point=None):
+        """Add force to the body(s).
+
+        Explanation
+        ===========
+
+        Applies the force on self or equal and oppposite forces on
+        self and other body if both are given on the desried point on the bodies.
+        The force applied on other body is taken opposite of self, i.e, -force.
+
+        Parameters
+        ==========
+
+        force: Vector
+            The force to be applied.
+        point: Point, optional
+            The point on self on which force is applied.
+            By default self's masscenter.
+        reaction_body: Body, optional
+            Second body on which equal and opposite force
+            is to be applied.
+        reaction_point : Point, optional
+            The point on other body on which equal and opposite
+            force is applied. By default masscenter of other body.
+
+        Example
+        =======
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import Body, Point, dynamicsymbols
+        >>> m, g = symbols('m g')
+        >>> B = Body('B')
+        >>> force1 = m*g*B.z
+        >>> B.apply_force(force1) #Applying force on B's masscenter
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z)]
+
+        We can also remove some part of force from any point on the body by
+        adding the opposite force to the body on that point.
+
+        >>> f1, f2 = dynamicsymbols('f1 f2')
+        >>> P = Point('P') #Considering point P on body B
+        >>> B.apply_force(f1*B.x + f2*B.y, P)
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z), (P, f1(t)*B_frame.x + f2(t)*B_frame.y)]
+
+        Let's remove f1 from point P on body B.
+
+        >>> B.apply_force(-f1*B.x, P)
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z), (P, f2(t)*B_frame.y)]
+
+        To further demonstrate the use of ``apply_force`` attribute,
+        consider two bodies connected through a spring.
+
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> N = Body('N') #Newtonion Frame
+        >>> x = dynamicsymbols('x')
+        >>> B1 = Body('B1')
+        >>> B2 = Body('B2')
+        >>> spring_force = x*N.x
+
+        Now let's apply equal and opposite spring force to the bodies.
+
+        >>> P1 = Point('P1')
+        >>> P2 = Point('P2')
+        >>> B1.apply_force(spring_force, point=P1, reaction_body=B2, reaction_point=P2)
+
+        We can check the loads(forces) applied to bodies now.
+
+        >>> B1.loads
+        [(P1, x(t)*N_frame.x)]
+        >>> B2.loads
+        [(P2, - x(t)*N_frame.x)]
+
+        Notes
+        =====
+
+        If a new force is applied to a body on a point which already has some
+        force applied on it, then the new force is added to the already applied
+        force on that point.
+
+        """
+
+        if not isinstance(point, Point):
+            if point is None:
+                point = self.masscenter  # masscenter
+            else:
+                raise TypeError("Force must be applied to a point on the body.")
+        if not isinstance(force, Vector):
+            raise TypeError("Force must be a vector.")
+
+        if reaction_body is not None:
+            reaction_body.apply_force(-force, point=reaction_point)
+
+        for load in self._loads:
+            if point in load:
+                force += load[1]
+                self._loads.remove(load)
+                break
+
+        self._loads.append((point, force))
+
+    def apply_torque(self, torque, reaction_body=None):
+        """Add torque to the body(s).
+
+        Explanation
+        ===========
+
+        Applies the torque on self or equal and oppposite torquess on
+        self and other body if both are given.
+        The torque applied on other body is taken opposite of self,
+        i.e, -torque.
+
+        Parameters
+        ==========
+
+        torque: Vector
+            The torque to be applied.
+        reaction_body: Body, optional
+            Second body on which equal and opposite torque
+            is to be applied.
+
+        Example
+        =======
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> t = symbols('t')
+        >>> B = Body('B')
+        >>> torque1 = t*B.z
+        >>> B.apply_torque(torque1)
+        >>> B.loads
+        [(B_frame, t*B_frame.z)]
+
+        We can also remove some part of torque from the body by
+        adding the opposite torque to the body.
+
+        >>> t1, t2 = dynamicsymbols('t1 t2')
+        >>> B.apply_torque(t1*B.x + t2*B.y)
+        >>> B.loads
+        [(B_frame, t1(t)*B_frame.x + t2(t)*B_frame.y + t*B_frame.z)]
+
+        Let's remove t1 from Body B.
+
+        >>> B.apply_torque(-t1*B.x)
+        >>> B.loads
+        [(B_frame, t2(t)*B_frame.y + t*B_frame.z)]
+
+        To further demonstrate the use, let us consider two bodies such that
+        a torque `T` is acting on one body, and `-T` on the other.
+
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> N = Body('N') #Newtonion frame
+        >>> B1 = Body('B1')
+        >>> B2 = Body('B2')
+        >>> v = dynamicsymbols('v')
+        >>> T = v*N.y #Torque
+
+        Now let's apply equal and opposite torque to the bodies.
+
+        >>> B1.apply_torque(T, B2)
+
+        We can check the loads (torques) applied to bodies now.
+
+        >>> B1.loads
+        [(B1_frame, v(t)*N_frame.y)]
+        >>> B2.loads
+        [(B2_frame, - v(t)*N_frame.y)]
+
+        Notes
+        =====
+
+        If a new torque is applied on body which already has some torque applied on it,
+        then the new torque is added to the previous torque about the body's frame.
+
+        """
+
+        if not isinstance(torque, Vector):
+            raise TypeError("A Vector must be supplied to add torque.")
+
+        if reaction_body is not None:
+            reaction_body.apply_torque(-torque)
+
+        for load in self._loads:
+            if self.frame in load:
+                torque += load[1]
+                self._loads.remove(load)
+                break
+        self._loads.append((self.frame, torque))
+
+    def clear_loads(self):
+        """
+        Clears the Body's loads list.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body
+        >>> B = Body('B')
+        >>> force = B.x + B.y
+        >>> B.apply_force(force)
+        >>> B.loads
+        [(B_masscenter, B_frame.x + B_frame.y)]
+        >>> B.clear_loads()
+        >>> B.loads
+        []
+
+        """
+
+        self._loads = []
+
+    def remove_load(self, about=None):
+        """
+        Remove load about a point or frame.
+
+        Parameters
+        ==========
+
+        about : Point or ReferenceFrame, optional
+            The point about which force is applied,
+            and is to be removed.
+            If about is None, then the torque about
+            self's frame is removed.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body, Point
+        >>> B = Body('B')
+        >>> P = Point('P')
+        >>> f1 = B.x
+        >>> f2 = B.y
+        >>> B.apply_force(f1)
+        >>> B.apply_force(f2, P)
+        >>> B.loads
+        [(B_masscenter, B_frame.x), (P, B_frame.y)]
+
+        >>> B.remove_load(P)
+        >>> B.loads
+        [(B_masscenter, B_frame.x)]
+
+        """
+
+        if about is not None:
+            if not isinstance(about, Point):
+                raise TypeError('Load is applied about Point or ReferenceFrame.')
+        else:
+            about = self.frame
+
+        for load in self._loads:
+            if about in load:
+                self._loads.remove(load)
+                break
+
+    def masscenter_vel(self, body):
+        """
+        Returns the velocity of the mass center with respect to the provided
+        rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the velocity in.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body
+        >>> A = Body('A')
+        >>> B = Body('B')
+        >>> A.masscenter.set_vel(B.frame, 5*B.frame.x)
+        >>> A.masscenter_vel(B)
+        5*B_frame.x
+        >>> A.masscenter_vel(B.frame)
+        5*B_frame.x
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.masscenter.vel(frame)
+
+    def ang_vel_in(self, body):
+        """
+        Returns this body's angular velocity with respect to the provided
+        rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the angular velocity in.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body, ReferenceFrame
+        >>> A = Body('A')
+        >>> N = ReferenceFrame('N')
+        >>> B = Body('B', frame=N)
+        >>> A.frame.set_ang_vel(N, 5*N.x)
+        >>> A.ang_vel_in(B)
+        5*N.x
+        >>> A.ang_vel_in(N)
+        5*N.x
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.frame.ang_vel_in(frame)
+
+    def dcm(self, body):
+        """
+        Returns the direction cosine matrix of this body relative to the
+        provided rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the dcm.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body
+        >>> A = Body('A')
+        >>> B = Body('B')
+        >>> A.frame.orient_axis(B.frame, B.frame.x, 5)
+        >>> A.dcm(B)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(5), sin(5)],
+        [0, -sin(5), cos(5)]])
+        >>> A.dcm(B.frame)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(5), sin(5)],
+        [0, -sin(5), cos(5)]])
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.frame.dcm(frame)
+
+    def parallel_axis(self, point, frame=None):
+        """Returns the inertia dyadic of the body with respect to another
+        point.
+
+        Parameters
+        ==========
+
+        point : sympy.physics.vector.Point
+            The point to express the inertia dyadic about.
+        frame : sympy.physics.vector.ReferenceFrame
+            The reference frame used to construct the dyadic.
+
+        Returns
+        =======
+
+        inertia : sympy.physics.vector.Dyadic
+            The inertia dyadic of the rigid body expressed about the provided
+            point.
+
+        Example
+        =======
+
+        >>> from sympy.physics.mechanics import Body
+        >>> A = Body('A')
+        >>> P = A.masscenter.locatenew('point', 3 * A.x + 5 * A.y)
+        >>> A.parallel_axis(P).to_matrix(A.frame)
+        Matrix([
+        [A_ixx + 25*A_mass, A_ixy - 15*A_mass,             A_izx],
+        [A_ixy - 15*A_mass,  A_iyy + 9*A_mass,             A_iyz],
+        [            A_izx,             A_iyz, A_izz + 34*A_mass]])
+
+        """
+        if self.is_rigidbody:
+            return RigidBody.parallel_axis(self, point, frame)
+        return Particle.parallel_axis(self, point, frame)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/functions.py

@@ -0,0 +1,779 @@
+from sympy.utilities import dict_merge
+from sympy.utilities.iterables import iterable
+from sympy.physics.vector import (Dyadic, Vector, ReferenceFrame,
+                                  Point, dynamicsymbols)
+from sympy.physics.vector.printing import (vprint, vsprint, vpprint, vlatex,
+                                           init_vprinting)
+from sympy.physics.mechanics.particle import Particle
+from sympy.physics.mechanics.rigidbody import RigidBody
+from sympy.simplify.simplify import simplify
+from sympy.core.backend import (Matrix, sympify, Mul, Derivative, sin, cos,
+                                tan, AppliedUndef, S)
+
+__all__ = ['inertia',
+           'inertia_of_point_mass',
+           'linear_momentum',
+           'angular_momentum',
+           'kinetic_energy',
+           'potential_energy',
+           'Lagrangian',
+           'mechanics_printing',
+           'mprint',
+           'msprint',
+           'mpprint',
+           'mlatex',
+           'msubs',
+           'find_dynamicsymbols']
+
+# These are functions that we've moved and renamed during extracting the
+# basic vector calculus code from the mechanics packages.
+
+mprint = vprint
+msprint = vsprint
+mpprint = vpprint
+mlatex = vlatex
+
+
+def mechanics_printing(**kwargs):
+    """
+    Initializes time derivative printing for all SymPy objects in
+    mechanics module.
+    """
+
+    init_vprinting(**kwargs)
+
+mechanics_printing.__doc__ = init_vprinting.__doc__
+
+
+def inertia(frame, ixx, iyy, izz, ixy=0, iyz=0, izx=0):
+    """Simple way to create inertia Dyadic object.
+
+    Explanation
+    ===========
+
+    If you do not know what a Dyadic is, just treat this like the inertia
+    tensor. Then, do the easy thing and define it in a body-fixed frame.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame the inertia is defined in
+    ixx : Sympifyable
+        the xx element in the inertia dyadic
+    iyy : Sympifyable
+        the yy element in the inertia dyadic
+    izz : Sympifyable
+        the zz element in the inertia dyadic
+    ixy : Sympifyable
+        the xy element in the inertia dyadic
+    iyz : Sympifyable
+        the yz element in the inertia dyadic
+    izx : Sympifyable
+        the zx element in the inertia dyadic
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import ReferenceFrame, inertia
+    >>> N = ReferenceFrame('N')
+    >>> inertia(N, 1, 2, 3)
+    (N.x|N.x) + 2*(N.y|N.y) + 3*(N.z|N.z)
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Need to define the inertia in a frame')
+    ixx = sympify(ixx)
+    ixy = sympify(ixy)
+    iyy = sympify(iyy)
+    iyz = sympify(iyz)
+    izx = sympify(izx)
+    izz = sympify(izz)
+    ol = ixx * (frame.x | frame.x)
+    ol += ixy * (frame.x | frame.y)
+    ol += izx * (frame.x | frame.z)
+    ol += ixy * (frame.y | frame.x)
+    ol += iyy * (frame.y | frame.y)
+    ol += iyz * (frame.y | frame.z)
+    ol += izx * (frame.z | frame.x)
+    ol += iyz * (frame.z | frame.y)
+    ol += izz * (frame.z | frame.z)
+    return ol
+
+
+def inertia_of_point_mass(mass, pos_vec, frame):
+    """Inertia dyadic of a point mass relative to point O.
+
+    Parameters
+    ==========
+
+    mass : Sympifyable
+        Mass of the point mass
+    pos_vec : Vector
+        Position from point O to point mass
+    frame : ReferenceFrame
+        Reference frame to express the dyadic in
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import ReferenceFrame, inertia_of_point_mass
+    >>> N = ReferenceFrame('N')
+    >>> r, m = symbols('r m')
+    >>> px = r * N.x
+    >>> inertia_of_point_mass(m, px, N)
+    m*r**2*(N.y|N.y) + m*r**2*(N.z|N.z)
+
+    """
+
+    return mass * (((frame.x | frame.x) + (frame.y | frame.y) +
+                   (frame.z | frame.z)) * (pos_vec & pos_vec) -
+                   (pos_vec | pos_vec))
+
+
+def linear_momentum(frame, *body):
+    """Linear momentum of the system.
+
+    Explanation
+    ===========
+
+    This function returns the linear momentum of a system of Particle's and/or
+    RigidBody's. The linear momentum of a system is equal to the vector sum of
+    the linear momentum of its constituents. Consider a system, S, comprised of
+    a rigid body, A, and a particle, P. The linear momentum of the system, L,
+    is equal to the vector sum of the linear momentum of the particle, L1, and
+    the linear momentum of the rigid body, L2, i.e.
+
+    L = L1 + L2
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which linear momentum is desired.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose linear momentum is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, linear_momentum
+    >>> N = ReferenceFrame('N')
+    >>> P = Point('P')
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = Point('Ac')
+    >>> Ac.set_vel(N, 25 * N.y)
+    >>> I = outer(N.x, N.x)
+    >>> A = RigidBody('A', Ac, N, 20, (I, Ac))
+    >>> linear_momentum(N, A, Pa)
+    10*N.x + 500*N.y
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please specify a valid ReferenceFrame')
+    else:
+        linear_momentum_sys = Vector(0)
+        for e in body:
+            if isinstance(e, (RigidBody, Particle)):
+                linear_momentum_sys += e.linear_momentum(frame)
+            else:
+                raise TypeError('*body must have only Particle or RigidBody')
+    return linear_momentum_sys
+
+
+def angular_momentum(point, frame, *body):
+    """Angular momentum of a system.
+
+    Explanation
+    ===========
+
+    This function returns the angular momentum of a system of Particle's and/or
+    RigidBody's. The angular momentum of such a system is equal to the vector
+    sum of the angular momentum of its constituents. Consider a system, S,
+    comprised of a rigid body, A, and a particle, P. The angular momentum of
+    the system, H, is equal to the vector sum of the angular momentum of the
+    particle, H1, and the angular momentum of the rigid body, H2, i.e.
+
+    H = H1 + H2
+
+    Parameters
+    ==========
+
+    point : Point
+        The point about which angular momentum of the system is desired.
+    frame : ReferenceFrame
+        The frame in which angular momentum is desired.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose angular momentum is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, angular_momentum
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> angular_momentum(O, N, Pa, A)
+    10*N.z
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please enter a valid ReferenceFrame')
+    if not isinstance(point, Point):
+        raise TypeError('Please specify a valid Point')
+    else:
+        angular_momentum_sys = Vector(0)
+        for e in body:
+            if isinstance(e, (RigidBody, Particle)):
+                angular_momentum_sys += e.angular_momentum(point, frame)
+            else:
+                raise TypeError('*body must have only Particle or RigidBody')
+    return angular_momentum_sys
+
+
+def kinetic_energy(frame, *body):
+    """Kinetic energy of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the kinetic energy of a system of Particle's and/or
+    RigidBody's. The kinetic energy of such a system is equal to the sum of
+    the kinetic energies of its constituents. Consider a system, S, comprising
+    a rigid body, A, and a particle, P. The kinetic energy of the system, T,
+    is equal to the vector sum of the kinetic energy of the particle, T1, and
+    the kinetic energy of the rigid body, T2, i.e.
+
+    T = T1 + T2
+
+    Kinetic energy is a scalar.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which the velocity or angular velocity of the body is
+        defined.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose kinetic energy is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, kinetic_energy
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> kinetic_energy(N, Pa, A)
+    350
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please enter a valid ReferenceFrame')
+    ke_sys = S.Zero
+    for e in body:
+        if isinstance(e, (RigidBody, Particle)):
+            ke_sys += e.kinetic_energy(frame)
+        else:
+            raise TypeError('*body must have only Particle or RigidBody')
+    return ke_sys
+
+
+def potential_energy(*body):
+    """Potential energy of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the potential energy of a system of Particle's and/or
+    RigidBody's. The potential energy of such a system is equal to the sum of
+    the potential energy of its constituents. Consider a system, S, comprising
+    a rigid body, A, and a particle, P. The potential energy of the system, V,
+    is equal to the vector sum of the potential energy of the particle, V1, and
+    the potential energy of the rigid body, V2, i.e.
+
+    V = V1 + V2
+
+    Potential energy is a scalar.
+
+    Parameters
+    ==========
+
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose potential energy is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, potential_energy
+    >>> from sympy import symbols
+    >>> M, m, g, h = symbols('M m g h')
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> Pa = Particle('Pa', P, m)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, M, (I, Ac))
+    >>> Pa.potential_energy = m * g * h
+    >>> A.potential_energy = M * g * h
+    >>> potential_energy(Pa, A)
+    M*g*h + g*h*m
+
+    """
+
+    pe_sys = S.Zero
+    for e in body:
+        if isinstance(e, (RigidBody, Particle)):
+            pe_sys += e.potential_energy
+        else:
+            raise TypeError('*body must have only Particle or RigidBody')
+    return pe_sys
+
+
+def gravity(acceleration, *bodies):
+    """
+    Returns a list of gravity forces given the acceleration
+    due to gravity and any number of particles or rigidbodies.
+
+    Example
+    =======
+
+    >>> from sympy.physics.mechanics import ReferenceFrame, Point, Particle, outer, RigidBody
+    >>> from sympy.physics.mechanics.functions import gravity
+    >>> from sympy import symbols
+    >>> N = ReferenceFrame('N')
+    >>> m, M, g = symbols('m M g')
+    >>> F1, F2 = symbols('F1 F2')
+    >>> po = Point('po')
+    >>> pa = Particle('pa', po, m)
+    >>> A = ReferenceFrame('A')
+    >>> P = Point('P')
+    >>> I = outer(A.x, A.x)
+    >>> B = RigidBody('B', P, A, M, (I, P))
+    >>> forceList = [(po, F1), (P, F2)]
+    >>> forceList.extend(gravity(g*N.y, pa, B))
+    >>> forceList
+    [(po, F1), (P, F2), (po, g*m*N.y), (P, M*g*N.y)]
+
+    """
+
+    gravity_force = []
+    if not bodies:
+        raise TypeError("No bodies(instances of Particle or Rigidbody) were passed.")
+
+    for e in bodies:
+        point = getattr(e, 'masscenter', None)
+        if point is None:
+            point = e.point
+
+        gravity_force.append((point, e.mass*acceleration))
+
+    return gravity_force
+
+
+def center_of_mass(point, *bodies):
+    """
+    Returns the position vector from the given point to the center of mass
+    of the given bodies(particles or rigidbodies).
+
+    Example
+    =======
+
+    >>> from sympy import symbols, S
+    >>> from sympy.physics.vector import Point
+    >>> from sympy.physics.mechanics import Particle, ReferenceFrame, RigidBody, outer
+    >>> from sympy.physics.mechanics.functions import center_of_mass
+    >>> a = ReferenceFrame('a')
+    >>> m = symbols('m', real=True)
+    >>> p1 = Particle('p1', Point('p1_pt'), S(1))
+    >>> p2 = Particle('p2', Point('p2_pt'), S(2))
+    >>> p3 = Particle('p3', Point('p3_pt'), S(3))
+    >>> p4 = Particle('p4', Point('p4_pt'), m)
+    >>> b_f = ReferenceFrame('b_f')
+    >>> b_cm = Point('b_cm')
+    >>> mb = symbols('mb')
+    >>> b = RigidBody('b', b_cm, b_f, mb, (outer(b_f.x, b_f.x), b_cm))
+    >>> p2.point.set_pos(p1.point, a.x)
+    >>> p3.point.set_pos(p1.point, a.x + a.y)
+    >>> p4.point.set_pos(p1.point, a.y)
+    >>> b.masscenter.set_pos(p1.point, a.y + a.z)
+    >>> point_o=Point('o')
+    >>> point_o.set_pos(p1.point, center_of_mass(p1.point, p1, p2, p3, p4, b))
+    >>> expr = 5/(m + mb + 6)*a.x + (m + mb + 3)/(m + mb + 6)*a.y + mb/(m + mb + 6)*a.z
+    >>> point_o.pos_from(p1.point)
+    5/(m + mb + 6)*a.x + (m + mb + 3)/(m + mb + 6)*a.y + mb/(m + mb + 6)*a.z
+
+    """
+    if not bodies:
+        raise TypeError("No bodies(instances of Particle or Rigidbody) were passed.")
+
+    total_mass = 0
+    vec = Vector(0)
+    for i in bodies:
+        total_mass += i.mass
+
+        masscenter = getattr(i, 'masscenter', None)
+        if masscenter is None:
+            masscenter = i.point
+        vec += i.mass*masscenter.pos_from(point)
+
+    return vec/total_mass
+
+
+def Lagrangian(frame, *body):
+    """Lagrangian of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the Lagrangian of a system of Particle's and/or
+    RigidBody's. The Lagrangian of such a system is equal to the difference
+    between the kinetic energies and potential energies of its constituents. If
+    T and V are the kinetic and potential energies of a system then it's
+    Lagrangian, L, is defined as
+
+    L = T - V
+
+    The Lagrangian is a scalar.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which the velocity or angular velocity of the body is
+        defined to determine the kinetic energy.
+
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose Lagrangian is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, Lagrangian
+    >>> from sympy import symbols
+    >>> M, m, g, h = symbols('M m g h')
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> Pa.potential_energy = m * g * h
+    >>> A.potential_energy = M * g * h
+    >>> Lagrangian(N, Pa, A)
+    -M*g*h - g*h*m + 350
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please supply a valid ReferenceFrame')
+    for e in body:
+        if not isinstance(e, (RigidBody, Particle)):
+            raise TypeError('*body must have only Particle or RigidBody')
+    return kinetic_energy(frame, *body) - potential_energy(*body)
+
+
+def find_dynamicsymbols(expression, exclude=None, reference_frame=None):
+    """Find all dynamicsymbols in expression.
+
+    Explanation
+    ===========
+
+    If the optional ``exclude`` kwarg is used, only dynamicsymbols
+    not in the iterable ``exclude`` are returned.
+    If we intend to apply this function on a vector, the optional
+    ``reference_frame`` is also used to inform about the corresponding frame
+    with respect to which the dynamic symbols of the given vector is to be
+    determined.
+
+    Parameters
+    ==========
+
+    expression : SymPy expression
+
+    exclude : iterable of dynamicsymbols, optional
+
+    reference_frame : ReferenceFrame, optional
+        The frame with respect to which the dynamic symbols of the
+        given vector is to be determined.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import dynamicsymbols, find_dynamicsymbols
+    >>> from sympy.physics.mechanics import ReferenceFrame
+    >>> x, y = dynamicsymbols('x, y')
+    >>> expr = x + x.diff()*y
+    >>> find_dynamicsymbols(expr)
+    {x(t), y(t), Derivative(x(t), t)}
+    >>> find_dynamicsymbols(expr, exclude=[x, y])
+    {Derivative(x(t), t)}
+    >>> a, b, c = dynamicsymbols('a, b, c')
+    >>> A = ReferenceFrame('A')
+    >>> v = a * A.x + b * A.y + c * A.z
+    >>> find_dynamicsymbols(v, reference_frame=A)
+    {a(t), b(t), c(t)}
+
+    """
+    t_set = {dynamicsymbols._t}
+    if exclude:
+        if iterable(exclude):
+            exclude_set = set(exclude)
+        else:
+            raise TypeError("exclude kwarg must be iterable")
+    else:
+        exclude_set = set()
+    if isinstance(expression, Vector):
+        if reference_frame is None:
+            raise ValueError("You must provide reference_frame when passing a "
+                             "vector expression, got %s." % reference_frame)
+        else:
+            expression = expression.to_matrix(reference_frame)
+    return {i for i in expression.atoms(AppliedUndef, Derivative) if
+            i.free_symbols == t_set} - exclude_set
+
+
+def msubs(expr, *sub_dicts, smart=False, **kwargs):
+    """A custom subs for use on expressions derived in physics.mechanics.
+
+    Traverses the expression tree once, performing the subs found in sub_dicts.
+    Terms inside ``Derivative`` expressions are ignored:
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import dynamicsymbols, msubs
+    >>> x = dynamicsymbols('x')
+    >>> msubs(x.diff() + x, {x: 1})
+    Derivative(x(t), t) + 1
+
+    Note that sub_dicts can be a single dictionary, or several dictionaries:
+
+    >>> x, y, z = dynamicsymbols('x, y, z')
+    >>> sub1 = {x: 1, y: 2}
+    >>> sub2 = {z: 3, x.diff(): 4}
+    >>> msubs(x.diff() + x + y + z, sub1, sub2)
+    10
+
+    If smart=True (default False), also checks for conditions that may result
+    in ``nan``, but if simplified would yield a valid expression. For example:
+
+    >>> from sympy import sin, tan
+    >>> (sin(x)/tan(x)).subs(x, 0)
+    nan
+    >>> msubs(sin(x)/tan(x), {x: 0}, smart=True)
+    1
+
+    It does this by first replacing all ``tan`` with ``sin/cos``. Then each
+    node is traversed. If the node is a fraction, subs is first evaluated on
+    the denominator. If this results in 0, simplification of the entire
+    fraction is attempted. Using this selective simplification, only
+    subexpressions that result in 1/0 are targeted, resulting in faster
+    performance.
+
+    """
+
+    sub_dict = dict_merge(*sub_dicts)
+    if smart:
+        func = _smart_subs
+    elif hasattr(expr, 'msubs'):
+        return expr.msubs(sub_dict)
+    else:
+        func = lambda expr, sub_dict: _crawl(expr, _sub_func, sub_dict)
+    if isinstance(expr, (Matrix, Vector, Dyadic)):
+        return expr.applyfunc(lambda x: func(x, sub_dict))
+    else:
+        return func(expr, sub_dict)
+
+
+def _crawl(expr, func, *args, **kwargs):
+    """Crawl the expression tree, and apply func to every node."""
+    val = func(expr, *args, **kwargs)
+    if val is not None:
+        return val
+    new_args = (_crawl(arg, func, *args, **kwargs) for arg in expr.args)
+    return expr.func(*new_args)
+
+
+def _sub_func(expr, sub_dict):
+    """Perform direct matching substitution, ignoring derivatives."""
+    if expr in sub_dict:
+        return sub_dict[expr]
+    elif not expr.args or expr.is_Derivative:
+        return expr
+
+
+def _tan_repl_func(expr):
+    """Replace tan with sin/cos."""
+    if isinstance(expr, tan):
+        return sin(*expr.args) / cos(*expr.args)
+    elif not expr.args or expr.is_Derivative:
+        return expr
+
+
+def _smart_subs(expr, sub_dict):
+    """Performs subs, checking for conditions that may result in `nan` or
+    `oo`, and attempts to simplify them out.
+
+    The expression tree is traversed twice, and the following steps are
+    performed on each expression node:
+    - First traverse:
+        Replace all `tan` with `sin/cos`.
+    - Second traverse:
+        If node is a fraction, check if the denominator evaluates to 0.
+        If so, attempt to simplify it out. Then if node is in sub_dict,
+        sub in the corresponding value.
+
+    """
+    expr = _crawl(expr, _tan_repl_func)
+
+    def _recurser(expr, sub_dict):
+        # Decompose the expression into num, den
+        num, den = _fraction_decomp(expr)
+        if den != 1:
+            # If there is a non trivial denominator, we need to handle it
+            denom_subbed = _recurser(den, sub_dict)
+            if denom_subbed.evalf() == 0:
+                # If denom is 0 after this, attempt to simplify the bad expr
+                expr = simplify(expr)
+            else:
+                # Expression won't result in nan, find numerator
+                num_subbed = _recurser(num, sub_dict)
+                return num_subbed / denom_subbed
+        # We have to crawl the tree manually, because `expr` may have been
+        # modified in the simplify step. First, perform subs as normal:
+        val = _sub_func(expr, sub_dict)
+        if val is not None:
+            return val
+        new_args = (_recurser(arg, sub_dict) for arg in expr.args)
+        return expr.func(*new_args)
+    return _recurser(expr, sub_dict)
+
+
+def _fraction_decomp(expr):
+    """Return num, den such that expr = num/den."""
+    if not isinstance(expr, Mul):
+        return expr, 1
+    num = []
+    den = []
+    for a in expr.args:
+        if a.is_Pow and a.args[1] < 0:
+            den.append(1 / a)
+        else:
+            num.append(a)
+    if not den:
+        return expr, 1
+    num = Mul(*num)
+    den = Mul(*den)
+    return num, den
+
+
+def _f_list_parser(fl, ref_frame):
+    """Parses the provided forcelist composed of items
+    of the form (obj, force).
+    Returns a tuple containing:
+        vel_list: The velocity (ang_vel for Frames, vel for Points) in
+                the provided reference frame.
+        f_list: The forces.
+
+    Used internally in the KanesMethod and LagrangesMethod classes.
+
+    """
+    def flist_iter():
+        for pair in fl:
+            obj, force = pair
+            if isinstance(obj, ReferenceFrame):
+                yield obj.ang_vel_in(ref_frame), force
+            elif isinstance(obj, Point):
+                yield obj.vel(ref_frame), force
+            else:
+                raise TypeError('First entry in each forcelist pair must '
+                                'be a point or frame.')
+
+    if not fl:
+        vel_list, f_list = (), ()
+    else:
+        unzip = lambda l: list(zip(*l)) if l[0] else [(), ()]
+        vel_list, f_list = unzip(list(flist_iter()))
+    return vel_list, f_list
+
+
+def _validate_coordinates(coordinates=None, speeds=None, check_duplicates=True,
+                          is_dynamicsymbols=True):
+    t_set = {dynamicsymbols._t}
+    # Convert input to iterables
+    if coordinates is None:
+        coordinates = []
+    elif not iterable(coordinates):
+        coordinates = [coordinates]
+    if speeds is None:
+        speeds = []
+    elif not iterable(speeds):
+        speeds = [speeds]
+
+    if check_duplicates:  # Check for duplicates
+        seen = set()
+        coord_duplicates = {x for x in coordinates if x in seen or seen.add(x)}
+        seen = set()
+        speed_duplicates = {x for x in speeds if x in seen or seen.add(x)}
+        overlap = set(coordinates).intersection(speeds)
+        if coord_duplicates:
+            raise ValueError(f'The generalized coordinates {coord_duplicates} '
+                             f'are duplicated, all generalized coordinates '
+                             f'should be unique.')
+        if speed_duplicates:
+            raise ValueError(f'The generalized speeds {speed_duplicates} are '
+                             f'duplicated, all generalized speeds should be '
+                             f'unique.')
+        if overlap:
+            raise ValueError(f'{overlap} are defined as both generalized '
+                             f'coordinates and generalized speeds.')
+    if is_dynamicsymbols:  # Check whether all coordinates are dynamicsymbols
+        for coordinate in coordinates:
+            if not (isinstance(coordinate, (AppliedUndef, Derivative)) and
+                    coordinate.free_symbols == t_set):
+                raise ValueError(f'Generalized coordinate "{coordinate}" is not'
+                                 f' a dynamicsymbol.')
+        for speed in speeds:
+            if not (isinstance(speed, (AppliedUndef, Derivative)) and
+                    speed.free_symbols == t_set):
+                raise ValueError(f'Generalized speed "{speed}" is not a '
+                                 f'dynamicsymbol.')

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/joint.py

@@ -0,0 +1,2163 @@
+# coding=utf-8
+
+from abc import ABC, abstractmethod
+
+from sympy.core.backend import pi, AppliedUndef, Derivative, Matrix
+from sympy.physics.mechanics.body import Body
+from sympy.physics.mechanics.functions import _validate_coordinates
+from sympy.physics.vector import (Vector, dynamicsymbols, cross, Point,
+                                  ReferenceFrame)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['Joint', 'PinJoint', 'PrismaticJoint', 'CylindricalJoint',
+           'PlanarJoint', 'SphericalJoint', 'WeldJoint']
+
+
+class Joint(ABC):
+    """Abstract base class for all specific joints.
+
+    Explanation
+    ===========
+
+    A joint subtracts degrees of freedom from a body. This is the base class
+    for all specific joints and holds all common methods acting as an interface
+    for all joints. Custom joint can be created by inheriting Joint class and
+    defining all abstract functions.
+
+    The abstract methods are:
+
+    - ``_generate_coordinates``
+    - ``_generate_speeds``
+    - ``_orient_frames``
+    - ``_set_angular_velocity``
+    - ``_set_linear_velocity``
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    coordinates : iterable of dynamicsymbols, optional
+        Generalized coordinates of the joint.
+    speeds : iterable of dynamicsymbols, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Notes
+    =====
+
+    When providing a vector as the intermediate frame, a new intermediate frame
+    is created which aligns its X axis with the provided vector. This is done
+    with a single fixed rotation about a rotation axis. This rotation axis is
+    determined by taking the cross product of the ``body.x`` axis with the
+    provided vector. In the case where the provided vector is in the ``-body.x``
+    direction, the rotation is done about the ``body.y`` axis.
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_axis=None,
+                 child_axis=None, parent_interframe=None, child_interframe=None,
+                 parent_joint_pos=None, child_joint_pos=None):
+
+        if not isinstance(name, str):
+            raise TypeError('Supply a valid name.')
+        self._name = name
+
+        if not isinstance(parent, Body):
+            raise TypeError('Parent must be an instance of Body.')
+        self._parent = parent
+
+        if not isinstance(child, Body):
+            raise TypeError('Parent must be an instance of Body.')
+        self._child = child
+
+        self._coordinates = self._generate_coordinates(coordinates)
+        self._speeds = self._generate_speeds(speeds)
+        _validate_coordinates(self.coordinates, self.speeds)
+        self._kdes = self._generate_kdes()
+
+        self._parent_axis = self._axis(parent_axis, parent.frame)
+        self._child_axis = self._axis(child_axis, child.frame)
+
+        if parent_joint_pos is not None or child_joint_pos is not None:
+            sympy_deprecation_warning(
+                """
+                The parent_joint_pos and child_joint_pos arguments for the Joint
+                classes are deprecated. Instead use parent_point and child_point.
+                """,
+                deprecated_since_version="1.12",
+                active_deprecations_target="deprecated-mechanics-joint-pos",
+                stacklevel=4
+            )
+            if parent_point is None:
+                parent_point = parent_joint_pos
+            if child_point is None:
+                child_point = child_joint_pos
+        self._parent_point = self._locate_joint_pos(parent, parent_point)
+        self._child_point = self._locate_joint_pos(child, child_point)
+        if parent_axis is not None or child_axis is not None:
+            sympy_deprecation_warning(
+                """
+                The parent_axis and child_axis arguments for the Joint classes
+                are deprecated. Instead use parent_interframe, child_interframe.
+                """,
+                deprecated_since_version="1.12",
+                active_deprecations_target="deprecated-mechanics-joint-axis",
+                stacklevel=4
+            )
+            if parent_interframe is None:
+                parent_interframe = parent_axis
+            if child_interframe is None:
+                child_interframe = child_axis
+        self._parent_interframe = self._locate_joint_frame(parent,
+                                                           parent_interframe)
+        self._child_interframe = self._locate_joint_frame(child,
+                                                          child_interframe)
+
+        self._orient_frames()
+        self._set_angular_velocity()
+        self._set_linear_velocity()
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def name(self):
+        """Name of the joint."""
+        return self._name
+
+    @property
+    def parent(self):
+        """Parent body of Joint."""
+        return self._parent
+
+    @property
+    def child(self):
+        """Child body of Joint."""
+        return self._child
+
+    @property
+    def coordinates(self):
+        """Matrix of the joint's generalized coordinates."""
+        return self._coordinates
+
+    @property
+    def speeds(self):
+        """Matrix of the joint's generalized speeds."""
+        return self._speeds
+
+    @property
+    def kdes(self):
+        """Kinematical differential equations of the joint."""
+        return self._kdes
+
+    @property
+    def parent_axis(self):
+        """The axis of parent frame."""
+        # Will be removed with `deprecated-mechanics-joint-axis`
+        return self._parent_axis
+
+    @property
+    def child_axis(self):
+        """The axis of child frame."""
+        # Will be removed with `deprecated-mechanics-joint-axis`
+        return self._child_axis
+
+    @property
+    def parent_point(self):
+        """Attachment point where the joint is fixed to the parent body."""
+        return self._parent_point
+
+    @property
+    def child_point(self):
+        """Attachment point where the joint is fixed to the child body."""
+        return self._child_point
+
+    @property
+    def parent_interframe(self):
+        return self._parent_interframe
+
+    @property
+    def child_interframe(self):
+        return self._child_interframe
+
+    @abstractmethod
+    def _generate_coordinates(self, coordinates):
+        """Generate Matrix of the joint's generalized coordinates."""
+        pass
+
+    @abstractmethod
+    def _generate_speeds(self, speeds):
+        """Generate Matrix of the joint's generalized speeds."""
+        pass
+
+    @abstractmethod
+    def _orient_frames(self):
+        """Orient frames as per the joint."""
+        pass
+
+    @abstractmethod
+    def _set_angular_velocity(self):
+        """Set angular velocity of the joint related frames."""
+        pass
+
+    @abstractmethod
+    def _set_linear_velocity(self):
+        """Set velocity of related points to the joint."""
+        pass
+
+    @staticmethod
+    def _to_vector(matrix, frame):
+        """Converts a matrix to a vector in the given frame."""
+        return Vector([(matrix, frame)])
+
+    @staticmethod
+    def _axis(ax, *frames):
+        """Check whether an axis is fixed in one of the frames."""
+        if ax is None:
+            ax = frames[0].x
+            return ax
+        if not isinstance(ax, Vector):
+            raise TypeError("Axis must be a Vector.")
+        ref_frame = None  # Find a body in which the axis can be expressed
+        for frame in frames:
+            try:
+                ax.to_matrix(frame)
+            except ValueError:
+                pass
+            else:
+                ref_frame = frame
+                break
+        if ref_frame is None:
+            raise ValueError("Axis cannot be expressed in one of the body's "
+                             "frames.")
+        if not ax.dt(ref_frame) == 0:
+            raise ValueError('Axis cannot be time-varying when viewed from the '
+                             'associated body.')
+        return ax
+
+    @staticmethod
+    def _choose_rotation_axis(frame, axis):
+        components = axis.to_matrix(frame)
+        x, y, z = components[0], components[1], components[2]
+
+        if x != 0:
+            if y != 0:
+                if z != 0:
+                    return cross(axis, frame.x)
+            if z != 0:
+                return frame.y
+            return frame.z
+        else:
+            if y != 0:
+                return frame.x
+            return frame.y
+
+    @staticmethod
+    def _create_aligned_interframe(frame, align_axis, frame_axis=None,
+                                   frame_name=None):
+        """
+        Returns an intermediate frame, where the ``frame_axis`` defined in
+        ``frame`` is aligned with ``axis``. By default this means that the X
+        axis will be aligned with ``axis``.
+
+        Parameters
+        ==========
+
+        frame : Body or ReferenceFrame
+            The body or reference frame with respect to which the intermediate
+            frame is oriented.
+        align_axis : Vector
+            The vector with respect to which the intermediate frame will be
+            aligned.
+        frame_axis : Vector
+            The vector of the frame which should get aligned with ``axis``. The
+            default is the X axis of the frame.
+        frame_name : string
+            Name of the to be created intermediate frame. The default adds
+            "_int_frame" to the name of ``frame``.
+
+        Example
+        =======
+
+        An intermediate frame, where the X axis of the parent becomes aligned
+        with ``parent.y + parent.z`` can be created as follows:
+
+        >>> from sympy.physics.mechanics.joint import Joint
+        >>> from sympy.physics.mechanics import Body
+        >>> parent = Body('parent')
+        >>> parent_interframe = Joint._create_aligned_interframe(
+        ...     parent, parent.y + parent.z)
+        >>> parent_interframe
+        parent_int_frame
+        >>> parent.dcm(parent_interframe)
+        Matrix([
+        [        0, -sqrt(2)/2, -sqrt(2)/2],
+        [sqrt(2)/2,        1/2,       -1/2],
+        [sqrt(2)/2,       -1/2,        1/2]])
+        >>> (parent.y + parent.z).express(parent_interframe)
+        sqrt(2)*parent_int_frame.x
+
+        Notes
+        =====
+
+        The direction cosine matrix between the given frame and intermediate
+        frame is formed using a simple rotation about an axis that is normal to
+        both ``align_axis`` and ``frame_axis``. In general, the normal axis is
+        formed by crossing the ``frame_axis`` with the ``align_axis``. The
+        exception is if the axes are parallel with opposite directions, in which
+        case the rotation vector is chosen using the rules in the following
+        table with the vectors expressed in the given frame:
+
+        .. list-table::
+           :header-rows: 1
+
+           * - ``align_axis``
+             - ``frame_axis``
+             - ``rotation_axis``
+           * - ``-x``
+             - ``x``
+             - ``z``
+           * - ``-y``
+             - ``y``
+             - ``x``
+           * - ``-z``
+             - ``z``
+             - ``y``
+           * - ``-x-y``
+             - ``x+y``
+             - ``z``
+           * - ``-y-z``
+             - ``y+z``
+             - ``x``
+           * - ``-x-z``
+             - ``x+z``
+             - ``y``
+           * - ``-x-y-z``
+             - ``x+y+z``
+             - ``(x+y+z) × x``
+
+        """
+        if isinstance(frame, Body):
+            frame = frame.frame
+        if frame_axis is None:
+            frame_axis = frame.x
+        if frame_name is None:
+            if frame.name[-6:] == '_frame':
+                frame_name = f'{frame.name[:-6]}_int_frame'
+            else:
+                frame_name = f'{frame.name}_int_frame'
+        angle = frame_axis.angle_between(align_axis)
+        rotation_axis = cross(frame_axis, align_axis)
+        if rotation_axis == Vector(0) and angle == 0:
+            return frame
+        if angle == pi:
+            rotation_axis = Joint._choose_rotation_axis(frame, align_axis)
+
+        int_frame = ReferenceFrame(frame_name)
+        int_frame.orient_axis(frame, rotation_axis, angle)
+        int_frame.set_ang_vel(frame, 0 * rotation_axis)
+        return int_frame
+
+    def _generate_kdes(self):
+        """Generate kinematical differential equations."""
+        kdes = []
+        t = dynamicsymbols._t
+        for i in range(len(self.coordinates)):
+            kdes.append(-self.coordinates[i].diff(t) + self.speeds[i])
+        return Matrix(kdes)
+
+    def _locate_joint_pos(self, body, joint_pos):
+        """Returns the attachment point of a body."""
+        if joint_pos is None:
+            return body.masscenter
+        if not isinstance(joint_pos, (Point, Vector)):
+            raise TypeError('Attachment point must be a Point or Vector.')
+        if isinstance(joint_pos, Vector):
+            point_name = f'{self.name}_{body.name}_joint'
+            joint_pos = body.masscenter.locatenew(point_name, joint_pos)
+        if not joint_pos.pos_from(body.masscenter).dt(body.frame) == 0:
+            raise ValueError('Attachment point must be fixed to the associated '
+                             'body.')
+        return joint_pos
+
+    def _locate_joint_frame(self, body, interframe):
+        """Returns the attachment frame of a body."""
+        if interframe is None:
+            return body.frame
+        if isinstance(interframe, Vector):
+            interframe = Joint._create_aligned_interframe(
+                body, interframe,
+                frame_name=f'{self.name}_{body.name}_int_frame')
+        elif not isinstance(interframe, ReferenceFrame):
+            raise TypeError('Interframe must be a ReferenceFrame.')
+        if not interframe.ang_vel_in(body.frame) == 0:
+            raise ValueError(f'Interframe {interframe} is not fixed to body '
+                             f'{body}.')
+        body.masscenter.set_vel(interframe, 0)  # Fixate interframe to body
+        return interframe
+
+    def _fill_coordinate_list(self, coordinates, n_coords, label='q', offset=0,
+                              number_single=False):
+        """Helper method for _generate_coordinates and _generate_speeds.
+
+        Parameters
+        ==========
+
+        coordinates : iterable
+            Iterable of coordinates or speeds that have been provided.
+        n_coords : Integer
+            Number of coordinates that should be returned.
+        label : String, optional
+            Coordinate type either 'q' (coordinates) or 'u' (speeds). The
+            Default is 'q'.
+        offset : Integer
+            Count offset when creating new dynamicsymbols. The default is 0.
+        number_single : Boolean
+            Boolean whether if n_coords == 1, number should still be used. The
+            default is False.
+
+        """
+
+        def create_symbol(number):
+            if n_coords == 1 and not number_single:
+                return dynamicsymbols(f'{label}_{self.name}')
+            return dynamicsymbols(f'{label}{number}_{self.name}')
+
+        name = 'generalized coordinate' if label == 'q' else 'generalized speed'
+        generated_coordinates = []
+        if coordinates is None:
+            coordinates = []
+        elif not iterable(coordinates):
+            coordinates = [coordinates]
+        if not (len(coordinates) == 0 or len(coordinates) == n_coords):
+            raise ValueError(f'Expected {n_coords} {name}s, instead got '
+                             f'{len(coordinates)} {name}s.')
+        # Supports more iterables, also Matrix
+        for i, coord in enumerate(coordinates):
+            if coord is None:
+                generated_coordinates.append(create_symbol(i + offset))
+            elif isinstance(coord, (AppliedUndef, Derivative)):
+                generated_coordinates.append(coord)
+            else:
+                raise TypeError(f'The {name} {coord} should have been a '
+                                f'dynamicsymbol.')
+        for i in range(len(coordinates) + offset, n_coords + offset):
+            generated_coordinates.append(create_symbol(i))
+        return Matrix(generated_coordinates)
+
+
+class PinJoint(Joint):
+    """Pin (Revolute) Joint.
+
+    .. image:: PinJoint.svg
+
+    Explanation
+    ===========
+
+    A pin joint is defined such that the joint rotation axis is fixed in both
+    the child and parent and the location of the joint is relative to the mass
+    center of each body. The child rotates an angle, θ, from the parent about
+    the rotation axis and has a simple angular speed, ω, relative to the
+    parent. The direction cosine matrix between the child interframe and
+    parent interframe is formed using a simple rotation about the joint axis.
+    The page on the joints framework gives a more detailed explanation of the
+    intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    coordinates : dynamicsymbol, optional
+        Generalized coordinates of the joint.
+    speeds : dynamicsymbol, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector
+        The axis about which the rotation occurs. Note that the components
+        of this axis are the same in the parent_interframe and child_interframe.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    joint_axis : Vector
+        The axis about which the rotation occurs. Note that the components of
+        this axis are the same in the parent_interframe and child_interframe.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single pin joint is created from two bodies and has the following basic
+    attributes:
+
+    >>> from sympy.physics.mechanics import Body, PinJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = PinJoint('PC', parent, child)
+    >>> joint
+    PinJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([[q_PC(t)]])
+    >>> joint.speeds
+    Matrix([[u_PC(t)]])
+    >>> joint.child.frame.ang_vel_in(joint.parent.frame)
+    u_PC(t)*P_frame.x
+    >>> joint.child.frame.dcm(joint.parent.frame)
+    Matrix([
+    [1,             0,            0],
+    [0,  cos(q_PC(t)), sin(q_PC(t))],
+    [0, -sin(q_PC(t)), cos(q_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the pin joint, the kinematics of simple
+    double pendulum that rotates about the Z axis of each connected body can be
+    created as follows.
+
+    >>> from sympy import symbols, trigsimp
+    >>> from sympy.physics.mechanics import Body, PinJoint
+    >>> l1, l2 = symbols('l1 l2')
+
+    First create bodies to represent the fixed ceiling and one to represent
+    each pendulum bob.
+
+    >>> ceiling = Body('C')
+    >>> upper_bob = Body('U')
+    >>> lower_bob = Body('L')
+
+    The first joint will connect the upper bob to the ceiling by a distance of
+    ``l1`` and the joint axis will be about the Z axis for each body.
+
+    >>> ceiling_joint = PinJoint('P1', ceiling, upper_bob,
+    ... child_point=-l1*upper_bob.frame.x,
+    ... joint_axis=ceiling.frame.z)
+
+    The second joint will connect the lower bob to the upper bob by a distance
+    of ``l2`` and the joint axis will also be about the Z axis for each body.
+
+    >>> pendulum_joint = PinJoint('P2', upper_bob, lower_bob,
+    ... child_point=-l2*lower_bob.frame.x,
+    ... joint_axis=upper_bob.frame.z)
+
+    Once the joints are established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of pendulum link relative
+    to the ceiling are found:
+
+    >>> upper_bob.frame.dcm(ceiling.frame)
+    Matrix([
+    [ cos(q_P1(t)), sin(q_P1(t)), 0],
+    [-sin(q_P1(t)), cos(q_P1(t)), 0],
+    [            0,            0, 1]])
+    >>> trigsimp(lower_bob.frame.dcm(ceiling.frame))
+    Matrix([
+    [ cos(q_P1(t) + q_P2(t)), sin(q_P1(t) + q_P2(t)), 0],
+    [-sin(q_P1(t) + q_P2(t)), cos(q_P1(t) + q_P2(t)), 0],
+    [                      0,                      0, 1]])
+
+    The position of the lower bob's masscenter is found with:
+
+    >>> lower_bob.masscenter.pos_from(ceiling.masscenter)
+    l1*U_frame.x + l2*L_frame.x
+
+    The angular velocities of the two pendulum links can be computed with
+    respect to the ceiling.
+
+    >>> upper_bob.frame.ang_vel_in(ceiling.frame)
+    u_P1(t)*C_frame.z
+    >>> lower_bob.frame.ang_vel_in(ceiling.frame)
+    u_P1(t)*C_frame.z + u_P2(t)*U_frame.z
+
+    And finally, the linear velocities of the two pendulum bobs can be computed
+    with respect to the ceiling.
+
+    >>> upper_bob.masscenter.vel(ceiling.frame)
+    l1*u_P1(t)*U_frame.y
+    >>> lower_bob.masscenter.vel(ceiling.frame)
+    l1*u_P1(t)*U_frame.y + l2*(u_P1(t) + u_P2(t))*L_frame.y
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_axis=None,
+                 child_axis=None, parent_interframe=None, child_interframe=None,
+                 joint_axis=None, parent_joint_pos=None, child_joint_pos=None):
+
+        self._joint_axis = joint_axis
+        super().__init__(name, parent, child, coordinates, speeds, parent_point,
+                         child_point, parent_axis, child_axis,
+                         parent_interframe, child_interframe, parent_joint_pos,
+                         child_joint_pos)
+
+    def __str__(self):
+        return (f'PinJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis about which the child rotates with respect to the parent."""
+        return self._joint_axis
+
+    def _generate_coordinates(self, coordinate):
+        return self._fill_coordinate_list(coordinate, 1, 'q')
+
+    def _generate_speeds(self, speed):
+        return self._fill_coordinate_list(speed, 1, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, self.coordinates[0])
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, self.speeds[
+            0] * self.joint_axis.normalize())
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self.parent.frame, 0)
+        self.child_point.set_vel(self.child.frame, 0)
+        self.child.masscenter.v2pt_theory(self.parent_point,
+                                          self.parent.frame, self.child.frame)
+
+
+class PrismaticJoint(Joint):
+    """Prismatic (Sliding) Joint.
+
+    .. image:: PrismaticJoint.svg
+
+    Explanation
+    ===========
+
+    It is defined such that the child body translates with respect to the parent
+    body along the body-fixed joint axis. The location of the joint is defined
+    by two points, one in each body, which coincide when the generalized
+    coordinate is zero. The direction cosine matrix between the
+    parent_interframe and child_interframe is the identity matrix. Therefore,
+    the direction cosine matrix between the parent and child frames is fully
+    defined by the definition of the intermediate frames. The page on the joints
+    framework gives a more detailed explanation of the intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    coordinates : dynamicsymbol, optional
+        Generalized coordinates of the joint. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : dynamicsymbol, optional
+        Generalized speeds of joint. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector
+        The axis along which the translation occurs. Note that the components
+        of this axis are the same in the parent_interframe and child_interframe.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single prismatic joint is created from two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import Body, PrismaticJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = PrismaticJoint('PC', parent, child)
+    >>> joint
+    PrismaticJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([[q_PC(t)]])
+    >>> joint.speeds
+    Matrix([[u_PC(t)]])
+    >>> joint.child.frame.ang_vel_in(joint.parent.frame)
+    0
+    >>> joint.child.frame.dcm(joint.parent.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q_PC(t)*P_frame.x
+
+    To further demonstrate the use of the prismatic joint, the kinematics of two
+    masses sliding, one moving relative to a fixed body and the other relative
+    to the moving body. about the X axis of each connected body can be created
+    as follows.
+
+    >>> from sympy.physics.mechanics import PrismaticJoint, Body
+
+    First create bodies to represent the fixed ceiling and one to represent
+    a particle.
+
+    >>> wall = Body('W')
+    >>> Part1 = Body('P1')
+    >>> Part2 = Body('P2')
+
+    The first joint will connect the particle to the ceiling and the
+    joint axis will be about the X axis for each body.
+
+    >>> J1 = PrismaticJoint('J1', wall, Part1)
+
+    The second joint will connect the second particle to the first particle
+    and the joint axis will also be about the X axis for each body.
+
+    >>> J2 = PrismaticJoint('J2', Part1, Part2)
+
+    Once the joint is established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of Part relative
+    to the ceiling are found:
+
+    >>> Part1.dcm(wall)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    >>> Part2.dcm(wall)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    The position of the particles' masscenter is found with:
+
+    >>> Part1.masscenter.pos_from(wall.masscenter)
+    q_J1(t)*W_frame.x
+
+    >>> Part2.masscenter.pos_from(wall.masscenter)
+    q_J1(t)*W_frame.x + q_J2(t)*P1_frame.x
+
+    The angular velocities of the two particle links can be computed with
+    respect to the ceiling.
+
+    >>> Part1.ang_vel_in(wall)
+    0
+
+    >>> Part2.ang_vel_in(wall)
+    0
+
+    And finally, the linear velocities of the two particles can be computed
+    with respect to the ceiling.
+
+    >>> Part1.masscenter_vel(wall)
+    u_J1(t)*W_frame.x
+
+    >>> Part2.masscenter.vel(wall.frame)
+    u_J1(t)*W_frame.x + Derivative(q_J2(t), t)*P1_frame.x
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_axis=None,
+                 child_axis=None, parent_interframe=None, child_interframe=None,
+                 joint_axis=None, parent_joint_pos=None, child_joint_pos=None):
+
+        self._joint_axis = joint_axis
+        super().__init__(name, parent, child, coordinates, speeds, parent_point,
+                         child_point, parent_axis, child_axis,
+                         parent_interframe, child_interframe, parent_joint_pos,
+                         child_joint_pos)
+
+    def __str__(self):
+        return (f'PrismaticJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis along which the child translates with respect to the parent."""
+        return self._joint_axis
+
+    def _generate_coordinates(self, coordinate):
+        return self._fill_coordinate_list(coordinate, 1, 'q')
+
+    def _generate_speeds(self, speed):
+        return self._fill_coordinate_list(speed, 1, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, 0)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, 0)
+
+    def _set_linear_velocity(self):
+        axis = self.joint_axis.normalize()
+        self.child_point.set_pos(self.parent_point, self.coordinates[0] * axis)
+        self.parent_point.set_vel(self.parent.frame, 0)
+        self.child_point.set_vel(self.child.frame, 0)
+        self.child_point.set_vel(self.parent.frame, self.speeds[0] * axis)
+        self.child.masscenter.set_vel(self.parent.frame, self.speeds[0] * axis)
+
+
+class CylindricalJoint(Joint):
+    """Cylindrical Joint.
+
+    .. image:: CylindricalJoint.svg
+        :align: center
+        :width: 600
+
+    Explanation
+    ===========
+
+    A cylindrical joint is defined such that the child body both rotates about
+    and translates along the body-fixed joint axis with respect to the parent
+    body. The joint axis is both the rotation axis and translation axis. The
+    location of the joint is defined by two points, one in each body, which
+    coincide when the generalized coordinate corresponding to the translation is
+    zero. The direction cosine matrix between the child interframe and parent
+    interframe is formed using a simple rotation about the joint axis. The page
+    on the joints framework gives a more detailed explanation of the
+    intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    rotation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the rotation angle. The default
+        value is ``dynamicsymbols(f'q0_{joint.name}')``.
+    translation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the translation distance. The
+        default value is ``dynamicsymbols(f'q1_{joint.name}')``.
+    rotation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the angular velocity. The default
+        value is ``dynamicsymbols(f'u0_{joint.name}')``.
+    translation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the translation velocity. The default
+        value is ``dynamicsymbols(f'u1_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector, optional
+        The rotation as well as translation axis. Note that the components of
+        this axis are the same in the parent_interframe and child_interframe.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    rotation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the rotation angle.
+    translation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the translation distance.
+    rotation_speed : dynamicsymbol
+        Generalized speed corresponding to the angular velocity.
+    translation_speed : dynamicsymbol
+        Generalized speed corresponding to the translation velocity.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+    joint_axis : Vector
+        The axis of rotation and translation.
+
+    Examples
+    =========
+
+    A single cylindrical joint is created between two bodies and has the
+    following basic attributes:
+
+    >>> from sympy.physics.mechanics import Body, CylindricalJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = CylindricalJoint('PC', parent, child)
+    >>> joint
+    CylindricalJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)]])
+    >>> joint.child.frame.ang_vel_in(joint.parent.frame)
+    u0_PC(t)*P_frame.x
+    >>> joint.child.frame.dcm(joint.parent.frame)
+    Matrix([
+    [1,              0,             0],
+    [0,  cos(q0_PC(t)), sin(q0_PC(t))],
+    [0, -sin(q0_PC(t)), cos(q0_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q1_PC(t)*P_frame.x
+    >>> child.masscenter.vel(parent.frame)
+    u1_PC(t)*P_frame.x
+
+    To further demonstrate the use of the cylindrical joint, the kinematics of
+    two cylindrical joints perpendicular to each other can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import Body, CylindricalJoint
+    >>> r, l, w = symbols('r l w')
+
+    First create bodies to represent the fixed floor with a fixed pole on it.
+    The second body represents a freely moving tube around that pole. The third
+    body represents a solid flag freely translating along and rotating around
+    the Y axis of the tube.
+
+    >>> floor = Body('floor')
+    >>> tube = Body('tube')
+    >>> flag = Body('flag')
+
+    The first joint will connect the first tube to the floor with it translating
+    along and rotating around the Z axis of both bodies.
+
+    >>> floor_joint = CylindricalJoint('C1', floor, tube, joint_axis=floor.z)
+
+    The second joint will connect the tube perpendicular to the flag along the Y
+    axis of both the tube and the flag, with the joint located at a distance
+    ``r`` from the tube's center of mass and a combination of the distances
+    ``l`` and ``w`` from the flag's center of mass.
+
+    >>> flag_joint = CylindricalJoint('C2', tube, flag,
+    ...                               parent_point=r * tube.y,
+    ...                               child_point=-w * flag.y + l * flag.z,
+    ...                               joint_axis=tube.y)
+
+    Once the joints are established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of both the body and the
+    flag relative to the floor are found:
+
+    >>> tube.dcm(floor)
+    Matrix([
+    [ cos(q0_C1(t)), sin(q0_C1(t)), 0],
+    [-sin(q0_C1(t)), cos(q0_C1(t)), 0],
+    [             0,             0, 1]])
+    >>> flag.dcm(floor)
+    Matrix([
+    [cos(q0_C1(t))*cos(q0_C2(t)), sin(q0_C1(t))*cos(q0_C2(t)), -sin(q0_C2(t))],
+    [             -sin(q0_C1(t)),               cos(q0_C1(t)),              0],
+    [sin(q0_C2(t))*cos(q0_C1(t)), sin(q0_C1(t))*sin(q0_C2(t)),  cos(q0_C2(t))]])
+
+    The position of the flag's center of mass is found with:
+
+    >>> flag.masscenter.pos_from(floor.masscenter)
+    q1_C1(t)*floor_frame.z + (r + q1_C2(t))*tube_frame.y + w*flag_frame.y - l*flag_frame.z
+
+    The angular velocities of the two tubes can be computed with respect to the
+    floor.
+
+    >>> tube.ang_vel_in(floor)
+    u0_C1(t)*floor_frame.z
+    >>> flag.ang_vel_in(floor)
+    u0_C1(t)*floor_frame.z + u0_C2(t)*tube_frame.y
+
+    Finally, the linear velocities of the two tube centers of mass can be
+    computed with respect to the floor, while expressed in the tube's frame.
+
+    >>> tube.masscenter.vel(floor.frame).to_matrix(tube.frame)
+    Matrix([
+    [       0],
+    [       0],
+    [u1_C1(t)]])
+    >>> flag.masscenter.vel(floor.frame).to_matrix(tube.frame).simplify()
+    Matrix([
+    [-l*u0_C2(t)*cos(q0_C2(t)) - r*u0_C1(t) - w*u0_C1(t) - q1_C2(t)*u0_C1(t)],
+    [                    -l*u0_C1(t)*sin(q0_C2(t)) + Derivative(q1_C2(t), t)],
+    [                                    l*u0_C2(t)*sin(q0_C2(t)) + u1_C1(t)]])
+
+    """
+
+    def __init__(self, name, parent, child, rotation_coordinate=None,
+                 translation_coordinate=None, rotation_speed=None,
+                 translation_speed=None, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None,
+                 joint_axis=None):
+        self._joint_axis = joint_axis
+        coordinates = (rotation_coordinate, translation_coordinate)
+        speeds = (rotation_speed, translation_speed)
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'CylindricalJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis about and along which the rotation and translation occurs."""
+        return self._joint_axis
+
+    @property
+    def rotation_coordinate(self):
+        """Generalized coordinate corresponding to the rotation angle."""
+        return self.coordinates[0]
+
+    @property
+    def translation_coordinate(self):
+        """Generalized coordinate corresponding to the translation distance."""
+        return self.coordinates[1]
+
+    @property
+    def rotation_speed(self):
+        """Generalized speed corresponding to the angular velocity."""
+        return self.speeds[0]
+
+    @property
+    def translation_speed(self):
+        """Generalized speed corresponding to the translation velocity."""
+        return self.speeds[1]
+
+    def _generate_coordinates(self, coordinates):
+        return self._fill_coordinate_list(coordinates, 2, 'q')
+
+    def _generate_speeds(self, speeds):
+        return self._fill_coordinate_list(speeds, 2, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, self.rotation_coordinate)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(
+            self.parent_interframe,
+            self.rotation_speed * self.joint_axis.normalize())
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(
+            self.parent_point,
+            self.translation_coordinate * self.joint_axis.normalize())
+        self.parent_point.set_vel(self.parent.frame, 0)
+        self.child_point.set_vel(self.child.frame, 0)
+        self.child_point.set_vel(
+            self.parent.frame,
+            self.translation_speed * self.joint_axis.normalize())
+        self.child.masscenter.v2pt_theory(self.child_point, self.parent.frame,
+                                          self.child_interframe)
+
+
+class PlanarJoint(Joint):
+    """Planar Joint.
+
+    .. image:: PlanarJoint.svg
+        :align: center
+        :width: 800
+
+    Explanation
+    ===========
+
+    A planar joint is defined such that the child body translates over a fixed
+    plane of the parent body as well as rotate about the rotation axis, which
+    is perpendicular to that plane. The origin of this plane is the
+    ``parent_point`` and the plane is spanned by two nonparallel planar vectors.
+    The location of the ``child_point`` is based on the planar vectors
+    ($\\vec{v}_1$, $\\vec{v}_2$) and generalized coordinates ($q_1$, $q_2$),
+    i.e. $\\vec{r} = q_1 \\hat{v}_1 + q_2 \\hat{v}_2$. The direction cosine
+    matrix between the ``child_interframe`` and ``parent_interframe`` is formed
+    using a simple rotation ($q_0$) about the rotation axis.
+
+    In order to simplify the definition of the ``PlanarJoint``, the
+    ``rotation_axis`` and ``planar_vectors`` are set to be the unit vectors of
+    the ``parent_interframe`` according to the table below. This ensures that
+    you can only define these vectors by creating a separate frame and supplying
+    that as the interframe. If you however would only like to supply the normals
+    of the plane with respect to the parent and child bodies, then you can also
+    supply those to the ``parent_interframe`` and ``child_interframe``
+    arguments. An example of both of these cases is in the examples section
+    below and the page on the joints framework provides a more detailed
+    explanation of the intermediate frames.
+
+    .. list-table::
+
+        * - ``rotation_axis``
+          - ``parent_interframe.x``
+        * - ``planar_vectors[0]``
+          - ``parent_interframe.y``
+        * - ``planar_vectors[1]``
+          - ``parent_interframe.z``
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    rotation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the rotation angle. The default
+        value is ``dynamicsymbols(f'q0_{joint.name}')``.
+    planar_coordinates : iterable of dynamicsymbols, optional
+        Two generalized coordinates used for the planar translation. The default
+        value is ``dynamicsymbols(f'q1_{joint.name} q2_{joint.name}')``.
+    rotation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the angular velocity. The default
+        value is ``dynamicsymbols(f'u0_{joint.name}')``.
+    planar_speeds : dynamicsymbols, optional
+        Two generalized speeds used for the planar translation velocity. The
+        default value is ``dynamicsymbols(f'u1_{joint.name} u2_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    rotation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the rotation angle.
+    planar_coordinates : Matrix
+        Two generalized coordinates used for the planar translation.
+    rotation_speed : dynamicsymbol
+        Generalized speed corresponding to the angular velocity.
+    planar_speeds : Matrix
+        Two generalized speeds used for the planar translation velocity.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+    rotation_axis : Vector
+        The axis about which the rotation occurs.
+    planar_vectors : list
+        The vectors that describe the planar translation directions.
+
+    Examples
+    =========
+
+    A single planar joint is created between two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import Body, PlanarJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = PlanarJoint('PC', parent, child)
+    >>> joint
+    PlanarJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.rotation_axis
+    P_frame.x
+    >>> joint.planar_vectors
+    [P_frame.y, P_frame.z]
+    >>> joint.rotation_coordinate
+    q0_PC(t)
+    >>> joint.planar_coordinates
+    Matrix([
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.rotation_speed
+    u0_PC(t)
+    >>> joint.planar_speeds
+    Matrix([
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> joint.child.frame.ang_vel_in(joint.parent.frame)
+    u0_PC(t)*P_frame.x
+    >>> joint.child.frame.dcm(joint.parent.frame)
+    Matrix([
+    [1,              0,             0],
+    [0,  cos(q0_PC(t)), sin(q0_PC(t))],
+    [0, -sin(q0_PC(t)), cos(q0_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q1_PC(t)*P_frame.y + q2_PC(t)*P_frame.z
+    >>> child.masscenter.vel(parent.frame)
+    u1_PC(t)*P_frame.y + u2_PC(t)*P_frame.z
+
+    To further demonstrate the use of the planar joint, the kinematics of a
+    block sliding on a slope, can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import PlanarJoint, Body, ReferenceFrame
+    >>> a, d, h = symbols('a d h')
+
+    First create bodies to represent the slope and the block.
+
+    >>> ground = Body('G')
+    >>> block = Body('B')
+
+    To define the slope you can either define the plane by specifying the
+    ``planar_vectors`` or/and the ``rotation_axis``. However it is advisable to
+    create a rotated intermediate frame, so that the ``parent_vectors`` and
+    ``rotation_axis`` will be the unit vectors of this intermediate frame.
+
+    >>> slope = ReferenceFrame('A')
+    >>> slope.orient_axis(ground.frame, ground.y, a)
+
+    The planar joint can be created using these bodies and intermediate frame.
+    We can specify the origin of the slope to be ``d`` above the slope's center
+    of mass and the block's center of mass to be a distance ``h`` above the
+    slope's surface. Note that we can specify the normal of the plane using the
+    rotation axis argument.
+
+    >>> joint = PlanarJoint('PC', ground, block, parent_point=d * ground.x,
+    ...                     child_point=-h * block.x, parent_interframe=slope)
+
+    Once the joint is established the kinematics of the bodies can be accessed.
+    First the ``rotation_axis``, which is normal to the plane and the
+    ``plane_vectors``, can be found.
+
+    >>> joint.rotation_axis
+    A.x
+    >>> joint.planar_vectors
+    [A.y, A.z]
+
+    The direction cosine matrix of the block with respect to the ground can be
+    found with:
+
+    >>> block.dcm(ground)
+    Matrix([
+    [              cos(a),              0,              -sin(a)],
+    [sin(a)*sin(q0_PC(t)),  cos(q0_PC(t)), sin(q0_PC(t))*cos(a)],
+    [sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]])
+
+    The angular velocity of the block can be computed with respect to the
+    ground.
+
+    >>> block.ang_vel_in(ground)
+    u0_PC(t)*A.x
+
+    The position of the block's center of mass can be found with:
+
+    >>> block.masscenter.pos_from(ground.masscenter)
+    d*G_frame.x + h*B_frame.x + q1_PC(t)*A.y + q2_PC(t)*A.z
+
+    Finally, the linear velocity of the block's center of mass can be
+    computed with respect to the ground.
+
+    >>> block.masscenter.vel(ground.frame)
+    u1_PC(t)*A.y + u2_PC(t)*A.z
+
+    In some cases it could be your preference to only define the normals of the
+    plane with respect to both bodies. This can most easily be done by supplying
+    vectors to the ``interframe`` arguments. What will happen in this case is
+    that an interframe will be created with its ``x`` axis aligned with the
+    provided vector. For a further explanation of how this is done see the notes
+    of the ``Joint`` class. In the code below, the above example (with the block
+    on the slope) is recreated by supplying vectors to the interframe arguments.
+    Note that the previously described option is however more computationally
+    efficient, because the algorithm now has to compute the rotation angle
+    between the provided vector and the 'x' axis.
+
+    >>> from sympy import symbols, cos, sin
+    >>> from sympy.physics.mechanics import PlanarJoint, Body
+    >>> a, d, h = symbols('a d h')
+    >>> ground = Body('G')
+    >>> block = Body('B')
+    >>> joint = PlanarJoint(
+    ...     'PC', ground, block, parent_point=d * ground.x,
+    ...     child_point=-h * block.x, child_interframe=block.x,
+    ...     parent_interframe=cos(a) * ground.x + sin(a) * ground.z)
+    >>> block.dcm(ground).simplify()
+    Matrix([
+    [               cos(a),              0,               sin(a)],
+    [-sin(a)*sin(q0_PC(t)),  cos(q0_PC(t)), sin(q0_PC(t))*cos(a)],
+    [-sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]])
+
+    """
+
+    def __init__(self, name, parent, child, rotation_coordinate=None,
+                 planar_coordinates=None, rotation_speed=None,
+                 planar_speeds=None, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None):
+        # A ready to merge implementation of setting the planar_vectors and
+        # rotation_axis was added and removed in PR #24046
+        coordinates = (rotation_coordinate, planar_coordinates)
+        speeds = (rotation_speed, planar_speeds)
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'PlanarJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def rotation_coordinate(self):
+        """Generalized coordinate corresponding to the rotation angle."""
+        return self.coordinates[0]
+
+    @property
+    def planar_coordinates(self):
+        """Two generalized coordinates used for the planar translation."""
+        return self.coordinates[1:, 0]
+
+    @property
+    def rotation_speed(self):
+        """Generalized speed corresponding to the angular velocity."""
+        return self.speeds[0]
+
+    @property
+    def planar_speeds(self):
+        """Two generalized speeds used for the planar translation velocity."""
+        return self.speeds[1:, 0]
+
+    @property
+    def rotation_axis(self):
+        """The axis about which the rotation occurs."""
+        return self.parent_interframe.x
+
+    @property
+    def planar_vectors(self):
+        """The vectors that describe the planar translation directions."""
+        return [self.parent_interframe.y, self.parent_interframe.z]
+
+    def _generate_coordinates(self, coordinates):
+        rotation_speed = self._fill_coordinate_list(coordinates[0], 1, 'q',
+                                                    number_single=True)
+        planar_speeds = self._fill_coordinate_list(coordinates[1], 2, 'q', 1)
+        return rotation_speed.col_join(planar_speeds)
+
+    def _generate_speeds(self, speeds):
+        rotation_speed = self._fill_coordinate_list(speeds[0], 1, 'u',
+                                                    number_single=True)
+        planar_speeds = self._fill_coordinate_list(speeds[1], 2, 'u', 1)
+        return rotation_speed.col_join(planar_speeds)
+
+    def _orient_frames(self):
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.rotation_axis,
+            self.rotation_coordinate)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(
+            self.parent_interframe,
+            self.rotation_speed * self.rotation_axis)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(
+            self.parent_point,
+            self.planar_coordinates[0] * self.planar_vectors[0] +
+            self.planar_coordinates[1] * self.planar_vectors[1])
+        self.parent_point.set_vel(self.parent_interframe, 0)
+        self.child_point.set_vel(self.child_interframe, 0)
+        self.child_point.set_vel(
+            self.parent.frame, self.planar_speeds[0] * self.planar_vectors[0] +
+            self.planar_speeds[1] * self.planar_vectors[1])
+        self.child.masscenter.v2pt_theory(self.child_point, self.parent.frame,
+                                          self.child.frame)
+
+
+class SphericalJoint(Joint):
+    """Spherical (Ball-and-Socket) Joint.
+
+    .. image:: SphericalJoint.svg
+        :align: center
+        :width: 600
+
+    Explanation
+    ===========
+
+    A spherical joint is defined such that the child body is free to rotate in
+    any direction, without allowing a translation of the ``child_point``. As can
+    also be seen in the image, the ``parent_point`` and ``child_point`` are
+    fixed on top of each other, i.e. the ``joint_point``. This rotation is
+    defined using the :func:`parent_interframe.orient(child_interframe,
+    rot_type, amounts, rot_order)
+    <sympy.physics.vector.frame.ReferenceFrame.orient>` method. The default
+    rotation consists of three relative rotations, i.e. body-fixed rotations.
+    Based on the direction cosine matrix following from these rotations, the
+    angular velocity is computed based on the generalized coordinates and
+    generalized speeds.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    coordinates: iterable of dynamicsymbols, optional
+        Generalized coordinates of the joint.
+    speeds : iterable of dynamicsymbols, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    rot_type : str, optional
+        The method used to generate the direction cosine matrix. Supported
+        methods are:
+
+        - ``'Body'``: three successive rotations about new intermediate axes,
+          also called "Euler and Tait-Bryan angles"
+        - ``'Space'``: three successive rotations about the parent frames' unit
+          vectors
+
+        The default method is ``'Body'``.
+    amounts :
+        Expressions defining the rotation angles or direction cosine matrix.
+        These must match the ``rot_type``. See examples below for details. The
+        input types are:
+
+        - ``'Body'``: 3-tuple of expressions, symbols, or functions
+        - ``'Space'``: 3-tuple of expressions, symbols, or functions
+
+        The default amounts are the given ``coordinates``.
+    rot_order : str or int, optional
+        If applicable, the order of the successive of rotations. The string
+        ``'123'`` and integer ``123`` are equivalent, for example. Required for
+        ``'Body'`` and ``'Space'``. The default value is ``123``.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single spherical joint is created from two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import Body, SphericalJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = SphericalJoint('PC', parent, child)
+    >>> joint
+    SphericalJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_interframe
+    P_frame
+    >>> joint.child_interframe
+    C_frame
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame).to_matrix(child.frame)
+    Matrix([
+    [ u0_PC(t)*cos(q1_PC(t))*cos(q2_PC(t)) + u1_PC(t)*sin(q2_PC(t))],
+    [-u0_PC(t)*sin(q2_PC(t))*cos(q1_PC(t)) + u1_PC(t)*cos(q2_PC(t))],
+    [                             u0_PC(t)*sin(q1_PC(t)) + u2_PC(t)]])
+    >>> child.frame.x.to_matrix(parent.frame)
+    Matrix([
+    [                                            cos(q1_PC(t))*cos(q2_PC(t))],
+    [sin(q0_PC(t))*sin(q1_PC(t))*cos(q2_PC(t)) + sin(q2_PC(t))*cos(q0_PC(t))],
+    [sin(q0_PC(t))*sin(q2_PC(t)) - sin(q1_PC(t))*cos(q0_PC(t))*cos(q2_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the spherical joint, the kinematics of a
+    spherical joint with a ZXZ rotation can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import Body, SphericalJoint
+    >>> l1 = symbols('l1')
+
+    First create bodies to represent the fixed floor and a pendulum bob.
+
+    >>> floor = Body('F')
+    >>> bob = Body('B')
+
+    The joint will connect the bob to the floor, with the joint located at a
+    distance of ``l1`` from the child's center of mass and the rotation set to a
+    body-fixed ZXZ rotation.
+
+    >>> joint = SphericalJoint('S', floor, bob, child_point=l1 * bob.y,
+    ...                        rot_type='body', rot_order='ZXZ')
+
+    Now that the joint is established, the kinematics of the connected body can
+    be accessed.
+
+    The position of the bob's masscenter is found with:
+
+    >>> bob.masscenter.pos_from(floor.masscenter)
+    - l1*B_frame.y
+
+    The angular velocities of the pendulum link can be computed with respect to
+    the floor.
+
+    >>> bob.frame.ang_vel_in(floor.frame).to_matrix(
+    ...     floor.frame).simplify()
+    Matrix([
+    [u1_S(t)*cos(q0_S(t)) + u2_S(t)*sin(q0_S(t))*sin(q1_S(t))],
+    [u1_S(t)*sin(q0_S(t)) - u2_S(t)*sin(q1_S(t))*cos(q0_S(t))],
+    [                          u0_S(t) + u2_S(t)*cos(q1_S(t))]])
+
+    Finally, the linear velocity of the bob's center of mass can be computed.
+
+    >>> bob.masscenter.vel(floor.frame).to_matrix(bob.frame)
+    Matrix([
+    [                           l1*(u0_S(t)*cos(q1_S(t)) + u2_S(t))],
+    [                                                             0],
+    [-l1*(u0_S(t)*sin(q1_S(t))*sin(q2_S(t)) + u1_S(t)*cos(q2_S(t)))]])
+
+    """
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_interframe=None,
+                 child_interframe=None, rot_type='BODY', amounts=None,
+                 rot_order=123):
+        self._rot_type = rot_type
+        self._amounts = amounts
+        self._rot_order = rot_order
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'SphericalJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    def _generate_coordinates(self, coordinates):
+        return self._fill_coordinate_list(coordinates, 3, 'q')
+
+    def _generate_speeds(self, speeds):
+        return self._fill_coordinate_list(speeds, len(self.coordinates), 'u')
+
+    def _orient_frames(self):
+        supported_rot_types = ('BODY', 'SPACE')
+        if self._rot_type.upper() not in supported_rot_types:
+            raise NotImplementedError(
+                f'Rotation type "{self._rot_type}" is not implemented. '
+                f'Implemented rotation types are: {supported_rot_types}')
+        amounts = self.coordinates if self._amounts is None else self._amounts
+        self.child_interframe.orient(self.parent_interframe, self._rot_type,
+                                     amounts, self._rot_order)
+
+    def _set_angular_velocity(self):
+        t = dynamicsymbols._t
+        vel = self.child_interframe.ang_vel_in(self.parent_interframe).xreplace(
+            {q.diff(t): u for q, u in zip(self.coordinates, self.speeds)}
+        )
+        self.child_interframe.set_ang_vel(self.parent_interframe, vel)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self.parent.frame, 0)
+        self.child_point.set_vel(self.child.frame, 0)
+        self.child.masscenter.v2pt_theory(self.parent_point, self.parent.frame,
+                                          self.child.frame)
+
+
+class WeldJoint(Joint):
+    """Weld Joint.
+
+    .. image:: WeldJoint.svg
+        :align: center
+        :width: 500
+
+    Explanation
+    ===========
+
+    A weld joint is defined such that there is no relative motion between the
+    child and parent bodies. The direction cosine matrix between the attachment
+    frame (``parent_interframe`` and ``child_interframe``) is the identity
+    matrix and the attachment points (``parent_point`` and ``child_point``) are
+    coincident. The page on the joints framework gives a more detailed
+    explanation of the intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Body
+        The parent body of joint.
+    child : Body
+        The child body of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Body
+        The joint's parent body.
+    child : Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single weld joint is created from two bodies and has the following basic
+    attributes:
+
+    >>> from sympy.physics.mechanics import Body, WeldJoint
+    >>> parent = Body('P')
+    >>> parent
+    P
+    >>> child = Body('C')
+    >>> child
+    C
+    >>> joint = WeldJoint('PC', parent, child)
+    >>> joint
+    WeldJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.coordinates
+    Matrix(0, 0, [])
+    >>> joint.speeds
+    Matrix(0, 0, [])
+    >>> joint.child.frame.ang_vel_in(joint.parent.frame)
+    0
+    >>> joint.child.frame.dcm(joint.parent.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the weld joint, two relatively-fixed
+    bodies rotated by a quarter turn about the Y axis can be created as follows:
+
+    >>> from sympy import symbols, pi
+    >>> from sympy.physics.mechanics import ReferenceFrame, Body, WeldJoint
+    >>> l1, l2 = symbols('l1 l2')
+
+    First create the bodies to represent the parent and rotated child body.
+
+    >>> parent = Body('P')
+    >>> child = Body('C')
+
+    Next the intermediate frame specifying the fixed rotation with respect to
+    the parent can be created.
+
+    >>> rotated_frame = ReferenceFrame('Pr')
+    >>> rotated_frame.orient_axis(parent.frame, parent.y, pi / 2)
+
+    The weld between the parent body and child body is located at a distance
+    ``l1`` from the parent's center of mass in the X direction and ``l2`` from
+    the child's center of mass in the child's negative X direction.
+
+    >>> weld = WeldJoint('weld', parent, child, parent_point=l1 * parent.x,
+    ...                  child_point=-l2 * child.x,
+    ...                  parent_interframe=rotated_frame)
+
+    Now that the joint has been established, the kinematics of the bodies can be
+    accessed. The direction cosine matrix of the child body with respect to the
+    parent can be found:
+
+    >>> child.dcm(parent)
+    Matrix([
+    [0, 0, -1],
+    [0, 1,  0],
+    [1, 0,  0]])
+
+    As can also been seen from the direction cosine matrix, the parent X axis is
+    aligned with the child's Z axis:
+    >>> parent.x == child.z
+    True
+
+    The position of the child's center of mass with respect to the parent's
+    center of mass can be found with:
+
+    >>> child.masscenter.pos_from(parent.masscenter)
+    l1*P_frame.x + l2*C_frame.x
+
+    The angular velocity of the child with respect to the parent is 0 as one
+    would expect.
+
+    >>> child.ang_vel_in(parent)
+    0
+
+    """
+
+    def __init__(self, name, parent, child, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None):
+        super().__init__(name, parent, child, [], [], parent_point,
+                         child_point, parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+        self._kdes = Matrix(1, 0, []).T  # Removes stackability problems #10770
+
+    def __str__(self):
+        return (f'WeldJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    def _generate_coordinates(self, coordinate):
+        return Matrix()
+
+    def _generate_speeds(self, speed):
+        return Matrix()
+
+    def _orient_frames(self):
+        self.child_interframe.orient_axis(self.parent_interframe,
+                                          self.parent_interframe.x, 0)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, 0)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self.parent.frame, 0)
+        self.child_point.set_vel(self.child.frame, 0)
+        self.child.masscenter.set_vel(self.parent.frame, 0)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/jointsmethod.py

@@ -0,0 +1,279 @@
+from sympy.physics.mechanics import (Body, Lagrangian, KanesMethod, LagrangesMethod,
+                                    RigidBody, Particle)
+from sympy.physics.mechanics.method import _Methods
+from sympy.core.backend import Matrix
+
+__all__ = ['JointsMethod']
+
+
+class JointsMethod(_Methods):
+    """Method for formulating the equations of motion using a set of interconnected bodies with joints.
+
+    Parameters
+    ==========
+
+    newtonion : Body or ReferenceFrame
+        The newtonion(inertial) frame.
+    *joints : Joint
+        The joints in the system
+
+    Attributes
+    ==========
+
+    q, u : iterable
+        Iterable of the generalized coordinates and speeds
+    bodies : iterable
+        Iterable of Body objects in the system.
+    loads : iterable
+        Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
+        describing the forces on the system.
+    mass_matrix : Matrix, shape(n, n)
+        The system's mass matrix
+    forcing : Matrix, shape(n, 1)
+        The system's forcing vector
+    mass_matrix_full : Matrix, shape(2*n, 2*n)
+        The "mass matrix" for the u's and q's
+    forcing_full : Matrix, shape(2*n, 1)
+        The "forcing vector" for the u's and q's
+    method : KanesMethod or Lagrange's method
+        Method's object.
+    kdes : iterable
+        Iterable of kde in they system.
+
+    Examples
+    ========
+
+    This is a simple example for a one degree of freedom translational
+    spring-mass-damper.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import Body, JointsMethod, PrismaticJoint
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> c, k = symbols('c k')
+    >>> x, v = dynamicsymbols('x v')
+    >>> wall = Body('W')
+    >>> body = Body('B')
+    >>> J = PrismaticJoint('J', wall, body, coordinates=x, speeds=v)
+    >>> wall.apply_force(c*v*wall.x, reaction_body=body)
+    >>> wall.apply_force(k*x*wall.x, reaction_body=body)
+    >>> method = JointsMethod(wall, J)
+    >>> method.form_eoms()
+    Matrix([[-B_mass*Derivative(v(t), t) - c*v(t) - k*x(t)]])
+    >>> M = method.mass_matrix_full
+    >>> F = method.forcing_full
+    >>> rhs = M.LUsolve(F)
+    >>> rhs
+    Matrix([
+    [                     v(t)],
+    [(-c*v(t) - k*x(t))/B_mass]])
+
+    Notes
+    =====
+
+    ``JointsMethod`` currently only works with systems that do not have any
+    configuration or motion constraints.
+
+    """
+
+    def __init__(self, newtonion, *joints):
+        if isinstance(newtonion, Body):
+            self.frame = newtonion.frame
+        else:
+            self.frame = newtonion
+
+        self._joints = joints
+        self._bodies = self._generate_bodylist()
+        self._loads = self._generate_loadlist()
+        self._q = self._generate_q()
+        self._u = self._generate_u()
+        self._kdes = self._generate_kdes()
+
+        self._method = None
+
+    @property
+    def bodies(self):
+        """List of bodies in they system."""
+        return self._bodies
+
+    @property
+    def loads(self):
+        """List of loads on the system."""
+        return self._loads
+
+    @property
+    def q(self):
+        """List of the generalized coordinates."""
+        return self._q
+
+    @property
+    def u(self):
+        """List of the generalized speeds."""
+        return self._u
+
+    @property
+    def kdes(self):
+        """List of the generalized coordinates."""
+        return self._kdes
+
+    @property
+    def forcing_full(self):
+        """The "forcing vector" for the u's and q's."""
+        return self.method.forcing_full
+
+    @property
+    def mass_matrix_full(self):
+        """The "mass matrix" for the u's and q's."""
+        return self.method.mass_matrix_full
+
+    @property
+    def mass_matrix(self):
+        """The system's mass matrix."""
+        return self.method.mass_matrix
+
+    @property
+    def forcing(self):
+        """The system's forcing vector."""
+        return self.method.forcing
+
+    @property
+    def method(self):
+        """Object of method used to form equations of systems."""
+        return self._method
+
+    def _generate_bodylist(self):
+        bodies = []
+        for joint in self._joints:
+            if joint.child not in bodies:
+                bodies.append(joint.child)
+            if joint.parent not in bodies:
+                bodies.append(joint.parent)
+        return bodies
+
+    def _generate_loadlist(self):
+        load_list = []
+        for body in self.bodies:
+            load_list.extend(body.loads)
+        return load_list
+
+    def _generate_q(self):
+        q_ind = []
+        for joint in self._joints:
+            for coordinate in joint.coordinates:
+                if coordinate in q_ind:
+                    raise ValueError('Coordinates of joints should be unique.')
+                q_ind.append(coordinate)
+        return Matrix(q_ind)
+
+    def _generate_u(self):
+        u_ind = []
+        for joint in self._joints:
+            for speed in joint.speeds:
+                if speed in u_ind:
+                    raise ValueError('Speeds of joints should be unique.')
+                u_ind.append(speed)
+        return Matrix(u_ind)
+
+    def _generate_kdes(self):
+        kd_ind = Matrix(1, 0, []).T
+        for joint in self._joints:
+            kd_ind = kd_ind.col_join(joint.kdes)
+        return kd_ind
+
+    def _convert_bodies(self):
+        # Convert `Body` to `Particle` and `RigidBody`
+        bodylist = []
+        for body in self.bodies:
+            if body.is_rigidbody:
+                rb = RigidBody(body.name, body.masscenter, body.frame, body.mass,
+                    (body.central_inertia, body.masscenter))
+                rb.potential_energy = body.potential_energy
+                bodylist.append(rb)
+            else:
+                part = Particle(body.name, body.masscenter, body.mass)
+                part.potential_energy = body.potential_energy
+                bodylist.append(part)
+        return bodylist
+
+    def form_eoms(self, method=KanesMethod):
+        """Method to form system's equation of motions.
+
+        Parameters
+        ==========
+
+        method : Class
+            Class name of method.
+
+        Returns
+        ========
+
+        Matrix
+            Vector of equations of motions.
+
+        Examples
+        ========
+
+        This is a simple example for a one degree of freedom translational
+        spring-mass-damper.
+
+        >>> from sympy import S, symbols
+        >>> from sympy.physics.mechanics import LagrangesMethod, dynamicsymbols, Body
+        >>> from sympy.physics.mechanics import PrismaticJoint, JointsMethod
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> m, k, b = symbols('m k b')
+        >>> wall = Body('W')
+        >>> part = Body('P', mass=m)
+        >>> part.potential_energy = k * q**2 / S(2)
+        >>> J = PrismaticJoint('J', wall, part, coordinates=q, speeds=qd)
+        >>> wall.apply_force(b * qd * wall.x, reaction_body=part)
+        >>> method = JointsMethod(wall, J)
+        >>> method.form_eoms(LagrangesMethod)
+        Matrix([[b*Derivative(q(t), t) + k*q(t) + m*Derivative(q(t), (t, 2))]])
+
+        We can also solve for the states using the 'rhs' method.
+
+        >>> method.rhs()
+        Matrix([
+        [                Derivative(q(t), t)],
+        [(-b*Derivative(q(t), t) - k*q(t))/m]])
+
+        """
+
+        bodylist = self._convert_bodies()
+        if issubclass(method, LagrangesMethod): #LagrangesMethod or similar
+            L = Lagrangian(self.frame, *bodylist)
+            self._method = method(L, self.q, self.loads, bodylist, self.frame)
+        else: #KanesMethod or similar
+            self._method = method(self.frame, q_ind=self.q, u_ind=self.u, kd_eqs=self.kdes,
+                                    forcelist=self.loads, bodies=bodylist)
+        soln = self.method._form_eoms()
+        return soln
+
+    def rhs(self, inv_method=None):
+        """Returns equations that can be solved numerically.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrices.MatrixBase.inv`
+
+        Returns
+        ========
+
+        Matrix
+            Numerically solvable equations.
+
+        See Also
+        ========
+
+        sympy.physics.mechanics.kane.KanesMethod.rhs:
+            KanesMethod's rhs function.
+        sympy.physics.mechanics.lagrange.LagrangesMethod.rhs:
+            LagrangesMethod's rhs function.
+
+        """
+
+        return self.method.rhs(inv_method=inv_method)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/kane.py

@@ -0,0 +1,741 @@
+from sympy.core.backend import zeros, Matrix, diff, eye
+from sympy.core.sorting import default_sort_key
+from sympy.physics.vector import (ReferenceFrame, dynamicsymbols,
+                                  partial_velocity)
+from sympy.physics.mechanics.method import _Methods
+from sympy.physics.mechanics.particle import Particle
+from sympy.physics.mechanics.rigidbody import RigidBody
+from sympy.physics.mechanics.functions import (
+    msubs, find_dynamicsymbols, _f_list_parser, _validate_coordinates)
+from sympy.physics.mechanics.linearize import Linearizer
+from sympy.utilities.iterables import iterable
+
+__all__ = ['KanesMethod']
+
+
+class KanesMethod(_Methods):
+    r"""Kane's method object.
+
+    Explanation
+    ===========
+
+    This object is used to do the "book-keeping" as you go through and form
+    equations of motion in the way Kane presents in:
+    Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill
+
+    The attributes are for equations in the form [M] udot = forcing.
+
+    Attributes
+    ==========
+
+    q, u : Matrix
+        Matrices of the generalized coordinates and speeds
+    bodies : iterable
+        Iterable of Point and RigidBody objects in the system.
+    loads : iterable
+        Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
+        describing the forces on the system.
+    auxiliary_eqs : Matrix
+        If applicable, the set of auxiliary Kane's
+        equations used to solve for non-contributing
+        forces.
+    mass_matrix : Matrix
+        The system's dynamics mass matrix: [k_d; k_dnh]
+    forcing : Matrix
+        The system's dynamics forcing vector: -[f_d; f_dnh]
+    mass_matrix_kin : Matrix
+        The "mass matrix" for kinematic differential equations: k_kqdot
+    forcing_kin : Matrix
+        The forcing vector for kinematic differential equations: -(k_ku*u + f_k)
+    mass_matrix_full : Matrix
+        The "mass matrix" for the u's and q's with dynamics and kinematics
+    forcing_full : Matrix
+        The "forcing vector" for the u's and q's with dynamics and kinematics
+    explicit_kinematics : bool
+        Boolean whether the mass matrices and forcing vectors should use the
+        explicit form (default) or implicit form for kinematics.
+        See the notes for more details.
+
+    Notes
+    =====
+
+    The mass matrices and forcing vectors related to kinematic equations
+    are given in the explicit form by default. In other words, the kinematic
+    mass matrix is $\mathbf{k_{k\dot{q}}} = \mathbf{I}$.
+    In order to get the implicit form of those matrices/vectors, you can set the
+    ``explicit_kinematics`` attribute to ``False``. So $\mathbf{k_{k\dot{q}}}$ is not
+    necessarily an identity matrix. This can provide more compact equations for
+    non-simple kinematics (see #22626).
+
+    Examples
+    ========
+
+    This is a simple example for a one degree of freedom translational
+    spring-mass-damper.
+
+    In this example, we first need to do the kinematics.
+    This involves creating generalized speeds and coordinates and their
+    derivatives.
+    Then we create a point and set its velocity in a frame.
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame
+        >>> from sympy.physics.mechanics import Point, Particle, KanesMethod
+        >>> q, u = dynamicsymbols('q u')
+        >>> qd, ud = dynamicsymbols('q u', 1)
+        >>> m, c, k = symbols('m c k')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> P.set_vel(N, u * N.x)
+
+    Next we need to arrange/store information in the way that KanesMethod
+    requires.  The kinematic differential equations need to be stored in a
+    dict.  A list of forces/torques must be constructed, where each entry in
+    the list is a (Point, Vector) or (ReferenceFrame, Vector) tuple, where the
+    Vectors represent the Force or Torque.
+    Next a particle needs to be created, and it needs to have a point and mass
+    assigned to it.
+    Finally, a list of all bodies and particles needs to be created.
+
+        >>> kd = [qd - u]
+        >>> FL = [(P, (-k * q - c * u) * N.x)]
+        >>> pa = Particle('pa', P, m)
+        >>> BL = [pa]
+
+    Finally we can generate the equations of motion.
+    First we create the KanesMethod object and supply an inertial frame,
+    coordinates, generalized speeds, and the kinematic differential equations.
+    Additional quantities such as configuration and motion constraints,
+    dependent coordinates and speeds, and auxiliary speeds are also supplied
+    here (see the online documentation).
+    Next we form FR* and FR to complete: Fr + Fr* = 0.
+    We have the equations of motion at this point.
+    It makes sense to rearrange them though, so we calculate the mass matrix and
+    the forcing terms, for E.o.M. in the form: [MM] udot = forcing, where MM is
+    the mass matrix, udot is a vector of the time derivatives of the
+    generalized speeds, and forcing is a vector representing "forcing" terms.
+
+        >>> KM = KanesMethod(N, q_ind=[q], u_ind=[u], kd_eqs=kd)
+        >>> (fr, frstar) = KM.kanes_equations(BL, FL)
+        >>> MM = KM.mass_matrix
+        >>> forcing = KM.forcing
+        >>> rhs = MM.inv() * forcing
+        >>> rhs
+        Matrix([[(-c*u(t) - k*q(t))/m]])
+        >>> KM.linearize(A_and_B=True)[0]
+        Matrix([
+        [   0,    1],
+        [-k/m, -c/m]])
+
+    Please look at the documentation pages for more information on how to
+    perform linearization and how to deal with dependent coordinates & speeds,
+    and how do deal with bringing non-contributing forces into evidence.
+
+    """
+
+    def __init__(self, frame, q_ind, u_ind, kd_eqs=None, q_dependent=None,
+            configuration_constraints=None, u_dependent=None,
+            velocity_constraints=None, acceleration_constraints=None,
+            u_auxiliary=None, bodies=None, forcelist=None, explicit_kinematics=True):
+
+        """Please read the online documentation. """
+        if not q_ind:
+            q_ind = [dynamicsymbols('dummy_q')]
+            kd_eqs = [dynamicsymbols('dummy_kd')]
+
+        if not isinstance(frame, ReferenceFrame):
+            raise TypeError('An inertial ReferenceFrame must be supplied')
+        self._inertial = frame
+
+        self._fr = None
+        self._frstar = None
+
+        self._forcelist = forcelist
+        self._bodylist = bodies
+
+        self.explicit_kinematics = explicit_kinematics
+
+        self._initialize_vectors(q_ind, q_dependent, u_ind, u_dependent,
+                u_auxiliary)
+        _validate_coordinates(self.q, self.u)
+        self._initialize_kindiffeq_matrices(kd_eqs)
+        self._initialize_constraint_matrices(configuration_constraints,
+                velocity_constraints, acceleration_constraints)
+
+    def _initialize_vectors(self, q_ind, q_dep, u_ind, u_dep, u_aux):
+        """Initialize the coordinate and speed vectors."""
+
+        none_handler = lambda x: Matrix(x) if x else Matrix()
+
+        # Initialize generalized coordinates
+        q_dep = none_handler(q_dep)
+        if not iterable(q_ind):
+            raise TypeError('Generalized coordinates must be an iterable.')
+        if not iterable(q_dep):
+            raise TypeError('Dependent coordinates must be an iterable.')
+        q_ind = Matrix(q_ind)
+        self._qdep = q_dep
+        self._q = Matrix([q_ind, q_dep])
+        self._qdot = self.q.diff(dynamicsymbols._t)
+
+        # Initialize generalized speeds
+        u_dep = none_handler(u_dep)
+        if not iterable(u_ind):
+            raise TypeError('Generalized speeds must be an iterable.')
+        if not iterable(u_dep):
+            raise TypeError('Dependent speeds must be an iterable.')
+        u_ind = Matrix(u_ind)
+        self._udep = u_dep
+        self._u = Matrix([u_ind, u_dep])
+        self._udot = self.u.diff(dynamicsymbols._t)
+        self._uaux = none_handler(u_aux)
+
+    def _initialize_constraint_matrices(self, config, vel, acc):
+        """Initializes constraint matrices."""
+
+        # Define vector dimensions
+        o = len(self.u)
+        m = len(self._udep)
+        p = o - m
+        none_handler = lambda x: Matrix(x) if x else Matrix()
+
+        # Initialize configuration constraints
+        config = none_handler(config)
+        if len(self._qdep) != len(config):
+            raise ValueError('There must be an equal number of dependent '
+                             'coordinates and configuration constraints.')
+        self._f_h = none_handler(config)
+
+        # Initialize velocity and acceleration constraints
+        vel = none_handler(vel)
+        acc = none_handler(acc)
+        if len(vel) != m:
+            raise ValueError('There must be an equal number of dependent '
+                             'speeds and velocity constraints.')
+        if acc and (len(acc) != m):
+            raise ValueError('There must be an equal number of dependent '
+                             'speeds and acceleration constraints.')
+        if vel:
+            u_zero = {i: 0 for i in self.u}
+            udot_zero = {i: 0 for i in self._udot}
+
+            # When calling kanes_equations, another class instance will be
+            # created if auxiliary u's are present. In this case, the
+            # computation of kinetic differential equation matrices will be
+            # skipped as this was computed during the original KanesMethod
+            # object, and the qd_u_map will not be available.
+            if self._qdot_u_map is not None:
+                vel = msubs(vel, self._qdot_u_map)
+
+            self._f_nh = msubs(vel, u_zero)
+            self._k_nh = (vel - self._f_nh).jacobian(self.u)
+            # If no acceleration constraints given, calculate them.
+            if not acc:
+                _f_dnh = (self._k_nh.diff(dynamicsymbols._t) * self.u +
+                          self._f_nh.diff(dynamicsymbols._t))
+                if self._qdot_u_map is not None:
+                    _f_dnh = msubs(_f_dnh, self._qdot_u_map)
+                self._f_dnh = _f_dnh
+                self._k_dnh = self._k_nh
+            else:
+                if self._qdot_u_map is not None:
+                    acc = msubs(acc, self._qdot_u_map)
+                self._f_dnh = msubs(acc, udot_zero)
+                self._k_dnh = (acc - self._f_dnh).jacobian(self._udot)
+
+            # Form of non-holonomic constraints is B*u + C = 0.
+            # We partition B into independent and dependent columns:
+            # Ars is then -B_dep.inv() * B_ind, and it relates dependent speeds
+            # to independent speeds as: udep = Ars*uind, neglecting the C term.
+            B_ind = self._k_nh[:, :p]
+            B_dep = self._k_nh[:, p:o]
+            self._Ars = -B_dep.LUsolve(B_ind)
+        else:
+            self._f_nh = Matrix()
+            self._k_nh = Matrix()
+            self._f_dnh = Matrix()
+            self._k_dnh = Matrix()
+            self._Ars = Matrix()
+
+    def _initialize_kindiffeq_matrices(self, kdeqs):
+        """Initialize the kinematic differential equation matrices.
+
+        Parameters
+        ==========
+        kdeqs : sequence of sympy expressions
+            Kinematic differential equations in the form of f(u,q',q,t) where
+            f() = 0. The equations have to be linear in the generalized
+            coordinates and generalized speeds.
+
+        """
+
+        if kdeqs:
+            if len(self.q) != len(kdeqs):
+                raise ValueError('There must be an equal number of kinematic '
+                                 'differential equations and coordinates.')
+
+            u = self.u
+            qdot = self._qdot
+
+            kdeqs = Matrix(kdeqs)
+
+            u_zero = {ui: 0 for ui in u}
+            uaux_zero = {uai: 0 for uai in self._uaux}
+            qdot_zero = {qdi: 0 for qdi in qdot}
+
+            # Extract the linear coefficient matrices as per the following
+            # equation:
+            #
+            # k_ku(q,t)*u(t) + k_kqdot(q,t)*q'(t) + f_k(q,t) = 0
+            #
+            k_ku = kdeqs.jacobian(u)
+            k_kqdot = kdeqs.jacobian(qdot)
+            f_k = kdeqs.xreplace(u_zero).xreplace(qdot_zero)
+
+            # The kinematic differential equations should be linear in both q'
+            # and u, so check for u and q' in the components.
+            dy_syms = find_dynamicsymbols(k_ku.row_join(k_kqdot).row_join(f_k))
+            nonlin_vars = [vari for vari in u[:] + qdot[:] if vari in dy_syms]
+            if nonlin_vars:
+                msg = ('The provided kinematic differential equations are '
+                       'nonlinear in {}. They must be linear in the '
+                       'generalized speeds and derivatives of the generalized '
+                       'coordinates.')
+                raise ValueError(msg.format(nonlin_vars))
+
+            self._f_k_implicit = f_k.xreplace(uaux_zero)
+            self._k_ku_implicit = k_ku.xreplace(uaux_zero)
+            self._k_kqdot_implicit = k_kqdot
+
+            # Solve for q'(t) such that the coefficient matrices are now in
+            # this form:
+            #
+            # k_kqdot^-1*k_ku*u(t) + I*q'(t) + k_kqdot^-1*f_k = 0
+            #
+            # NOTE : Solving the kinematic differential equations here is not
+            # necessary and prevents the equations from being provided in fully
+            # implicit form.
+            f_k_explicit = k_kqdot.LUsolve(f_k)
+            k_ku_explicit = k_kqdot.LUsolve(k_ku)
+            self._qdot_u_map = dict(zip(qdot, -(k_ku_explicit*u + f_k_explicit)))
+
+            self._f_k = f_k_explicit.xreplace(uaux_zero)
+            self._k_ku = k_ku_explicit.xreplace(uaux_zero)
+            self._k_kqdot = eye(len(qdot))
+
+        else:
+            self._qdot_u_map = None
+            self._f_k_implicit = self._f_k = Matrix()
+            self._k_ku_implicit = self._k_ku = Matrix()
+            self._k_kqdot_implicit = self._k_kqdot = Matrix()
+
+    def _form_fr(self, fl):
+        """Form the generalized active force."""
+        if fl is not None and (len(fl) == 0 or not iterable(fl)):
+            raise ValueError('Force pairs must be supplied in an '
+                'non-empty iterable or None.')
+
+        N = self._inertial
+        # pull out relevant velocities for constructing partial velocities
+        vel_list, f_list = _f_list_parser(fl, N)
+        vel_list = [msubs(i, self._qdot_u_map) for i in vel_list]
+        f_list = [msubs(i, self._qdot_u_map) for i in f_list]
+
+        # Fill Fr with dot product of partial velocities and forces
+        o = len(self.u)
+        b = len(f_list)
+        FR = zeros(o, 1)
+        partials = partial_velocity(vel_list, self.u, N)
+        for i in range(o):
+            FR[i] = sum(partials[j][i] & f_list[j] for j in range(b))
+
+        # In case there are dependent speeds
+        if self._udep:
+            p = o - len(self._udep)
+            FRtilde = FR[:p, 0]
+            FRold = FR[p:o, 0]
+            FRtilde += self._Ars.T * FRold
+            FR = FRtilde
+
+        self._forcelist = fl
+        self._fr = FR
+        return FR
+
+    def _form_frstar(self, bl):
+        """Form the generalized inertia force."""
+
+        if not iterable(bl):
+            raise TypeError('Bodies must be supplied in an iterable.')
+
+        t = dynamicsymbols._t
+        N = self._inertial
+        # Dicts setting things to zero
+        udot_zero = {i: 0 for i in self._udot}
+        uaux_zero = {i: 0 for i in self._uaux}
+        uauxdot = [diff(i, t) for i in self._uaux]
+        uauxdot_zero = {i: 0 for i in uauxdot}
+        # Dictionary of q' and q'' to u and u'
+        q_ddot_u_map = {k.diff(t): v.diff(t) for (k, v) in
+                self._qdot_u_map.items()}
+        q_ddot_u_map.update(self._qdot_u_map)
+
+        # Fill up the list of partials: format is a list with num elements
+        # equal to number of entries in body list. Each of these elements is a
+        # list - either of length 1 for the translational components of
+        # particles or of length 2 for the translational and rotational
+        # components of rigid bodies. The inner most list is the list of
+        # partial velocities.
+        def get_partial_velocity(body):
+            if isinstance(body, RigidBody):
+                vlist = [body.masscenter.vel(N), body.frame.ang_vel_in(N)]
+            elif isinstance(body, Particle):
+                vlist = [body.point.vel(N),]
+            else:
+                raise TypeError('The body list may only contain either '
+                                'RigidBody or Particle as list elements.')
+            v = [msubs(vel, self._qdot_u_map) for vel in vlist]
+            return partial_velocity(v, self.u, N)
+        partials = [get_partial_velocity(body) for body in bl]
+
+        # Compute fr_star in two components:
+        # fr_star = -(MM*u' + nonMM)
+        o = len(self.u)
+        MM = zeros(o, o)
+        nonMM = zeros(o, 1)
+        zero_uaux = lambda expr: msubs(expr, uaux_zero)
+        zero_udot_uaux = lambda expr: msubs(msubs(expr, udot_zero), uaux_zero)
+        for i, body in enumerate(bl):
+            if isinstance(body, RigidBody):
+                M = zero_uaux(body.mass)
+                I = zero_uaux(body.central_inertia)
+                vel = zero_uaux(body.masscenter.vel(N))
+                omega = zero_uaux(body.frame.ang_vel_in(N))
+                acc = zero_udot_uaux(body.masscenter.acc(N))
+                inertial_force = (M.diff(t) * vel + M * acc)
+                inertial_torque = zero_uaux((I.dt(body.frame) & omega) +
+                    msubs(I & body.frame.ang_acc_in(N), udot_zero) +
+                    (omega ^ (I & omega)))
+                for j in range(o):
+                    tmp_vel = zero_uaux(partials[i][0][j])
+                    tmp_ang = zero_uaux(I & partials[i][1][j])
+                    for k in range(o):
+                        # translational
+                        MM[j, k] += M * (tmp_vel & partials[i][0][k])
+                        # rotational
+                        MM[j, k] += (tmp_ang & partials[i][1][k])
+                    nonMM[j] += inertial_force & partials[i][0][j]
+                    nonMM[j] += inertial_torque & partials[i][1][j]
+            else:
+                M = zero_uaux(body.mass)
+                vel = zero_uaux(body.point.vel(N))
+                acc = zero_udot_uaux(body.point.acc(N))
+                inertial_force = (M.diff(t) * vel + M * acc)
+                for j in range(o):
+                    temp = zero_uaux(partials[i][0][j])
+                    for k in range(o):
+                        MM[j, k] += M * (temp & partials[i][0][k])
+                    nonMM[j] += inertial_force & partials[i][0][j]
+        # Compose fr_star out of MM and nonMM
+        MM = zero_uaux(msubs(MM, q_ddot_u_map))
+        nonMM = msubs(msubs(nonMM, q_ddot_u_map),
+                udot_zero, uauxdot_zero, uaux_zero)
+        fr_star = -(MM * msubs(Matrix(self._udot), uauxdot_zero) + nonMM)
+
+        # If there are dependent speeds, we need to find fr_star_tilde
+        if self._udep:
+            p = o - len(self._udep)
+            fr_star_ind = fr_star[:p, 0]
+            fr_star_dep = fr_star[p:o, 0]
+            fr_star = fr_star_ind + (self._Ars.T * fr_star_dep)
+            # Apply the same to MM
+            MMi = MM[:p, :]
+            MMd = MM[p:o, :]
+            MM = MMi + (self._Ars.T * MMd)
+
+        self._bodylist = bl
+        self._frstar = fr_star
+        self._k_d = MM
+        self._f_d = -msubs(self._fr + self._frstar, udot_zero)
+        return fr_star
+
+    def to_linearizer(self):
+        """Returns an instance of the Linearizer class, initiated from the
+        data in the KanesMethod class. This may be more desirable than using
+        the linearize class method, as the Linearizer object will allow more
+        efficient recalculation (i.e. about varying operating points)."""
+
+        if (self._fr is None) or (self._frstar is None):
+            raise ValueError('Need to compute Fr, Fr* first.')
+
+        # Get required equation components. The Kane's method class breaks
+        # these into pieces. Need to reassemble
+        f_c = self._f_h
+        if self._f_nh and self._k_nh:
+            f_v = self._f_nh + self._k_nh*Matrix(self.u)
+        else:
+            f_v = Matrix()
+        if self._f_dnh and self._k_dnh:
+            f_a = self._f_dnh + self._k_dnh*Matrix(self._udot)
+        else:
+            f_a = Matrix()
+        # Dicts to sub to zero, for splitting up expressions
+        u_zero = {i: 0 for i in self.u}
+        ud_zero = {i: 0 for i in self._udot}
+        qd_zero = {i: 0 for i in self._qdot}
+        qd_u_zero = {i: 0 for i in Matrix([self._qdot, self.u])}
+        # Break the kinematic differential eqs apart into f_0 and f_1
+        f_0 = msubs(self._f_k, u_zero) + self._k_kqdot*Matrix(self._qdot)
+        f_1 = msubs(self._f_k, qd_zero) + self._k_ku*Matrix(self.u)
+        # Break the dynamic differential eqs into f_2 and f_3
+        f_2 = msubs(self._frstar, qd_u_zero)
+        f_3 = msubs(self._frstar, ud_zero) + self._fr
+        f_4 = zeros(len(f_2), 1)
+
+        # Get the required vector components
+        q = self.q
+        u = self.u
+        if self._qdep:
+            q_i = q[:-len(self._qdep)]
+        else:
+            q_i = q
+        q_d = self._qdep
+        if self._udep:
+            u_i = u[:-len(self._udep)]
+        else:
+            u_i = u
+        u_d = self._udep
+
+        # Form dictionary to set auxiliary speeds & their derivatives to 0.
+        uaux = self._uaux
+        uauxdot = uaux.diff(dynamicsymbols._t)
+        uaux_zero = {i: 0 for i in Matrix([uaux, uauxdot])}
+
+        # Checking for dynamic symbols outside the dynamic differential
+        # equations; throws error if there is.
+        sym_list = set(Matrix([q, self._qdot, u, self._udot, uaux, uauxdot]))
+        if any(find_dynamicsymbols(i, sym_list) for i in [self._k_kqdot,
+                self._k_ku, self._f_k, self._k_dnh, self._f_dnh, self._k_d]):
+            raise ValueError('Cannot have dynamicsymbols outside dynamic \
+                             forcing vector.')
+
+        # Find all other dynamic symbols, forming the forcing vector r.
+        # Sort r to make it canonical.
+        r = list(find_dynamicsymbols(msubs(self._f_d, uaux_zero), sym_list))
+        r.sort(key=default_sort_key)
+
+        # Check for any derivatives of variables in r that are also found in r.
+        for i in r:
+            if diff(i, dynamicsymbols._t) in r:
+                raise ValueError('Cannot have derivatives of specified \
+                                 quantities when linearizing forcing terms.')
+        return Linearizer(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i,
+                q_d, u_i, u_d, r)
+
+    # TODO : Remove `new_method` after 1.1 has been released.
+    def linearize(self, *, new_method=None, **kwargs):
+        """ Linearize the equations of motion about a symbolic operating point.
+
+        Explanation
+        ===========
+
+        If kwarg A_and_B is False (default), returns M, A, B, r for the
+        linearized form, M*[q', u']^T = A*[q_ind, u_ind]^T + B*r.
+
+        If kwarg A_and_B is True, returns A, B, r for the linearized form
+        dx = A*x + B*r, where x = [q_ind, u_ind]^T. Note that this is
+        computationally intensive if there are many symbolic parameters. For
+        this reason, it may be more desirable to use the default A_and_B=False,
+        returning M, A, and B. Values may then be substituted in to these
+        matrices, and the state space form found as
+        A = P.T*M.inv()*A, B = P.T*M.inv()*B, where P = Linearizer.perm_mat.
+
+        In both cases, r is found as all dynamicsymbols in the equations of
+        motion that are not part of q, u, q', or u'. They are sorted in
+        canonical form.
+
+        The operating points may be also entered using the ``op_point`` kwarg.
+        This takes a dictionary of {symbol: value}, or a an iterable of such
+        dictionaries. The values may be numeric or symbolic. The more values
+        you can specify beforehand, the faster this computation will run.
+
+        For more documentation, please see the ``Linearizer`` class."""
+        linearizer = self.to_linearizer()
+        result = linearizer.linearize(**kwargs)
+        return result + (linearizer.r,)
+
+    def kanes_equations(self, bodies=None, loads=None):
+        """ Method to form Kane's equations, Fr + Fr* = 0.
+
+        Explanation
+        ===========
+
+        Returns (Fr, Fr*). In the case where auxiliary generalized speeds are
+        present (say, s auxiliary speeds, o generalized speeds, and m motion
+        constraints) the length of the returned vectors will be o - m + s in
+        length. The first o - m equations will be the constrained Kane's
+        equations, then the s auxiliary Kane's equations. These auxiliary
+        equations can be accessed with the auxiliary_eqs property.
+
+        Parameters
+        ==========
+
+        bodies : iterable
+            An iterable of all RigidBody's and Particle's in the system.
+            A system must have at least one body.
+        loads : iterable
+            Takes in an iterable of (Particle, Vector) or (ReferenceFrame, Vector)
+            tuples which represent the force at a point or torque on a frame.
+            Must be either a non-empty iterable of tuples or None which corresponds
+            to a system with no constraints.
+        """
+        if bodies is None:
+            bodies = self.bodies
+        if  loads is None and self._forcelist is not None:
+            loads = self._forcelist
+        if loads == []:
+            loads = None
+        if not self._k_kqdot:
+            raise AttributeError('Create an instance of KanesMethod with '
+                    'kinematic differential equations to use this method.')
+        fr = self._form_fr(loads)
+        frstar = self._form_frstar(bodies)
+        if self._uaux:
+            if not self._udep:
+                km = KanesMethod(self._inertial, self.q, self._uaux,
+                             u_auxiliary=self._uaux)
+            else:
+                km = KanesMethod(self._inertial, self.q, self._uaux,
+                        u_auxiliary=self._uaux, u_dependent=self._udep,
+                        velocity_constraints=(self._k_nh * self.u +
+                        self._f_nh),
+                        acceleration_constraints=(self._k_dnh * self._udot +
+                        self._f_dnh)
+                        )
+            km._qdot_u_map = self._qdot_u_map
+            self._km = km
+            fraux = km._form_fr(loads)
+            frstaraux = km._form_frstar(bodies)
+            self._aux_eq = fraux + frstaraux
+            self._fr = fr.col_join(fraux)
+            self._frstar = frstar.col_join(frstaraux)
+        return (self._fr, self._frstar)
+
+    def _form_eoms(self):
+        fr, frstar = self.kanes_equations(self.bodylist, self.forcelist)
+        return fr + frstar
+
+    def rhs(self, inv_method=None):
+        """Returns the system's equations of motion in first order form. The
+        output is the right hand side of::
+
+           x' = |q'| =: f(q, u, r, p, t)
+                |u'|
+
+        The right hand side is what is needed by most numerical ODE
+        integrators.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrices.MatrixBase.inv`
+
+        """
+        rhs = zeros(len(self.q) + len(self.u), 1)
+        kdes = self.kindiffdict()
+        for i, q_i in enumerate(self.q):
+            rhs[i] = kdes[q_i.diff()]
+
+        if inv_method is None:
+            rhs[len(self.q):, 0] = self.mass_matrix.LUsolve(self.forcing)
+        else:
+            rhs[len(self.q):, 0] = (self.mass_matrix.inv(inv_method,
+                                                         try_block_diag=True) *
+                                    self.forcing)
+
+        return rhs
+
+    def kindiffdict(self):
+        """Returns a dictionary mapping q' to u."""
+        if not self._qdot_u_map:
+            raise AttributeError('Create an instance of KanesMethod with '
+                    'kinematic differential equations to use this method.')
+        return self._qdot_u_map
+
+    @property
+    def auxiliary_eqs(self):
+        """A matrix containing the auxiliary equations."""
+        if not self._fr or not self._frstar:
+            raise ValueError('Need to compute Fr, Fr* first.')
+        if not self._uaux:
+            raise ValueError('No auxiliary speeds have been declared.')
+        return self._aux_eq
+
+    @property
+    def mass_matrix_kin(self):
+        r"""The kinematic "mass matrix" $\mathbf{k_{k\dot{q}}}$ of the system."""
+        return self._k_kqdot if self.explicit_kinematics else self._k_kqdot_implicit
+
+    @property
+    def forcing_kin(self):
+        """The kinematic "forcing vector" of the system."""
+        if self.explicit_kinematics:
+            return -(self._k_ku * Matrix(self.u) + self._f_k)
+        else:
+            return -(self._k_ku_implicit * Matrix(self.u) + self._f_k_implicit)
+
+    @property
+    def mass_matrix(self):
+        """The mass matrix of the system."""
+        if not self._fr or not self._frstar:
+            raise ValueError('Need to compute Fr, Fr* first.')
+        return Matrix([self._k_d, self._k_dnh])
+
+    @property
+    def forcing(self):
+        """The forcing vector of the system."""
+        if not self._fr or not self._frstar:
+            raise ValueError('Need to compute Fr, Fr* first.')
+        return -Matrix([self._f_d, self._f_dnh])
+
+    @property
+    def mass_matrix_full(self):
+        """The mass matrix of the system, augmented by the kinematic
+        differential equations in explicit or implicit form."""
+        if not self._fr or not self._frstar:
+            raise ValueError('Need to compute Fr, Fr* first.')
+        o, n = len(self.u), len(self.q)
+        return (self.mass_matrix_kin.row_join(zeros(n, o))).col_join(
+            zeros(o, n).row_join(self.mass_matrix))
+
+    @property
+    def forcing_full(self):
+        """The forcing vector of the system, augmented by the kinematic
+        differential equations in explicit or implicit form."""
+        return Matrix([self.forcing_kin, self.forcing])
+
+    @property
+    def q(self):
+        return self._q
+
+    @property
+    def u(self):
+        return self._u
+
+    @property
+    def bodylist(self):
+        return self._bodylist
+
+    @property
+    def forcelist(self):
+        return self._forcelist
+
+    @property
+    def bodies(self):
+        return self._bodylist
+
+    @property
+    def loads(self):
+        return self._forcelist

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/lagrange.py

@@ -0,0 +1,477 @@
+from sympy.core.backend import diff, zeros, Matrix, eye, sympify
+from sympy.core.sorting import default_sort_key
+from sympy.physics.vector import dynamicsymbols, ReferenceFrame
+from sympy.physics.mechanics.method import _Methods
+from sympy.physics.mechanics.functions import (
+    find_dynamicsymbols, msubs, _f_list_parser, _validate_coordinates)
+from sympy.physics.mechanics.linearize import Linearizer
+from sympy.utilities.iterables import iterable
+
+__all__ = ['LagrangesMethod']
+
+
+class LagrangesMethod(_Methods):
+    """Lagrange's method object.
+
+    Explanation
+    ===========
+
+    This object generates the equations of motion in a two step procedure. The
+    first step involves the initialization of LagrangesMethod by supplying the
+    Lagrangian and the generalized coordinates, at the bare minimum. If there
+    are any constraint equations, they can be supplied as keyword arguments.
+    The Lagrange multipliers are automatically generated and are equal in
+    number to the constraint equations. Similarly any non-conservative forces
+    can be supplied in an iterable (as described below and also shown in the
+    example) along with a ReferenceFrame. This is also discussed further in the
+    __init__ method.
+
+    Attributes
+    ==========
+
+    q, u : Matrix
+        Matrices of the generalized coordinates and speeds
+    loads : iterable
+        Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
+        describing the forces on the system.
+    bodies : iterable
+        Iterable containing the rigid bodies and particles of the system.
+    mass_matrix : Matrix
+        The system's mass matrix
+    forcing : Matrix
+        The system's forcing vector
+    mass_matrix_full : Matrix
+        The "mass matrix" for the qdot's, qdoubledot's, and the
+        lagrange multipliers (lam)
+    forcing_full : Matrix
+        The forcing vector for the qdot's, qdoubledot's and
+        lagrange multipliers (lam)
+
+    Examples
+    ========
+
+    This is a simple example for a one degree of freedom translational
+    spring-mass-damper.
+
+    In this example, we first need to do the kinematics.
+    This involves creating generalized coordinates and their derivatives.
+    Then we create a point and set its velocity in a frame.
+
+        >>> from sympy.physics.mechanics import LagrangesMethod, Lagrangian
+        >>> from sympy.physics.mechanics import ReferenceFrame, Particle, Point
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy import symbols
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> m, k, b = symbols('m k b')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> P.set_vel(N, qd * N.x)
+
+    We need to then prepare the information as required by LagrangesMethod to
+    generate equations of motion.
+    First we create the Particle, which has a point attached to it.
+    Following this the lagrangian is created from the kinetic and potential
+    energies.
+    Then, an iterable of nonconservative forces/torques must be constructed,
+    where each item is a (Point, Vector) or (ReferenceFrame, Vector) tuple,
+    with the Vectors representing the nonconservative forces or torques.
+
+        >>> Pa = Particle('Pa', P, m)
+        >>> Pa.potential_energy = k * q**2 / 2.0
+        >>> L = Lagrangian(N, Pa)
+        >>> fl = [(P, -b * qd * N.x)]
+
+    Finally we can generate the equations of motion.
+    First we create the LagrangesMethod object. To do this one must supply
+    the Lagrangian, and the generalized coordinates. The constraint equations,
+    the forcelist, and the inertial frame may also be provided, if relevant.
+    Next we generate Lagrange's equations of motion, such that:
+    Lagrange's equations of motion = 0.
+    We have the equations of motion at this point.
+
+        >>> l = LagrangesMethod(L, [q], forcelist = fl, frame = N)
+        >>> print(l.form_lagranges_equations())
+        Matrix([[b*Derivative(q(t), t) + 1.0*k*q(t) + m*Derivative(q(t), (t, 2))]])
+
+    We can also solve for the states using the 'rhs' method.
+
+        >>> print(l.rhs())
+        Matrix([[Derivative(q(t), t)], [(-b*Derivative(q(t), t) - 1.0*k*q(t))/m]])
+
+    Please refer to the docstrings on each method for more details.
+    """
+
+    def __init__(self, Lagrangian, qs, forcelist=None, bodies=None, frame=None,
+                 hol_coneqs=None, nonhol_coneqs=None):
+        """Supply the following for the initialization of LagrangesMethod.
+
+        Lagrangian : Sympifyable
+
+        qs : array_like
+            The generalized coordinates
+
+        hol_coneqs : array_like, optional
+            The holonomic constraint equations
+
+        nonhol_coneqs : array_like, optional
+            The nonholonomic constraint equations
+
+        forcelist : iterable, optional
+            Takes an iterable of (Point, Vector) or (ReferenceFrame, Vector)
+            tuples which represent the force at a point or torque on a frame.
+            This feature is primarily to account for the nonconservative forces
+            and/or moments.
+
+        bodies : iterable, optional
+            Takes an iterable containing the rigid bodies and particles of the
+            system.
+
+        frame : ReferenceFrame, optional
+            Supply the inertial frame. This is used to determine the
+            generalized forces due to non-conservative forces.
+        """
+
+        self._L = Matrix([sympify(Lagrangian)])
+        self.eom = None
+        self._m_cd = Matrix()           # Mass Matrix of differentiated coneqs
+        self._m_d = Matrix()            # Mass Matrix of dynamic equations
+        self._f_cd = Matrix()           # Forcing part of the diff coneqs
+        self._f_d = Matrix()            # Forcing part of the dynamic equations
+        self.lam_coeffs = Matrix()      # The coeffecients of the multipliers
+
+        forcelist = forcelist if forcelist else []
+        if not iterable(forcelist):
+            raise TypeError('Force pairs must be supplied in an iterable.')
+        self._forcelist = forcelist
+        if frame and not isinstance(frame, ReferenceFrame):
+            raise TypeError('frame must be a valid ReferenceFrame')
+        self._bodies = bodies
+        self.inertial = frame
+
+        self.lam_vec = Matrix()
+
+        self._term1 = Matrix()
+        self._term2 = Matrix()
+        self._term3 = Matrix()
+        self._term4 = Matrix()
+
+        # Creating the qs, qdots and qdoubledots
+        if not iterable(qs):
+            raise TypeError('Generalized coordinates must be an iterable')
+        self._q = Matrix(qs)
+        self._qdots = self.q.diff(dynamicsymbols._t)
+        self._qdoubledots = self._qdots.diff(dynamicsymbols._t)
+        _validate_coordinates(self.q)
+
+        mat_build = lambda x: Matrix(x) if x else Matrix()
+        hol_coneqs = mat_build(hol_coneqs)
+        nonhol_coneqs = mat_build(nonhol_coneqs)
+        self.coneqs = Matrix([hol_coneqs.diff(dynamicsymbols._t),
+                nonhol_coneqs])
+        self._hol_coneqs = hol_coneqs
+
+    def form_lagranges_equations(self):
+        """Method to form Lagrange's equations of motion.
+
+        Returns a vector of equations of motion using Lagrange's equations of
+        the second kind.
+        """
+
+        qds = self._qdots
+        qdd_zero = {i: 0 for i in self._qdoubledots}
+        n = len(self.q)
+
+        # Internally we represent the EOM as four terms:
+        # EOM = term1 - term2 - term3 - term4 = 0
+
+        # First term
+        self._term1 = self._L.jacobian(qds)
+        self._term1 = self._term1.diff(dynamicsymbols._t).T
+
+        # Second term
+        self._term2 = self._L.jacobian(self.q).T
+
+        # Third term
+        if self.coneqs:
+            coneqs = self.coneqs
+            m = len(coneqs)
+            # Creating the multipliers
+            self.lam_vec = Matrix(dynamicsymbols('lam1:' + str(m + 1)))
+            self.lam_coeffs = -coneqs.jacobian(qds)
+            self._term3 = self.lam_coeffs.T * self.lam_vec
+            # Extracting the coeffecients of the qdds from the diff coneqs
+            diffconeqs = coneqs.diff(dynamicsymbols._t)
+            self._m_cd = diffconeqs.jacobian(self._qdoubledots)
+            # The remaining terms i.e. the 'forcing' terms in diff coneqs
+            self._f_cd = -diffconeqs.subs(qdd_zero)
+        else:
+            self._term3 = zeros(n, 1)
+
+        # Fourth term
+        if self.forcelist:
+            N = self.inertial
+            self._term4 = zeros(n, 1)
+            for i, qd in enumerate(qds):
+                flist = zip(*_f_list_parser(self.forcelist, N))
+                self._term4[i] = sum(v.diff(qd, N) & f for (v, f) in flist)
+        else:
+            self._term4 = zeros(n, 1)
+
+        # Form the dynamic mass and forcing matrices
+        without_lam = self._term1 - self._term2 - self._term4
+        self._m_d = without_lam.jacobian(self._qdoubledots)
+        self._f_d = -without_lam.subs(qdd_zero)
+
+        # Form the EOM
+        self.eom = without_lam - self._term3
+        return self.eom
+
+    def _form_eoms(self):
+        return self.form_lagranges_equations()
+
+    @property
+    def mass_matrix(self):
+        """Returns the mass matrix, which is augmented by the Lagrange
+        multipliers, if necessary.
+
+        Explanation
+        ===========
+
+        If the system is described by 'n' generalized coordinates and there are
+        no constraint equations then an n X n matrix is returned.
+
+        If there are 'n' generalized coordinates and 'm' constraint equations
+        have been supplied during initialization then an n X (n+m) matrix is
+        returned. The (n + m - 1)th and (n + m)th columns contain the
+        coefficients of the Lagrange multipliers.
+        """
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        if self.coneqs:
+            return (self._m_d).row_join(self.lam_coeffs.T)
+        else:
+            return self._m_d
+
+    @property
+    def mass_matrix_full(self):
+        """Augments the coefficients of qdots to the mass_matrix."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        n = len(self.q)
+        m = len(self.coneqs)
+        row1 = eye(n).row_join(zeros(n, n + m))
+        row2 = zeros(n, n).row_join(self.mass_matrix)
+        if self.coneqs:
+            row3 = zeros(m, n).row_join(self._m_cd).row_join(zeros(m, m))
+            return row1.col_join(row2).col_join(row3)
+        else:
+            return row1.col_join(row2)
+
+    @property
+    def forcing(self):
+        """Returns the forcing vector from 'lagranges_equations' method."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        return self._f_d
+
+    @property
+    def forcing_full(self):
+        """Augments qdots to the forcing vector above."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        if self.coneqs:
+            return self._qdots.col_join(self.forcing).col_join(self._f_cd)
+        else:
+            return self._qdots.col_join(self.forcing)
+
+    def to_linearizer(self, q_ind=None, qd_ind=None, q_dep=None, qd_dep=None):
+        """Returns an instance of the Linearizer class, initiated from the
+        data in the LagrangesMethod class. This may be more desirable than using
+        the linearize class method, as the Linearizer object will allow more
+        efficient recalculation (i.e. about varying operating points).
+
+        Parameters
+        ==========
+
+        q_ind, qd_ind : array_like, optional
+            The independent generalized coordinates and speeds.
+        q_dep, qd_dep : array_like, optional
+            The dependent generalized coordinates and speeds.
+        """
+
+        # Compose vectors
+        t = dynamicsymbols._t
+        q = self.q
+        u = self._qdots
+        ud = u.diff(t)
+        # Get vector of lagrange multipliers
+        lams = self.lam_vec
+
+        mat_build = lambda x: Matrix(x) if x else Matrix()
+        q_i = mat_build(q_ind)
+        q_d = mat_build(q_dep)
+        u_i = mat_build(qd_ind)
+        u_d = mat_build(qd_dep)
+
+        # Compose general form equations
+        f_c = self._hol_coneqs
+        f_v = self.coneqs
+        f_a = f_v.diff(t)
+        f_0 = u
+        f_1 = -u
+        f_2 = self._term1
+        f_3 = -(self._term2 + self._term4)
+        f_4 = -self._term3
+
+        # Check that there are an appropriate number of independent and
+        # dependent coordinates
+        if len(q_d) != len(f_c) or len(u_d) != len(f_v):
+            raise ValueError(("Must supply {:} dependent coordinates, and " +
+                    "{:} dependent speeds").format(len(f_c), len(f_v)))
+        if set(Matrix([q_i, q_d])) != set(q):
+            raise ValueError("Must partition q into q_ind and q_dep, with " +
+                    "no extra or missing symbols.")
+        if set(Matrix([u_i, u_d])) != set(u):
+            raise ValueError("Must partition qd into qd_ind and qd_dep, " +
+                    "with no extra or missing symbols.")
+
+        # Find all other dynamic symbols, forming the forcing vector r.
+        # Sort r to make it canonical.
+        insyms = set(Matrix([q, u, ud, lams]))
+        r = list(find_dynamicsymbols(f_3, insyms))
+        r.sort(key=default_sort_key)
+        # Check for any derivatives of variables in r that are also found in r.
+        for i in r:
+            if diff(i, dynamicsymbols._t) in r:
+                raise ValueError('Cannot have derivatives of specified \
+                                 quantities when linearizing forcing terms.')
+
+        return Linearizer(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i,
+                q_d, u_i, u_d, r, lams)
+
+    def linearize(self, q_ind=None, qd_ind=None, q_dep=None, qd_dep=None,
+            **kwargs):
+        """Linearize the equations of motion about a symbolic operating point.
+
+        Explanation
+        ===========
+
+        If kwarg A_and_B is False (default), returns M, A, B, r for the
+        linearized form, M*[q', u']^T = A*[q_ind, u_ind]^T + B*r.
+
+        If kwarg A_and_B is True, returns A, B, r for the linearized form
+        dx = A*x + B*r, where x = [q_ind, u_ind]^T. Note that this is
+        computationally intensive if there are many symbolic parameters. For
+        this reason, it may be more desirable to use the default A_and_B=False,
+        returning M, A, and B. Values may then be substituted in to these
+        matrices, and the state space form found as
+        A = P.T*M.inv()*A, B = P.T*M.inv()*B, where P = Linearizer.perm_mat.
+
+        In both cases, r is found as all dynamicsymbols in the equations of
+        motion that are not part of q, u, q', or u'. They are sorted in
+        canonical form.
+
+        The operating points may be also entered using the ``op_point`` kwarg.
+        This takes a dictionary of {symbol: value}, or a an iterable of such
+        dictionaries. The values may be numeric or symbolic. The more values
+        you can specify beforehand, the faster this computation will run.
+
+        For more documentation, please see the ``Linearizer`` class."""
+
+        linearizer = self.to_linearizer(q_ind, qd_ind, q_dep, qd_dep)
+        result = linearizer.linearize(**kwargs)
+        return result + (linearizer.r,)
+
+    def solve_multipliers(self, op_point=None, sol_type='dict'):
+        """Solves for the values of the lagrange multipliers symbolically at
+        the specified operating point.
+
+        Parameters
+        ==========
+
+        op_point : dict or iterable of dicts, optional
+            Point at which to solve at. The operating point is specified as
+            a dictionary or iterable of dictionaries of {symbol: value}. The
+            value may be numeric or symbolic itself.
+
+        sol_type : str, optional
+            Solution return type. Valid options are:
+            - 'dict': A dict of {symbol : value} (default)
+            - 'Matrix': An ordered column matrix of the solution
+        """
+
+        # Determine number of multipliers
+        k = len(self.lam_vec)
+        if k == 0:
+            raise ValueError("System has no lagrange multipliers to solve for.")
+        # Compose dict of operating conditions
+        if isinstance(op_point, dict):
+            op_point_dict = op_point
+        elif iterable(op_point):
+            op_point_dict = {}
+            for op in op_point:
+                op_point_dict.update(op)
+        elif op_point is None:
+            op_point_dict = {}
+        else:
+            raise TypeError("op_point must be either a dictionary or an "
+                            "iterable of dictionaries.")
+        # Compose the system to be solved
+        mass_matrix = self.mass_matrix.col_join(-self.lam_coeffs.row_join(
+                zeros(k, k)))
+        force_matrix = self.forcing.col_join(self._f_cd)
+        # Sub in the operating point
+        mass_matrix = msubs(mass_matrix, op_point_dict)
+        force_matrix = msubs(force_matrix, op_point_dict)
+        # Solve for the multipliers
+        sol_list = mass_matrix.LUsolve(-force_matrix)[-k:]
+        if sol_type == 'dict':
+            return dict(zip(self.lam_vec, sol_list))
+        elif sol_type == 'Matrix':
+            return Matrix(sol_list)
+        else:
+            raise ValueError("Unknown sol_type {:}.".format(sol_type))
+
+    def rhs(self, inv_method=None, **kwargs):
+        """Returns equations that can be solved numerically.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrices.MatrixBase.inv`
+        """
+
+        if inv_method is None:
+            self._rhs = self.mass_matrix_full.LUsolve(self.forcing_full)
+        else:
+            self._rhs = (self.mass_matrix_full.inv(inv_method,
+                         try_block_diag=True) * self.forcing_full)
+        return self._rhs
+
+    @property
+    def q(self):
+        return self._q
+
+    @property
+    def u(self):
+        return self._qdots
+
+    @property
+    def bodies(self):
+        return self._bodies
+
+    @property
+    def forcelist(self):
+        return self._forcelist
+
+    @property
+    def loads(self):
+        return self._forcelist

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/linearize.py

@@ -0,0 +1,443 @@
+__all__ = ['Linearizer']
+
+from sympy.core.backend import Matrix, eye, zeros
+from sympy.core.symbol import Dummy
+from sympy.utilities.iterables import flatten
+from sympy.physics.vector import dynamicsymbols
+from sympy.physics.mechanics.functions import msubs
+
+from collections import namedtuple
+from collections.abc import Iterable
+
+class Linearizer:
+    """This object holds the general model form for a dynamic system.
+    This model is used for computing the linearized form of the system,
+    while properly dealing with constraints leading to  dependent
+    coordinates and speeds.
+
+    Attributes
+    ==========
+
+    f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a : Matrix
+        Matrices holding the general system form.
+    q, u, r : Matrix
+        Matrices holding the generalized coordinates, speeds, and
+        input vectors.
+    q_i, u_i : Matrix
+        Matrices of the independent generalized coordinates and speeds.
+    q_d, u_d : Matrix
+        Matrices of the dependent generalized coordinates and speeds.
+    perm_mat : Matrix
+        Permutation matrix such that [q_ind, u_ind]^T = perm_mat*[q, u]^T
+    """
+
+    def __init__(self, f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u,
+            q_i=None, q_d=None, u_i=None, u_d=None, r=None, lams=None):
+        """
+        Parameters
+        ==========
+
+        f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a : array_like
+            System of equations holding the general system form.
+            Supply empty array or Matrix if the parameter
+            does not exist.
+        q : array_like
+            The generalized coordinates.
+        u : array_like
+            The generalized speeds
+        q_i, u_i : array_like, optional
+            The independent generalized coordinates and speeds.
+        q_d, u_d : array_like, optional
+            The dependent generalized coordinates and speeds.
+        r : array_like, optional
+            The input variables.
+        lams : array_like, optional
+            The lagrange multipliers
+        """
+
+        # Generalized equation form
+        self.f_0 = Matrix(f_0)
+        self.f_1 = Matrix(f_1)
+        self.f_2 = Matrix(f_2)
+        self.f_3 = Matrix(f_3)
+        self.f_4 = Matrix(f_4)
+        self.f_c = Matrix(f_c)
+        self.f_v = Matrix(f_v)
+        self.f_a = Matrix(f_a)
+
+        # Generalized equation variables
+        self.q = Matrix(q)
+        self.u = Matrix(u)
+        none_handler = lambda x: Matrix(x) if x else Matrix()
+        self.q_i = none_handler(q_i)
+        self.q_d = none_handler(q_d)
+        self.u_i = none_handler(u_i)
+        self.u_d = none_handler(u_d)
+        self.r = none_handler(r)
+        self.lams = none_handler(lams)
+
+        # Derivatives of generalized equation variables
+        self._qd = self.q.diff(dynamicsymbols._t)
+        self._ud = self.u.diff(dynamicsymbols._t)
+        # If the user doesn't actually use generalized variables, and the
+        # qd and u vectors have any intersecting variables, this can cause
+        # problems. We'll fix this with some hackery, and Dummy variables
+        dup_vars = set(self._qd).intersection(self.u)
+        self._qd_dup = Matrix([var if var not in dup_vars else Dummy()
+            for var in self._qd])
+
+        # Derive dimesion terms
+        l = len(self.f_c)
+        m = len(self.f_v)
+        n = len(self.q)
+        o = len(self.u)
+        s = len(self.r)
+        k = len(self.lams)
+        dims = namedtuple('dims', ['l', 'm', 'n', 'o', 's', 'k'])
+        self._dims = dims(l, m, n, o, s, k)
+
+        self._Pq = None
+        self._Pqi = None
+        self._Pqd = None
+        self._Pu = None
+        self._Pui = None
+        self._Pud = None
+        self._C_0 = None
+        self._C_1 = None
+        self._C_2 = None
+        self.perm_mat = None
+
+        self._setup_done = False
+
+    def _setup(self):
+        # Calculations here only need to be run once. They are moved out of
+        # the __init__ method to increase the speed of Linearizer creation.
+        self._form_permutation_matrices()
+        self._form_block_matrices()
+        self._form_coefficient_matrices()
+        self._setup_done = True
+
+    def _form_permutation_matrices(self):
+        """Form the permutation matrices Pq and Pu."""
+
+        # Extract dimension variables
+        l, m, n, o, s, k = self._dims
+        # Compute permutation matrices
+        if n != 0:
+            self._Pq = permutation_matrix(self.q, Matrix([self.q_i, self.q_d]))
+            if l > 0:
+                self._Pqi = self._Pq[:, :-l]
+                self._Pqd = self._Pq[:, -l:]
+            else:
+                self._Pqi = self._Pq
+                self._Pqd = Matrix()
+        if o != 0:
+            self._Pu = permutation_matrix(self.u, Matrix([self.u_i, self.u_d]))
+            if m > 0:
+                self._Pui = self._Pu[:, :-m]
+                self._Pud = self._Pu[:, -m:]
+            else:
+                self._Pui = self._Pu
+                self._Pud = Matrix()
+        # Compute combination permutation matrix for computing A and B
+        P_col1 = Matrix([self._Pqi, zeros(o + k, n - l)])
+        P_col2 = Matrix([zeros(n, o - m), self._Pui, zeros(k, o - m)])
+        if P_col1:
+            if P_col2:
+                self.perm_mat = P_col1.row_join(P_col2)
+            else:
+                self.perm_mat = P_col1
+        else:
+            self.perm_mat = P_col2
+
+    def _form_coefficient_matrices(self):
+        """Form the coefficient matrices C_0, C_1, and C_2."""
+
+        # Extract dimension variables
+        l, m, n, o, s, k = self._dims
+        # Build up the coefficient matrices C_0, C_1, and C_2
+        # If there are configuration constraints (l > 0), form C_0 as normal.
+        # If not, C_0 is I_(nxn). Note that this works even if n=0
+        if l > 0:
+            f_c_jac_q = self.f_c.jacobian(self.q)
+            self._C_0 = (eye(n) - self._Pqd * (f_c_jac_q *
+                    self._Pqd).LUsolve(f_c_jac_q)) * self._Pqi
+        else:
+            self._C_0 = eye(n)
+        # If there are motion constraints (m > 0), form C_1 and C_2 as normal.
+        # If not, C_1 is 0, and C_2 is I_(oxo). Note that this works even if
+        # o = 0.
+        if m > 0:
+            f_v_jac_u = self.f_v.jacobian(self.u)
+            temp = f_v_jac_u * self._Pud
+            if n != 0:
+                f_v_jac_q = self.f_v.jacobian(self.q)
+                self._C_1 = -self._Pud * temp.LUsolve(f_v_jac_q)
+            else:
+                self._C_1 = zeros(o, n)
+            self._C_2 = (eye(o) - self._Pud *
+                    temp.LUsolve(f_v_jac_u)) * self._Pui
+        else:
+            self._C_1 = zeros(o, n)
+            self._C_2 = eye(o)
+
+    def _form_block_matrices(self):
+        """Form the block matrices for composing M, A, and B."""
+
+        # Extract dimension variables
+        l, m, n, o, s, k = self._dims
+        # Block Matrix Definitions. These are only defined if under certain
+        # conditions. If undefined, an empty matrix is used instead
+        if n != 0:
+            self._M_qq = self.f_0.jacobian(self._qd)
+            self._A_qq = -(self.f_0 + self.f_1).jacobian(self.q)
+        else:
+            self._M_qq = Matrix()
+            self._A_qq = Matrix()
+        if n != 0 and m != 0:
+            self._M_uqc = self.f_a.jacobian(self._qd_dup)
+            self._A_uqc = -self.f_a.jacobian(self.q)
+        else:
+            self._M_uqc = Matrix()
+            self._A_uqc = Matrix()
+        if n != 0 and o - m + k != 0:
+            self._M_uqd = self.f_3.jacobian(self._qd_dup)
+            self._A_uqd = -(self.f_2 + self.f_3 + self.f_4).jacobian(self.q)
+        else:
+            self._M_uqd = Matrix()
+            self._A_uqd = Matrix()
+        if o != 0 and m != 0:
+            self._M_uuc = self.f_a.jacobian(self._ud)
+            self._A_uuc = -self.f_a.jacobian(self.u)
+        else:
+            self._M_uuc = Matrix()
+            self._A_uuc = Matrix()
+        if o != 0 and o - m + k != 0:
+            self._M_uud = self.f_2.jacobian(self._ud)
+            self._A_uud = -(self.f_2 + self.f_3).jacobian(self.u)
+        else:
+            self._M_uud = Matrix()
+            self._A_uud = Matrix()
+        if o != 0 and n != 0:
+            self._A_qu = -self.f_1.jacobian(self.u)
+        else:
+            self._A_qu = Matrix()
+        if k != 0 and o - m + k != 0:
+            self._M_uld = self.f_4.jacobian(self.lams)
+        else:
+            self._M_uld = Matrix()
+        if s != 0 and o - m + k != 0:
+            self._B_u = -self.f_3.jacobian(self.r)
+        else:
+            self._B_u = Matrix()
+
+    def linearize(self, op_point=None, A_and_B=False, simplify=False):
+        """Linearize the system about the operating point. Note that
+        q_op, u_op, qd_op, ud_op must satisfy the equations of motion.
+        These may be either symbolic or numeric.
+
+        Parameters
+        ==========
+
+        op_point : dict or iterable of dicts, optional
+            Dictionary or iterable of dictionaries containing the operating
+            point conditions. These will be substituted in to the linearized
+            system before the linearization is complete. Leave blank if you
+            want a completely symbolic form. Note that any reduction in
+            symbols (whether substituted for numbers or expressions with a
+            common parameter) will result in faster runtime.
+
+        A_and_B : bool, optional
+            If A_and_B=False (default), (M, A, B) is returned for forming
+            [M]*[q, u]^T = [A]*[q_ind, u_ind]^T + [B]r. If A_and_B=True,
+            (A, B) is returned for forming dx = [A]x + [B]r, where
+            x = [q_ind, u_ind]^T.
+
+        simplify : bool, optional
+            Determines if returned values are simplified before return.
+            For large expressions this may be time consuming. Default is False.
+
+        Potential Issues
+        ================
+
+            Note that the process of solving with A_and_B=True is
+            computationally intensive if there are many symbolic parameters.
+            For this reason, it may be more desirable to use the default
+            A_and_B=False, returning M, A, and B. More values may then be
+            substituted in to these matrices later on. The state space form can
+            then be found as A = P.T*M.LUsolve(A), B = P.T*M.LUsolve(B), where
+            P = Linearizer.perm_mat.
+        """
+
+        # Run the setup if needed:
+        if not self._setup_done:
+            self._setup()
+
+        # Compose dict of operating conditions
+        if isinstance(op_point, dict):
+            op_point_dict = op_point
+        elif isinstance(op_point, Iterable):
+            op_point_dict = {}
+            for op in op_point:
+                op_point_dict.update(op)
+        else:
+            op_point_dict = {}
+
+        # Extract dimension variables
+        l, m, n, o, s, k = self._dims
+
+        # Rename terms to shorten expressions
+        M_qq = self._M_qq
+        M_uqc = self._M_uqc
+        M_uqd = self._M_uqd
+        M_uuc = self._M_uuc
+        M_uud = self._M_uud
+        M_uld = self._M_uld
+        A_qq = self._A_qq
+        A_uqc = self._A_uqc
+        A_uqd = self._A_uqd
+        A_qu = self._A_qu
+        A_uuc = self._A_uuc
+        A_uud = self._A_uud
+        B_u = self._B_u
+        C_0 = self._C_0
+        C_1 = self._C_1
+        C_2 = self._C_2
+
+        # Build up Mass Matrix
+        #     |M_qq    0_nxo   0_nxk|
+        # M = |M_uqc   M_uuc   0_mxk|
+        #     |M_uqd   M_uud   M_uld|
+        if o != 0:
+            col2 = Matrix([zeros(n, o), M_uuc, M_uud])
+        if k != 0:
+            col3 = Matrix([zeros(n + m, k), M_uld])
+        if n != 0:
+            col1 = Matrix([M_qq, M_uqc, M_uqd])
+            if o != 0 and k != 0:
+                M = col1.row_join(col2).row_join(col3)
+            elif o != 0:
+                M = col1.row_join(col2)
+            else:
+                M = col1
+        elif k != 0:
+            M = col2.row_join(col3)
+        else:
+            M = col2
+        M_eq = msubs(M, op_point_dict)
+
+        # Build up state coefficient matrix A
+        #     |(A_qq + A_qu*C_1)*C_0       A_qu*C_2|
+        # A = |(A_uqc + A_uuc*C_1)*C_0    A_uuc*C_2|
+        #     |(A_uqd + A_uud*C_1)*C_0    A_uud*C_2|
+        # Col 1 is only defined if n != 0
+        if n != 0:
+            r1c1 = A_qq
+            if o != 0:
+                r1c1 += (A_qu * C_1)
+            r1c1 = r1c1 * C_0
+            if m != 0:
+                r2c1 = A_uqc
+                if o != 0:
+                    r2c1 += (A_uuc * C_1)
+                r2c1 = r2c1 * C_0
+            else:
+                r2c1 = Matrix()
+            if o - m + k != 0:
+                r3c1 = A_uqd
+                if o != 0:
+                    r3c1 += (A_uud * C_1)
+                r3c1 = r3c1 * C_0
+            else:
+                r3c1 = Matrix()
+            col1 = Matrix([r1c1, r2c1, r3c1])
+        else:
+            col1 = Matrix()
+        # Col 2 is only defined if o != 0
+        if o != 0:
+            if n != 0:
+                r1c2 = A_qu * C_2
+            else:
+                r1c2 = Matrix()
+            if m != 0:
+                r2c2 = A_uuc * C_2
+            else:
+                r2c2 = Matrix()
+            if o - m + k != 0:
+                r3c2 = A_uud * C_2
+            else:
+                r3c2 = Matrix()
+            col2 = Matrix([r1c2, r2c2, r3c2])
+        else:
+            col2 = Matrix()
+        if col1:
+            if col2:
+                Amat = col1.row_join(col2)
+            else:
+                Amat = col1
+        else:
+            Amat = col2
+        Amat_eq = msubs(Amat, op_point_dict)
+
+        # Build up the B matrix if there are forcing variables
+        #     |0_(n + m)xs|
+        # B = |B_u        |
+        if s != 0 and o - m + k != 0:
+            Bmat = zeros(n + m, s).col_join(B_u)
+            Bmat_eq = msubs(Bmat, op_point_dict)
+        else:
+            Bmat_eq = Matrix()
+
+        # kwarg A_and_B indicates to return  A, B for forming the equation
+        # dx = [A]x + [B]r, where x = [q_indnd, u_indnd]^T,
+        if A_and_B:
+            A_cont = self.perm_mat.T * M_eq.LUsolve(Amat_eq)
+            if Bmat_eq:
+                B_cont = self.perm_mat.T * M_eq.LUsolve(Bmat_eq)
+            else:
+                # Bmat = Matrix([]), so no need to sub
+                B_cont = Bmat_eq
+            if simplify:
+                A_cont.simplify()
+                B_cont.simplify()
+            return A_cont, B_cont
+        # Otherwise return M, A, B for forming the equation
+        # [M]dx = [A]x + [B]r, where x = [q, u]^T
+        else:
+            if simplify:
+                M_eq.simplify()
+                Amat_eq.simplify()
+                Bmat_eq.simplify()
+            return M_eq, Amat_eq, Bmat_eq
+
+
+def permutation_matrix(orig_vec, per_vec):
+    """Compute the permutation matrix to change order of
+    orig_vec into order of per_vec.
+
+    Parameters
+    ==========
+
+    orig_vec : array_like
+        Symbols in original ordering.
+    per_vec : array_like
+        Symbols in new ordering.
+
+    Returns
+    =======
+
+    p_matrix : Matrix
+        Permutation matrix such that orig_vec == (p_matrix * per_vec).
+    """
+    if not isinstance(orig_vec, (list, tuple)):
+        orig_vec = flatten(orig_vec)
+    if not isinstance(per_vec, (list, tuple)):
+        per_vec = flatten(per_vec)
+    if set(orig_vec) != set(per_vec):
+        raise ValueError("orig_vec and per_vec must be the same length, " +
+                "and contain the same symbols.")
+    ind_list = [orig_vec.index(i) for i in per_vec]
+    p_matrix = zeros(len(orig_vec))
+    for i, j in enumerate(ind_list):
+        p_matrix[i, j] = 1
+    return p_matrix

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/method.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+class _Methods(ABC):
+    """Abstract Base Class for all methods."""
+
+    @abstractmethod
+    def q(self):
+        pass
+
+    @abstractmethod
+    def u(self):
+        pass
+
+    @abstractmethod
+    def bodies(self):
+        pass
+
+    @abstractmethod
+    def loads(self):
+        pass
+
+    @abstractmethod
+    def mass_matrix(self):
+        pass
+
+    @abstractmethod
+    def forcing(self):
+        pass
+
+    @abstractmethod
+    def mass_matrix_full(self):
+        pass
+
+    @abstractmethod
+    def forcing_full(self):
+        pass
+
+    def _form_eoms(self):
+        raise NotImplementedError("Subclasses must implement this.")

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/models.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+"""This module contains some sample symbolic models used for testing and
+examples."""
+
+# Internal imports
+from sympy.core import backend as sm
+import sympy.physics.mechanics as me
+
+
+def multi_mass_spring_damper(n=1, apply_gravity=False,
+                             apply_external_forces=False):
+    r"""Returns a system containing the symbolic equations of motion and
+    associated variables for a simple multi-degree of freedom point mass,
+    spring, damper system with optional gravitational and external
+    specified forces. For example, a two mass system under the influence of
+    gravity and external forces looks like:
+
+    ::
+
+        ----------------
+         |     |     |   | g
+         \    | |    |   V
+      k0 /    --- c0 |
+         |     |     | x0, v0
+        ---------    V
+        |  m0   | -----
+        ---------    |
+         | |   |     |
+         \ v  | |    |
+      k1 / f0 --- c1 |
+         |     |     | x1, v1
+        ---------    V
+        |  m1   | -----
+        ---------
+           | f1
+           V
+
+    Parameters
+    ==========
+
+    n : integer
+        The number of masses in the serial chain.
+    apply_gravity : boolean
+        If true, gravity will be applied to each mass.
+    apply_external_forces : boolean
+        If true, a time varying external force will be applied to each mass.
+
+    Returns
+    =======
+
+    kane : sympy.physics.mechanics.kane.KanesMethod
+        A KanesMethod object.
+
+    """
+
+    mass = sm.symbols('m:{}'.format(n))
+    stiffness = sm.symbols('k:{}'.format(n))
+    damping = sm.symbols('c:{}'.format(n))
+
+    acceleration_due_to_gravity = sm.symbols('g')
+
+    coordinates = me.dynamicsymbols('x:{}'.format(n))
+    speeds = me.dynamicsymbols('v:{}'.format(n))
+    specifieds = me.dynamicsymbols('f:{}'.format(n))
+
+    ceiling = me.ReferenceFrame('N')
+    origin = me.Point('origin')
+    origin.set_vel(ceiling, 0)
+
+    points = [origin]
+    kinematic_equations = []
+    particles = []
+    forces = []
+
+    for i in range(n):
+
+        center = points[-1].locatenew('center{}'.format(i),
+                                      coordinates[i] * ceiling.x)
+        center.set_vel(ceiling, points[-1].vel(ceiling) +
+                       speeds[i] * ceiling.x)
+        points.append(center)
+
+        block = me.Particle('block{}'.format(i), center, mass[i])
+
+        kinematic_equations.append(speeds[i] - coordinates[i].diff())
+
+        total_force = (-stiffness[i] * coordinates[i] -
+                       damping[i] * speeds[i])
+        try:
+            total_force += (stiffness[i + 1] * coordinates[i + 1] +
+                            damping[i + 1] * speeds[i + 1])
+        except IndexError:  # no force from below on last mass
+            pass
+
+        if apply_gravity:
+            total_force += mass[i] * acceleration_due_to_gravity
+
+        if apply_external_forces:
+            total_force += specifieds[i]
+
+        forces.append((center, total_force * ceiling.x))
+
+        particles.append(block)
+
+    kane = me.KanesMethod(ceiling, q_ind=coordinates, u_ind=speeds,
+                          kd_eqs=kinematic_equations)
+    kane.kanes_equations(particles, forces)
+
+    return kane
+
+
+def n_link_pendulum_on_cart(n=1, cart_force=True, joint_torques=False):
+    r"""Returns the system containing the symbolic first order equations of
+    motion for a 2D n-link pendulum on a sliding cart under the influence of
+    gravity.
+
+    ::
+
+                  |
+         o    y   v
+          \ 0 ^   g
+           \  |
+          --\-|----
+          |  \|   |
+      F-> |   o --|---> x
+          |       |
+          ---------
+           o     o
+
+    Parameters
+    ==========
+
+    n : integer
+        The number of links in the pendulum.
+    cart_force : boolean, default=True
+        If true an external specified lateral force is applied to the cart.
+    joint_torques : boolean, default=False
+        If true joint torques will be added as specified inputs at each
+        joint.
+
+    Returns
+    =======
+
+    kane : sympy.physics.mechanics.kane.KanesMethod
+        A KanesMethod object.
+
+    Notes
+    =====
+
+    The degrees of freedom of the system are n + 1, i.e. one for each
+    pendulum link and one for the lateral motion of the cart.
+
+    M x' = F, where x = [u0, ..., un+1, q0, ..., qn+1]
+
+    The joint angles are all defined relative to the ground where the x axis
+    defines the ground line and the y axis points up. The joint torques are
+    applied between each adjacent link and the between the cart and the
+    lower link where a positive torque corresponds to positive angle.
+
+    """
+    if n <= 0:
+        raise ValueError('The number of links must be a positive integer.')
+
+    q = me.dynamicsymbols('q:{}'.format(n + 1))
+    u = me.dynamicsymbols('u:{}'.format(n + 1))
+
+    if joint_torques is True:
+        T = me.dynamicsymbols('T1:{}'.format(n + 1))
+
+    m = sm.symbols('m:{}'.format(n + 1))
+    l = sm.symbols('l:{}'.format(n))
+    g, t = sm.symbols('g t')
+
+    I = me.ReferenceFrame('I')
+    O = me.Point('O')
+    O.set_vel(I, 0)
+
+    P0 = me.Point('P0')
+    P0.set_pos(O, q[0] * I.x)
+    P0.set_vel(I, u[0] * I.x)
+    Pa0 = me.Particle('Pa0', P0, m[0])
+
+    frames = [I]
+    points = [P0]
+    particles = [Pa0]
+    forces = [(P0, -m[0] * g * I.y)]
+    kindiffs = [q[0].diff(t) - u[0]]
+
+    if cart_force is True or joint_torques is True:
+        specified = []
+    else:
+        specified = None
+
+    for i in range(n):
+        Bi = I.orientnew('B{}'.format(i), 'Axis', [q[i + 1], I.z])
+        Bi.set_ang_vel(I, u[i + 1] * I.z)
+        frames.append(Bi)
+
+        Pi = points[-1].locatenew('P{}'.format(i + 1), l[i] * Bi.y)
+        Pi.v2pt_theory(points[-1], I, Bi)
+        points.append(Pi)
+
+        Pai = me.Particle('Pa' + str(i + 1), Pi, m[i + 1])
+        particles.append(Pai)
+
+        forces.append((Pi, -m[i + 1] * g * I.y))
+
+        if joint_torques is True:
+
+            specified.append(T[i])
+
+            if i == 0:
+                forces.append((I, -T[i] * I.z))
+
+            if i == n - 1:
+                forces.append((Bi, T[i] * I.z))
+            else:
+                forces.append((Bi, T[i] * I.z - T[i + 1] * I.z))
+
+        kindiffs.append(q[i + 1].diff(t) - u[i + 1])
+
+    if cart_force is True:
+        F = me.dynamicsymbols('F')
+        forces.append((P0, F * I.x))
+        specified.append(F)
+
+    kane = me.KanesMethod(I, q_ind=q, u_ind=u, kd_eqs=kindiffs)
+    kane.kanes_equations(particles, forces)
+
+    return kane

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/particle.py

@@ -0,0 +1,281 @@
+from sympy.core.backend import sympify
+from sympy.physics.vector import Point
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['Particle']
+
+
+class Particle:
+    """A particle.
+
+    Explanation
+    ===========
+
+    Particles have a non-zero mass and lack spatial extension; they take up no
+    space.
+
+    Values need to be supplied on initialization, but can be changed later.
+
+    Parameters
+    ==========
+
+    name : str
+        Name of particle
+    point : Point
+        A physics/mechanics Point which represents the position, velocity, and
+        acceleration of this Particle
+    mass : sympifyable
+        A SymPy expression representing the Particle's mass
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Particle, Point
+    >>> from sympy import Symbol
+    >>> po = Point('po')
+    >>> m = Symbol('m')
+    >>> pa = Particle('pa', po, m)
+    >>> # Or you could change these later
+    >>> pa.mass = m
+    >>> pa.point = po
+
+    """
+
+    def __init__(self, name, point, mass):
+        if not isinstance(name, str):
+            raise TypeError('Supply a valid name.')
+        self._name = name
+        self.mass = mass
+        self.point = point
+        self.potential_energy = 0
+
+    def __str__(self):
+        return self._name
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def mass(self):
+        """Mass of the particle."""
+        return self._mass
+
+    @mass.setter
+    def mass(self, value):
+        self._mass = sympify(value)
+
+    @property
+    def point(self):
+        """Point of the particle."""
+        return self._point
+
+    @point.setter
+    def point(self, p):
+        if not isinstance(p, Point):
+            raise TypeError("Particle point attribute must be a Point object.")
+        self._point = p
+
+    def linear_momentum(self, frame):
+        """Linear momentum of the particle.
+
+        Explanation
+        ===========
+
+        The linear momentum L, of a particle P, with respect to frame N is
+        given by:
+
+        L = m * v
+
+        where m is the mass of the particle, and v is the velocity of the
+        particle in the frame N.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which linear momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> m, v = dynamicsymbols('m v')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> A = Particle('A', P, m)
+        >>> P.set_vel(N, v * N.x)
+        >>> A.linear_momentum(N)
+        m*v*N.x
+
+        """
+
+        return self.mass * self.point.vel(frame)
+
+    def angular_momentum(self, point, frame):
+        """Angular momentum of the particle about the point.
+
+        Explanation
+        ===========
+
+        The angular momentum H, about some point O of a particle, P, is given
+        by:
+
+        ``H = cross(r, m * v)``
+
+        where r is the position vector from point O to the particle P, m is
+        the mass of the particle, and v is the velocity of the particle in
+        the inertial frame, N.
+
+        Parameters
+        ==========
+
+        point : Point
+            The point about which angular momentum of the particle is desired.
+
+        frame : ReferenceFrame
+            The frame in which angular momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> m, v, r = dynamicsymbols('m v r')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> A = O.locatenew('A', r * N.x)
+        >>> P = Particle('P', A, m)
+        >>> P.point.set_vel(N, v * N.y)
+        >>> P.angular_momentum(O, N)
+        m*r*v*N.z
+
+        """
+
+        return self.point.pos_from(point) ^ (self.mass * self.point.vel(frame))
+
+    def kinetic_energy(self, frame):
+        """Kinetic energy of the particle.
+
+        Explanation
+        ===========
+
+        The kinetic energy, T, of a particle, P, is given by:
+
+        ``T = 1/2 (dot(m * v, v))``
+
+        where m is the mass of particle P, and v is the velocity of the
+        particle in the supplied ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The Particle's velocity is typically defined with respect to
+            an inertial frame but any relevant frame in which the velocity is
+            known can be supplied.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy import symbols
+        >>> m, v, r = symbols('m v r')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> P = Particle('P', O, m)
+        >>> P.point.set_vel(N, v * N.y)
+        >>> P.kinetic_energy(N)
+        m*v**2/2
+
+        """
+
+        return (self.mass / sympify(2) * self.point.vel(frame) &
+                self.point.vel(frame))
+
+    @property
+    def potential_energy(self):
+        """The potential energy of the Particle.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point
+        >>> from sympy import symbols
+        >>> m, g, h = symbols('m g h')
+        >>> O = Point('O')
+        >>> P = Particle('P', O, m)
+        >>> P.potential_energy = m * g * h
+        >>> P.potential_energy
+        g*h*m
+
+        """
+
+        return self._pe
+
+    @potential_energy.setter
+    def potential_energy(self, scalar):
+        """Used to set the potential energy of the Particle.
+
+        Parameters
+        ==========
+
+        scalar : Sympifyable
+            The potential energy (a scalar) of the Particle.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point
+        >>> from sympy import symbols
+        >>> m, g, h = symbols('m g h')
+        >>> O = Point('O')
+        >>> P = Particle('P', O, m)
+        >>> P.potential_energy = m * g * h
+
+        """
+
+        self._pe = sympify(scalar)
+
+    def set_potential_energy(self, scalar):
+        sympy_deprecation_warning(
+            """
+The sympy.physics.mechanics.Particle.set_potential_energy()
+method is deprecated. Instead use
+
+    P.potential_energy = scalar
+            """,
+        deprecated_since_version="1.5",
+        active_deprecations_target="deprecated-set-potential-energy",
+        )
+        self.potential_energy = scalar
+
+    def parallel_axis(self, point, frame):
+        """Returns an inertia dyadic of the particle with respect to another
+        point and frame.
+
+        Parameters
+        ==========
+
+        point : sympy.physics.vector.Point
+            The point to express the inertia dyadic about.
+        frame : sympy.physics.vector.ReferenceFrame
+            The reference frame used to construct the dyadic.
+
+        Returns
+        =======
+
+        inertia : sympy.physics.vector.Dyadic
+            The inertia dyadic of the particle expressed about the provided
+            point and frame.
+
+        """
+        # circular import issue
+        from sympy.physics.mechanics import inertia_of_point_mass
+        return inertia_of_point_mass(self.mass, self.point.pos_from(point),
+                                     frame)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/rigidbody.py

@@ -0,0 +1,366 @@
+from sympy.core.backend import sympify
+from sympy.physics.vector import Point, ReferenceFrame, Dyadic
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['RigidBody']
+
+
+class RigidBody:
+    """An idealized rigid body.
+
+    Explanation
+    ===========
+
+    This is essentially a container which holds the various components which
+    describe a rigid body: a name, mass, center of mass, reference frame, and
+    inertia.
+
+    All of these need to be supplied on creation, but can be changed
+    afterwards.
+
+    Attributes
+    ==========
+
+    name : string
+        The body's name.
+    masscenter : Point
+        The point which represents the center of mass of the rigid body.
+    frame : ReferenceFrame
+        The ReferenceFrame which the rigid body is fixed in.
+    mass : Sympifyable
+        The body's mass.
+    inertia : (Dyadic, Point)
+        The body's inertia about a point; stored in a tuple as shown above.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.physics.mechanics import ReferenceFrame, Point, RigidBody
+    >>> from sympy.physics.mechanics import outer
+    >>> m = Symbol('m')
+    >>> A = ReferenceFrame('A')
+    >>> P = Point('P')
+    >>> I = outer (A.x, A.x)
+    >>> inertia_tuple = (I, P)
+    >>> B = RigidBody('B', P, A, m, inertia_tuple)
+    >>> # Or you could change them afterwards
+    >>> m2 = Symbol('m2')
+    >>> B.mass = m2
+
+    """
+
+    def __init__(self, name, masscenter, frame, mass, inertia):
+        if not isinstance(name, str):
+            raise TypeError('Supply a valid name.')
+        self._name = name
+        self.masscenter = masscenter
+        self.mass = mass
+        self.frame = frame
+        self.inertia = inertia
+        self.potential_energy = 0
+
+    def __str__(self):
+        return self._name
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def frame(self):
+        """The ReferenceFrame fixed to the body."""
+        return self._frame
+
+    @frame.setter
+    def frame(self, F):
+        if not isinstance(F, ReferenceFrame):
+            raise TypeError("RigidBody frame must be a ReferenceFrame object.")
+        self._frame = F
+
+    @property
+    def masscenter(self):
+        """The body's center of mass."""
+        return self._masscenter
+
+    @masscenter.setter
+    def masscenter(self, p):
+        if not isinstance(p, Point):
+            raise TypeError("RigidBody center of mass must be a Point object.")
+        self._masscenter = p
+
+    @property
+    def mass(self):
+        """The body's mass."""
+        return self._mass
+
+    @mass.setter
+    def mass(self, m):
+        self._mass = sympify(m)
+
+    @property
+    def inertia(self):
+        """The body's inertia about a point; stored as (Dyadic, Point)."""
+        return (self._inertia, self._inertia_point)
+
+    @inertia.setter
+    def inertia(self, I):
+        if not isinstance(I[0], Dyadic):
+            raise TypeError("RigidBody inertia must be a Dyadic object.")
+        if not isinstance(I[1], Point):
+            raise TypeError("RigidBody inertia must be about a Point.")
+        self._inertia = I[0]
+        self._inertia_point = I[1]
+        # have I S/O, want I S/S*
+        # I S/O = I S/S* + I S*/O; I S/S* = I S/O - I S*/O
+        # I_S/S* = I_S/O - I_S*/O
+        from sympy.physics.mechanics.functions import inertia_of_point_mass
+        I_Ss_O = inertia_of_point_mass(self.mass,
+                                       self.masscenter.pos_from(I[1]),
+                                       self.frame)
+        self._central_inertia = I[0] - I_Ss_O
+
+    @property
+    def central_inertia(self):
+        """The body's central inertia dyadic."""
+        return self._central_inertia
+
+    @central_inertia.setter
+    def central_inertia(self, I):
+        if not isinstance(I, Dyadic):
+            raise TypeError("RigidBody inertia must be a Dyadic object.")
+        self.inertia = (I, self.masscenter)
+
+    def linear_momentum(self, frame):
+        """ Linear momentum of the rigid body.
+
+        Explanation
+        ===========
+
+        The linear momentum L, of a rigid body B, with respect to frame N is
+        given by:
+
+        L = M * v*
+
+        where M is the mass of the rigid body and v* is the velocity of
+        the mass center of B in the frame, N.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which linear momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
+        >>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> M, v = dynamicsymbols('M v')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> P.set_vel(N, v * N.x)
+        >>> I = outer (N.x, N.x)
+        >>> Inertia_tuple = (I, P)
+        >>> B = RigidBody('B', P, N, M, Inertia_tuple)
+        >>> B.linear_momentum(N)
+        M*v*N.x
+
+        """
+
+        return self.mass * self.masscenter.vel(frame)
+
+    def angular_momentum(self, point, frame):
+        """Returns the angular momentum of the rigid body about a point in the
+        given frame.
+
+        Explanation
+        ===========
+
+        The angular momentum H of a rigid body B about some point O in a frame
+        N is given by:
+
+        ``H = dot(I, w) + cross(r, M * v)``
+
+        where I is the central inertia dyadic of B, w is the angular velocity
+        of body B in the frame, N, r is the position vector from point O to the
+        mass center of B, and v is the velocity of the mass center in the
+        frame, N.
+
+        Parameters
+        ==========
+
+        point : Point
+            The point about which angular momentum is desired.
+        frame : ReferenceFrame
+            The frame in which angular momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
+        >>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> M, v, r, omega = dynamicsymbols('M v r omega')
+        >>> N = ReferenceFrame('N')
+        >>> b = ReferenceFrame('b')
+        >>> b.set_ang_vel(N, omega * b.x)
+        >>> P = Point('P')
+        >>> P.set_vel(N, 1 * N.x)
+        >>> I = outer(b.x, b.x)
+        >>> B = RigidBody('B', P, b, M, (I, P))
+        >>> B.angular_momentum(P, N)
+        omega*b.x
+
+        """
+        I = self.central_inertia
+        w = self.frame.ang_vel_in(frame)
+        m = self.mass
+        r = self.masscenter.pos_from(point)
+        v = self.masscenter.vel(frame)
+
+        return I.dot(w) + r.cross(m * v)
+
+    def kinetic_energy(self, frame):
+        """Kinetic energy of the rigid body.
+
+        Explanation
+        ===========
+
+        The kinetic energy, T, of a rigid body, B, is given by:
+
+        ``T = 1/2 * (dot(dot(I, w), w) + dot(m * v, v))``
+
+        where I and m are the central inertia dyadic and mass of rigid body B,
+        respectively, omega is the body's angular velocity and v is the
+        velocity of the body's mass center in the supplied ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The RigidBody's angular velocity and the velocity of it's mass
+            center are typically defined with respect to an inertial frame but
+            any relevant frame in which the velocities are known can be supplied.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
+        >>> from sympy.physics.mechanics import RigidBody
+        >>> from sympy import symbols
+        >>> M, v, r, omega = symbols('M v r omega')
+        >>> N = ReferenceFrame('N')
+        >>> b = ReferenceFrame('b')
+        >>> b.set_ang_vel(N, omega * b.x)
+        >>> P = Point('P')
+        >>> P.set_vel(N, v * N.x)
+        >>> I = outer (b.x, b.x)
+        >>> inertia_tuple = (I, P)
+        >>> B = RigidBody('B', P, b, M, inertia_tuple)
+        >>> B.kinetic_energy(N)
+        M*v**2/2 + omega**2/2
+
+        """
+
+        rotational_KE = (self.frame.ang_vel_in(frame) & (self.central_inertia &
+                self.frame.ang_vel_in(frame)) / sympify(2))
+
+        translational_KE = (self.mass * (self.masscenter.vel(frame) &
+            self.masscenter.vel(frame)) / sympify(2))
+
+        return rotational_KE + translational_KE
+
+    @property
+    def potential_energy(self):
+        """The potential energy of the RigidBody.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import RigidBody, Point, outer, ReferenceFrame
+        >>> from sympy import symbols
+        >>> M, g, h = symbols('M g h')
+        >>> b = ReferenceFrame('b')
+        >>> P = Point('P')
+        >>> I = outer (b.x, b.x)
+        >>> Inertia_tuple = (I, P)
+        >>> B = RigidBody('B', P, b, M, Inertia_tuple)
+        >>> B.potential_energy = M * g * h
+        >>> B.potential_energy
+        M*g*h
+
+        """
+
+        return self._pe
+
+    @potential_energy.setter
+    def potential_energy(self, scalar):
+        """Used to set the potential energy of this RigidBody.
+
+        Parameters
+        ==========
+
+        scalar: Sympifyable
+            The potential energy (a scalar) of the RigidBody.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Point, outer
+        >>> from sympy.physics.mechanics import RigidBody, ReferenceFrame
+        >>> from sympy import symbols
+        >>> b = ReferenceFrame('b')
+        >>> M, g, h = symbols('M g h')
+        >>> P = Point('P')
+        >>> I = outer (b.x, b.x)
+        >>> Inertia_tuple = (I, P)
+        >>> B = RigidBody('B', P, b, M, Inertia_tuple)
+        >>> B.potential_energy = M * g * h
+
+        """
+
+        self._pe = sympify(scalar)
+
+    def set_potential_energy(self, scalar):
+        sympy_deprecation_warning(
+            """
+The sympy.physics.mechanics.RigidBody.set_potential_energy()
+method is deprecated. Instead use
+
+    B.potential_energy = scalar
+            """,
+        deprecated_since_version="1.5",
+        active_deprecations_target="deprecated-set-potential-energy",
+        )
+        self.potential_energy = scalar
+
+    def parallel_axis(self, point, frame=None):
+        """Returns the inertia dyadic of the body with respect to another
+        point.
+
+        Parameters
+        ==========
+
+        point : sympy.physics.vector.Point
+            The point to express the inertia dyadic about.
+        frame : sympy.physics.vector.ReferenceFrame
+            The reference frame used to construct the dyadic.
+
+        Returns
+        =======
+
+        inertia : sympy.physics.vector.Dyadic
+            The inertia dyadic of the rigid body expressed about the provided
+            point.
+
+        """
+        # circular import issue
+        from sympy.physics.mechanics.functions import inertia_of_point_mass
+        if frame is None:
+            frame = self.frame
+        return self.central_inertia + inertia_of_point_mass(
+            self.mass, self.masscenter.pos_from(point), frame)

env-llmeval/lib/python3.10/site-packages/sympy/physics/mechanics/system.py

@@ -0,0 +1,445 @@
+from sympy.core.backend import eye, Matrix, zeros
+from sympy.physics.mechanics import dynamicsymbols
+from sympy.physics.mechanics.functions import find_dynamicsymbols
+
+__all__ = ['SymbolicSystem']
+
+
+class SymbolicSystem:
+    """SymbolicSystem is a class that contains all the information about a
+    system in a symbolic format such as the equations of motions and the bodies
+    and loads in the system.
+
+    There are three ways that the equations of motion can be described for
+    Symbolic System:
+
+
+        [1] Explicit form where the kinematics and dynamics are combined
+            x' = F_1(x, t, r, p)
+
+        [2] Implicit form where the kinematics and dynamics are combined
+            M_2(x, p) x' = F_2(x, t, r, p)
+
+        [3] Implicit form where the kinematics and dynamics are separate
+            M_3(q, p) u' = F_3(q, u, t, r, p)
+            q' = G(q, u, t, r, p)
+
+    where
+
+    x : states, e.g. [q, u]
+    t : time
+    r : specified (exogenous) inputs
+    p : constants
+    q : generalized coordinates
+    u : generalized speeds
+    F_1 : right hand side of the combined equations in explicit form
+    F_2 : right hand side of the combined equations in implicit form
+    F_3 : right hand side of the dynamical equations in implicit form
+    M_2 : mass matrix of the combined equations in implicit form
+    M_3 : mass matrix of the dynamical equations in implicit form
+    G : right hand side of the kinematical differential equations
+
+        Parameters
+        ==========
+
+        coord_states : ordered iterable of functions of time
+            This input will either be a collection of the coordinates or states
+            of the system depending on whether or not the speeds are also
+            given. If speeds are specified this input will be assumed to
+            be the coordinates otherwise this input will be assumed to
+            be the states.
+
+        right_hand_side : Matrix
+            This variable is the right hand side of the equations of motion in
+            any of the forms. The specific form will be assumed depending on
+            whether a mass matrix or coordinate derivatives are given.
+
+        speeds : ordered iterable of functions of time, optional
+            This is a collection of the generalized speeds of the system. If
+            given it will be assumed that the first argument (coord_states)
+            will represent the generalized coordinates of the system.
+
+        mass_matrix : Matrix, optional
+            The matrix of the implicit forms of the equations of motion (forms
+            [2] and [3]). The distinction between the forms is determined by
+            whether or not the coordinate derivatives are passed in. If
+            they are given form [3] will be assumed otherwise form [2] is
+            assumed.
+
+        coordinate_derivatives : Matrix, optional
+            The right hand side of the kinematical equations in explicit form.
+            If given it will be assumed that the equations of motion are being
+            entered in form [3].
+
+        alg_con : Iterable, optional
+            The indexes of the rows in the equations of motion that contain
+            algebraic constraints instead of differential equations. If the
+            equations are input in form [3], it will be assumed the indexes are
+            referencing the mass_matrix/right_hand_side combination and not the
+            coordinate_derivatives.
+
+        output_eqns : Dictionary, optional
+            Any output equations that are desired to be tracked are stored in a
+            dictionary where the key corresponds to the name given for the
+            specific equation and the value is the equation itself in symbolic
+            form
+
+        coord_idxs : Iterable, optional
+            If coord_states corresponds to the states rather than the
+            coordinates this variable will tell SymbolicSystem which indexes of
+            the states correspond to generalized coordinates.
+
+        speed_idxs : Iterable, optional
+            If coord_states corresponds to the states rather than the
+            coordinates this variable will tell SymbolicSystem which indexes of
+            the states correspond to generalized speeds.
+
+        bodies : iterable of Body/Rigidbody objects, optional
+            Iterable containing the bodies of the system
+
+        loads : iterable of load instances (described below), optional
+            Iterable containing the loads of the system where forces are given
+            by (point of application, force vector) and torques are given by
+            (reference frame acting upon, torque vector). Ex [(point, force),
+            (ref_frame, torque)]
+
+    Attributes
+    ==========
+
+    coordinates : Matrix, shape(n, 1)
+        This is a matrix containing the generalized coordinates of the system
+
+    speeds : Matrix, shape(m, 1)
+        This is a matrix containing the generalized speeds of the system
+
+    states : Matrix, shape(o, 1)
+        This is a matrix containing the state variables of the system
+
+    alg_con : List
+        This list contains the indices of the algebraic constraints in the
+        combined equations of motion. The presence of these constraints
+        requires that a DAE solver be used instead of an ODE solver.
+        If the system is given in form [3] the alg_con variable will be
+        adjusted such that it is a representation of the combined kinematics
+        and dynamics thus make sure it always matches the mass matrix
+        entered.
+
+    dyn_implicit_mat : Matrix, shape(m, m)
+        This is the M matrix in form [3] of the equations of motion (the mass
+        matrix or generalized inertia matrix of the dynamical equations of
+        motion in implicit form).
+
+    dyn_implicit_rhs : Matrix, shape(m, 1)
+        This is the F vector in form [3] of the equations of motion (the right
+        hand side of the dynamical equations of motion in implicit form).
+
+    comb_implicit_mat : Matrix, shape(o, o)
+        This is the M matrix in form [2] of the equations of motion.
+        This matrix contains a block diagonal structure where the top
+        left block (the first rows) represent the matrix in the
+        implicit form of the kinematical equations and the bottom right
+        block (the last rows) represent the matrix in the implicit form
+        of the dynamical equations.
+
+    comb_implicit_rhs : Matrix, shape(o, 1)
+        This is the F vector in form [2] of the equations of motion. The top
+        part of the vector represents the right hand side of the implicit form
+        of the kinemaical equations and the bottom of the vector represents the
+        right hand side of the implicit form of the dynamical equations of
+        motion.
+
+    comb_explicit_rhs : Matrix, shape(o, 1)
+        This vector represents the right hand side of the combined equations of
+        motion in explicit form (form [1] from above).
+
+    kin_explicit_rhs : Matrix, shape(m, 1)
+        This is the right hand side of the explicit form of the kinematical
+        equations of motion as can be seen in form [3] (the G matrix).
+
+    output_eqns : Dictionary
+        If output equations were given they are stored in a dictionary where
+        the key corresponds to the name given for the specific equation and
+        the value is the equation itself in symbolic form
+
+    bodies : Tuple
+        If the bodies in the system were given they are stored in a tuple for
+        future access
+
+    loads : Tuple
+        If the loads in the system were given they are stored in a tuple for
+        future access. This includes forces and torques where forces are given
+        by (point of application, force vector) and torques are given by
+        (reference frame acted upon, torque vector).
+
+    Example
+    =======
+
+    As a simple example, the dynamics of a simple pendulum will be input into a
+    SymbolicSystem object manually. First some imports will be needed and then
+    symbols will be set up for the length of the pendulum (l), mass at the end
+    of the pendulum (m), and a constant for gravity (g). ::
+
+        >>> from sympy import Matrix, sin, symbols
+        >>> from sympy.physics.mechanics import dynamicsymbols, SymbolicSystem
+        >>> l, m, g = symbols('l m g')
+
+    The system will be defined by an angle of theta from the vertical and a
+    generalized speed of omega will be used where omega = theta_dot. ::
+
+        >>> theta, omega = dynamicsymbols('theta omega')
+
+    Now the equations of motion are ready to be formed and passed to the
+    SymbolicSystem object. ::
+
+        >>> kin_explicit_rhs = Matrix([omega])
+        >>> dyn_implicit_mat = Matrix([l**2 * m])
+        >>> dyn_implicit_rhs = Matrix([-g * l * m * sin(theta)])
+        >>> symsystem = SymbolicSystem([theta], dyn_implicit_rhs, [omega],
+        ...                            dyn_implicit_mat)
+
+    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
+        if not isinstance(bodies, tuple) and bodies is not None:
+            bodies = tuple(bodies)
+        if not isinstance(loads, tuple) and loads is not None:
+            loads = tuple(loads)
+        self._bodies = bodies
+        self._loads = loads
+
+    @property
+    def coordinates(self):
+        """Returns the column matrix of the generalized coordinates"""
+        if self._coordinates is None:
+            raise AttributeError("The coordinates were not specified.")
+        else:
+            return self._coordinates
+
+    @property
+    def speeds(self):
+        """Returns the column matrix of generalized speeds"""
+        if self._speeds is None:
+            raise AttributeError("The speeds were not specified.")
+        else:
+            return self._speeds
+
+    @property
+    def states(self):
+        """Returns the column matrix of the state variables"""
+        return self._states
+
+    @property
+    def alg_con(self):
+        """Returns a list with the indices of the rows containing algebraic
+        constraints in the combined form of the equations of motion"""
+        return self._alg_con
+
+    @property
+    def dyn_implicit_mat(self):
+        """Returns the matrix, M, corresponding to the dynamic equations in
+        implicit form, M x' = F, where the kinematical equations are not
+        included"""
+        if self._dyn_implicit_mat is None:
+            raise AttributeError("dyn_implicit_mat is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._dyn_implicit_mat
+
+    @property
+    def dyn_implicit_rhs(self):
+        """Returns the column matrix, F, corresponding to the dynamic equations
+        in implicit form, M x' = F, where the kinematical equations are not
+        included"""
+        if self._dyn_implicit_rhs is None:
+            raise AttributeError("dyn_implicit_rhs is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._dyn_implicit_rhs
+
+    @property
+    def comb_implicit_mat(self):
+        """Returns the matrix, M, corresponding to the equations of motion in
+        implicit form (form [2]), M x' = F, where the kinematical equations are
+        included"""
+        if self._comb_implicit_mat is None:
+            if self._dyn_implicit_mat is not None:
+                num_kin_eqns = len(self._kin_explicit_rhs)
+                num_dyn_eqns = len(self._dyn_implicit_rhs)
+                zeros1 = zeros(num_kin_eqns, num_dyn_eqns)
+                zeros2 = zeros(num_dyn_eqns, num_kin_eqns)
+                inter1 = eye(num_kin_eqns).row_join(zeros1)
+                inter2 = zeros2.row_join(self._dyn_implicit_mat)
+                self._comb_implicit_mat = inter1.col_join(inter2)
+                return self._comb_implicit_mat
+            else:
+                raise AttributeError("comb_implicit_mat is not specified for "
+                                     "equations of motion form [1].")
+        else:
+            return self._comb_implicit_mat
+
+    @property
+    def comb_implicit_rhs(self):
+        """Returns the column matrix, F, corresponding to the equations of
+        motion in implicit form (form [2]), M x' = F, where the kinematical
+        equations are included"""
+        if self._comb_implicit_rhs is None:
+            if self._dyn_implicit_rhs is not None:
+                kin_inter = self._kin_explicit_rhs
+                dyn_inter = self._dyn_implicit_rhs
+                self._comb_implicit_rhs = kin_inter.col_join(dyn_inter)
+                return self._comb_implicit_rhs
+            else:
+                raise AttributeError("comb_implicit_mat is not specified for "
+                                     "equations of motion in form [1].")
+        else:
+            return self._comb_implicit_rhs
+
+    def compute_explicit_form(self):
+        """If the explicit right hand side of the combined equations of motion
+        is to provided upon initialization, this method will calculate it. This
+        calculation can potentially take awhile to compute."""
+        if self._comb_explicit_rhs is not None:
+            raise AttributeError("comb_explicit_rhs is already formed.")
+
+        inter1 = getattr(self, 'kin_explicit_rhs', None)
+        if inter1 is not None:
+            inter2 = self._dyn_implicit_mat.LUsolve(self._dyn_implicit_rhs)
+            out = inter1.col_join(inter2)
+        else:
+            out = self._comb_implicit_mat.LUsolve(self._comb_implicit_rhs)
+
+        self._comb_explicit_rhs = out
+
+    @property
+    def comb_explicit_rhs(self):
+        """Returns the right hand side of the equations of motion in explicit
+        form, x' = F, where the kinematical equations are included"""
+        if self._comb_explicit_rhs is None:
+            raise AttributeError("Please run .combute_explicit_form before "
+                                 "attempting to access comb_explicit_rhs.")
+        else:
+            return self._comb_explicit_rhs
+
+    @property
+    def kin_explicit_rhs(self):
+        """Returns the right hand side of the kinematical equations in explicit
+        form, q' = G"""
+        if self._kin_explicit_rhs is None:
+            raise AttributeError("kin_explicit_rhs is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._kin_explicit_rhs
+
+    def dynamic_symbols(self):
+        """Returns a column matrix containing all of the symbols in the system
+        that depend on time"""
+        # Create a list of all of the expressions in the equations of motion
+        if self._comb_explicit_rhs is None:
+            eom_expressions = (self.comb_implicit_mat[:] +
+                               self.comb_implicit_rhs[:])
+        else:
+            eom_expressions = (self._comb_explicit_rhs[:])
+
+        functions_of_time = set()
+        for expr in eom_expressions:
+            functions_of_time = functions_of_time.union(
+                find_dynamicsymbols(expr))
+        functions_of_time = functions_of_time.union(self._states)
+
+        return tuple(functions_of_time)
+
+    def constant_symbols(self):
+        """Returns a column matrix containing all of the symbols in the system
+        that do not depend on time"""
+        # Create a list of all of the expressions in the equations of motion
+        if self._comb_explicit_rhs is None:
+            eom_expressions = (self.comb_implicit_mat[:] +
+                               self.comb_implicit_rhs[:])
+        else:
+            eom_expressions = (self._comb_explicit_rhs[:])
+
+        constants = set()
+        for expr in eom_expressions:
+            constants = constants.union(expr.free_symbols)
+        constants.remove(dynamicsymbols._t)
+
+        return tuple(constants)
+
+    @property
+    def bodies(self):
+        """Returns the bodies in the system"""
+        if self._bodies is None:
+            raise AttributeError("bodies were not specified for the system.")
+        else:
+            return self._bodies
+
+    @property
+    def loads(self):
+        """Returns the loads in the system"""
+        if self._loads is None:
+            raise AttributeError("loads were not specified for the system.")
+        else:
+            return self._loads