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.
docstr: Linearize the equations of motion about a symbolic operating point.
  
  Parameters
  ==========
  linear_solver : str, callable
      Method used to solve the several symbolic linear systems of the
      form ``A*x=b`` in the linearization process. If a string is
      supplied, it should be a valid method that can be used with the
      :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is
      supplied, it should have the format ``x = f(A, b)``, where it
      solves the equations and returns the solution. The default is
      ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``.
      ``LUsolve()`` is fast to compute but will often result in
      divide-by-zero and thus ``nan`` results.
  **kwargs
      Extra keyword arguments are passed to
      :meth:`sympy.physics.mechanics.linearize.Linearizer.linearize`.
  
  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.
docstr_tok: ["Linearize","the","equations","of","motion","about","a","symbolic","operating","point",".","Parameters","==========","linear_solver",":","str",",","callable","Method","used","to","solve","the","several","symbolic","linear","systems","of","the","form","``","A","*","x=b","``","in","the","linearization","process",".","If","a","string","is","supplied",",","it","should","be","a","valid","method","that","can","be","used","with","the",":","meth",":","`","sympy.matrices.matrixbase.MatrixBase.solve","`",".","If","a","callable","is","supplied",",","it","should","have","the","format","``","x","=","f","(","A",",","b",")","``",",","where","it","solves","the","equations","and","returns","the","solution",".","The","default","is","``","'LU","'","``","which","corresponds","to","SymPy","'s","``","A.LUsolve","(","b",")","``",".","``","LUsolve","(",")","``","is","fast","to","compute","but","will","often","result","in","divide-by-zero","and","thus","``","nan","``","results",".","*","*","kwargs","Extra","keyword","arguments","are","passed","to",":","meth",":","`","sympy.physics.mechanics.linearize.Linearizer.linearize","`",".","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","."]
code: def linearize(
      self,
      q_ind=None,
      qd_ind=None,
      q_dep=None,
      qd_dep=None,
      linear_solver="LU",
      **kwargs,
  ):
      """Linearize the equations of motion about a symbolic operating point.
  
      Parameters
      ==========
      linear_solver : str, callable
          Method used to solve the several symbolic linear systems of the
          form ``A*x=b`` in the linearization process. If a string is
          supplied, it should be a valid method that can be used with the
          :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is
          supplied, it should have the format ``x = f(A, b)``, where it
          solves the equations and returns the solution. The default is
          ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``.
          ``LUsolve()`` is fast to compute but will often result in
          divide-by-zero and thus ``nan`` results.
      **kwargs
          Extra keyword arguments are passed to
          :meth:`sympy.physics.mechanics.linearize.Linearizer.linearize`.
  
      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, linear_solver=linear_solver
      )
      result = linearizer.linearize(**kwargs)
      return result + (linearizer.r,)
  
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 9 for calling the LagrangesMethod obj's underlying member method code with example usage: obj.linearize(q_ind, qd_ind, q_dep, qd_dep, linear_solver) and returns: unknown