class_docstr: 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.
code: def _form_eoms(self):
      return self.form_lagranges_equations()
  
imports: from sympy 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
label_desc: Use image node_id 3 for calling the LagrangesMethod obj's underlying member method code with example usage: obj._form_eoms() and returns: self