code: def get_motion_params(frame, **kwargs):
      """
      Returns the three motion parameters - (acceleration, velocity, and
      position) as vectorial functions of time in the given frame.
  
      If a higher order differential function is provided, the lower order
      functions are used as boundary conditions. For example, given the
      acceleration, the velocity and position parameters are taken as
      boundary conditions.
  
      The values of time at which the boundary conditions are specified
      are taken from timevalue1(for position boundary condition) and
      timevalue2(for velocity boundary condition).
  
      If any of the boundary conditions are not provided, they are taken
      to be zero by default (zero vectors, in case of vectorial inputs). If
      the boundary conditions are also functions of time, they are converted
      to constants by substituting the time values in the dynamicsymbols._t
      time Symbol.
  
      This function can also be used for calculating rotational motion
      parameters. Have a look at the Parameters and Examples for more clarity.
  
      Parameters
      ==========
  
      frame : ReferenceFrame
          The frame to express the motion parameters in
  
      acceleration : Vector
          Acceleration of the object/frame as a function of time
  
      velocity : Vector
          Velocity as function of time or as boundary condition
          of velocity at time = timevalue1
  
      position : Vector
          Velocity as function of time or as boundary condition
          of velocity at time = timevalue1
  
      timevalue1 : sympyfiable
          Value of time for position boundary condition
  
      timevalue2 : sympyfiable
          Value of time for velocity boundary condition
  
      Examples
      ========
  
      >>> from sympy.physics.vector import ReferenceFrame, get_motion_params, dynamicsymbols
      >>> from sympy.physics.vector import init_vprinting
      >>> init_vprinting(pretty_print=False)
      >>> from sympy import symbols
      >>> R = ReferenceFrame('R')
      >>> v1, v2, v3 = dynamicsymbols('v1 v2 v3')
      >>> v = v1*R.x + v2*R.y + v3*R.z
      >>> get_motion_params(R, position = v)
      (v1''*R.x + v2''*R.y + v3''*R.z, v1'*R.x + v2'*R.y + v3'*R.z, v1*R.x + v2*R.y + v3*R.z)
      >>> a, b, c = symbols('a b c')
      >>> v = a*R.x + b*R.y + c*R.z
      >>> get_motion_params(R, velocity = v)
      (0, a*R.x + b*R.y + c*R.z, a*t*R.x + b*t*R.y + c*t*R.z)
      >>> parameters = get_motion_params(R, acceleration = v)
      >>> parameters[1]
      a*t*R.x + b*t*R.y + c*t*R.z
      >>> parameters[2]
      a*t**2/2*R.x + b*t**2/2*R.y + c*t**2/2*R.z
  
      """
  
      def _process_vector_differential(
          vectdiff, condition, variable, ordinate, frame
      ):
          """
          Helper function for get_motion methods. Finds derivative of vectdiff
          wrt variable, and its integral using the specified boundary condition
          at value of variable = ordinate.
          Returns a tuple of - (derivative, function and integral) wrt vectdiff
  
          """
  
          # Make sure boundary condition is independent of 'variable'
          if condition != 0:
              condition = express(condition, frame, variables=True)
          # Special case of vectdiff == 0
          if vectdiff == Vector(0):
              return (0, 0, condition)
          # Express vectdiff completely in condition's frame to give vectdiff1
          vectdiff1 = express(vectdiff, frame)
          # Find derivative of vectdiff
          vectdiff2 = time_derivative(vectdiff, frame)
          # Integrate and use boundary condition
          vectdiff0 = Vector(0)
          lims = (variable, ordinate, variable)
          for dim in frame:
              function1 = vectdiff1.dot(dim)
              abscissa = dim.dot(condition).subs({variable: ordinate})
              # Indefinite integral of 'function1' wrt 'variable', using
              # the given initial condition (ordinate, abscissa).
              vectdiff0 += (integrate(function1, lims) + abscissa) * dim
          # Return tuple
          return (vectdiff2, vectdiff, vectdiff0)
  
      _check_frame(frame)
      # Decide mode of operation based on user's input
      if "acceleration" in kwargs:
          mode = 2
      elif "velocity" in kwargs:
          mode = 1
      else:
          mode = 0
      # All the possible parameters in kwargs
      # Not all are required for every case
      # If not specified, set to default values(may or may not be used in
      # calculations)
      conditions = [
          "acceleration",
          "velocity",
          "position",
          "timevalue",
          "timevalue1",
          "timevalue2",
      ]
      for i, x in enumerate(conditions):
          if x not in kwargs:
              if i < 3:
                  kwargs[x] = Vector(0)
              else:
                  kwargs[x] = S.Zero
          elif i < 3:
              _check_vector(kwargs[x])
          else:
              kwargs[x] = sympify(kwargs[x])
      if mode == 2:
          vel = _process_vector_differential(
              kwargs["acceleration"],
              kwargs["velocity"],
              dynamicsymbols._t,
              kwargs["timevalue2"],
              frame,
          )[2]
          pos = _process_vector_differential(
              vel,
              kwargs["position"],
              dynamicsymbols._t,
              kwargs["timevalue1"],
              frame,
          )[2]
          return (kwargs["acceleration"], vel, pos)
      elif mode == 1:
          return _process_vector_differential(
              kwargs["velocity"],
              kwargs["position"],
              dynamicsymbols._t,
              kwargs["timevalue1"],
              frame,
          )
      else:
          vel = time_derivative(kwargs["position"], frame)
          acc = time_derivative(vel, frame)
          return (acc, vel, kwargs["position"])
  
file_path: sympy/sympy/physics/vector/functions.py
imports: from functools import reduce
  from sympy import sympify, diff, sin, cos, Matrix, symbols, Function, S, Symbol
  from sympy.integrals.integrals import integrate
  from sympy.simplify.trigsimp import trigsimp
  from .vector import Vector, _check_vector
  from .frame import CoordinateSym, _check_frame
  from .dyadic import Dyadic
  from .printing import vprint, vsprint, vpprint, vlatex, init_vprinting
  from sympy.utilities.iterables import iterable
  from sympy.utilities.misc import translate
label_desc: Use image node_id 7 for calling a global function with example usage: get_motion_params(frame) and returns: vectdiff2,  vectdiff,  vectdiff0, kwargs,  vel,  pos, int,  int,  condition, _process_vector_differential, acc,  vel,  kwargs