def recf_standard_poly(result, x, special, n, cur_var, pos):
    """Implementation of the recursion formula for standard polynomials.

    The recursion formula is P_n = P_{n-1} * x.

    .. note::

        We translate this recursion formula into code as follows.

        We leave out the left part of the equation, as the
        return value is automatically set to the n-th order
        expansion of the current variable, namely::

            >>> result[:, pos]

        We access all observations of the n-1-th order expansion of the current
        variable at::

            >>> result[:, pos-1]

        Using the index of the special variable we specified in our init
        function we can set the return value to::

            >>> result[:, pos-1]*result[:, special]

        Alternatively, in this case we could have used the x variable directly,
        by setting the return value to::

            >> result[:, pos-1]*x[:, cur_var]

        The recursion is natively applied to all variables contained in the data
        one after another and the results are stored in the
        one-dimensional result array.


    :param result: Contains the observations along the first dimension
        and the function values of expansion w.r.t. an observation
        along the second dimension.
    :type result: numpy.ndarray

    :param x: The data to be expanded.
    :type x: numpy.ndarray

    :param special: Index of a special element to be considered in the
        recursion formula. E.g. the first order function value.
    :type special: int

    :param n: The order of the function to be computed at this step.
    :type n: int

    :param cur_var: The index of the current variable to be considered in the
        recursion. This value will have to be lower than x.shape[1].
    :type cur_var: int

    :param pos: The index of the element to be computed, along the second
        dimension of result.
    :type int: int

    :returns: The vectorized result (along the observations) of the
        n-th recursion step of the cur_var-th variable.
    :rtype: numpy.ndarray
    """
    return result[:, (pos - 1)] * result[:, (special)]
