def __call__(self, fun, initial_step_size, epsilon):
<EOL>f0 = fun(<NUM_LIT:0.0>)<EOL>triplet = self._bracket(initial_step_size, f0, fun)<EOL>if triplet is None:<EOL><INDENT>return False, False, <NUM_LIT:0.0>, f0<EOL><DEDENT>qopt, fopt = self._golden(triplet, fun)<EOL>qopt = self.limit_step(qopt)<EOL>fopt = fun(qopt)<EOL>return True, True, qopt, fopt<EOL>
Return the value that minimizes the one-dimensional function 'fun'

           Arguments:
            | ``fun``  --  function to minimize (one-dimensional)
            | ``f0``   --  the function value at the starting point q=0"
            | ``initial_step_size``  --  a guess of the order of magnitude of
                                         step size to be found. This is used to
                                         bracket the minimum.
            | ``epsilon``  --  a value that is small compared to
                               initial_step_size

           Returns:
            | ``success``  --  a boolean indicating that the line search
                               resulted in an improved solution
            | ``wolfe``  --  a boolean indicating that the new solution
                             satisfies Wolfe conditions
            | ``qopt``  --  the position of the new solution on the line
            | ``fopt``  --  the corresponding function value

           P.S. The wolfe parameter is always True, but this aspect is not
           guaranteed to be correct. Never use the :class:`GoldenLineSearch` in
           combination with a quasi Newton method.