code: def jvp(f, params, tangents, method=None, h=None, argnum=None):
      """A :func:`~.qjit` compatible Jacobian-vector product of PennyLane programs.
  
      This function allows the Jacobian-vector Product of a hybrid quantum-classical function to be
      computed within the compiled program.
  
      .. warning::
  
          ``jvp`` is intended to be used with :func:`~.qjit` only.
  
      .. note::
  
          When used with :func:`~.qjit`, this function only supports the Catalyst compiler;
          see :func:`catalyst.jvp` for more details.
  
          Please see the Catalyst :doc:`quickstart guide <catalyst:dev/quick_start>`,
          as well as the :doc:`sharp bits and debugging tips <catalyst:dev/sharp_bits>`
          page for an overview of the differences between Catalyst and PennyLane.
  
      Args:
          f (Callable): Function-like object to calculate JVP for
          params (List[Array]): List (or a tuple) of the function arguments specifying the point
                                to calculate JVP at. A subset of these parameters are declared as
                                differentiable by listing their indices in the ``argnum`` parameter.
          tangents(List[Array]): List (or a tuple) of tangent values to use in JVP. The list size and
                                 shapes must match the ones of differentiable params.
          method(str): Differentiation method to use, same as in :func:`~.grad`.
          h (float): the step-size value for the finite-difference (``"fd"``) method
          argnum (Union[int, List[int]]): the params' indices to differentiate.
  
      Returns:
          Tuple[Array]: Return values of ``f`` paired with the JVP values.
  
      Raises:
          TypeError: invalid parameter types
          ValueError: invalid parameter values
  
      .. seealso:: :func:`~.grad`, :func:`~.vjp`, :func:`~.jacobian`
  
      **Example 1 (basic usage)**
  
      .. code-block:: python
  
          @qml.qjit
          def jvp(params, tangent):
            def f(x):
                y = [jnp.sin(x[0]), x[1] ** 2, x[0] * x[1]]
                return jnp.stack(y)
  
            return qml.jvp(f, [params], [tangent])
  
      >>> x = jnp.array([0.1, 0.2])
      >>> tangent = jnp.array([0.3, 0.6])
      >>> jvp(x, tangent)
      [array([0.09983342, 0.04      , 0.02      ]),
      array([0.29850125, 0.24000006, 0.12      ])]
  
      **Example 2 (argnum usage)**
  
      Here we show how to use ``argnum`` to ignore the non-differentiable parameter ``n`` of the
      target function. Note that the length and shapes of tangents must match the length and shape of
      primal parameters, which we mark as differentiable by passing their indices to ``argnum``.
  
      .. code-block:: python
  
          @qml.qjit
          @qml.qnode(qml.device("lightning.qubit", wires=2))
          def circuit(n, params):
              qml.RX(params[n, 0], wires=n)
              qml.RY(params[n, 1], wires=n)
              return qml.expval(qml.PauliZ(1))
  
          @qml.qjit
          def workflow(primals, tangents):
              return qml.jvp(circuit, [1, primals], [tangents], argnum=[1])
  
      >>> params = jnp.array([[0.54, 0.3154], [0.654, 0.123]])
      >>> dy = jnp.array([[1.0, 1.0], [1.0, 1.0]])
      >>> workflow(params, dy)
      [array(0.78766064), array(-0.7011436)]
      """
  
      if active_jit := compiler.active_compiler():
          available_eps = compiler.AvailableCompilers.names_entrypoints
          ops_loader = available_eps[active_jit]["ops"].load()
          return ops_loader.jvp(
              f, params, tangents, method=method, h=h, argnum=argnum
          )
  
      raise CompileError(
          "Pennylane does not support the JVP function without QJIT."
      )
  
file_path: pennylane/pennylane/_grad.py
imports: import warnings
  from autograd import jacobian
  from autograd.core import make_vjp
  from autograd.numpy.numpy_boxes import ArrayBox
  from autograd.extend import vspace
  from autograd.wrap_util import unary_to_nary
  from pennylane.compiler import compiler
  from pennylane.compiler.compiler import CompileError
label_desc: Use image node_id 3 for calling a global function with example usage: jvp(f, params, tangents, method, h, argnum) and returns: ops_loader