parameters: (self, *args, **kwargs)
docstring: r"""Build a NewtonParameters (C++ object) via its ctor; this object specifies multistarted Newton behavior and is required by C++ Newton optimization.
  
          .. Note:: See gpp_optimizer_parameters.hpp for more details.
              The following comments are copied from NewtonParameters struct in gpp_optimizer_parameters.hpp.
  
          **Diagonal dominance control: ``gamma`` and ``time_factor``**
  
          On i-th newton iteration, we add ``1/(time_factor*gamma^(i+1)) * I`` to the Hessian to improve robustness
  
          Choosing a small gamma (e.g., ``1.0 < gamma <= 1.01``) and time_factor (e.g., ``0 < time_factor <= 1.0e-3``)
          leads to more consistent/stable convergence at the cost of slower performance (and in fact
          for gamma or time_factor too small, gradient descent is preferred).  Conversely, choosing more
          aggressive values may lead to very fast convergence at the cost of more cases failing to
          converge.
  
          ``gamma = 1.01``, ``time_factor = 1.0e-3`` should lead to good robustness at reasonable speed.  This should be a fairly safe default.
          ``gamma = 1.05, time_factor = 1.0e-1`` will be several times faster but not as robust.
          for "easy" problems, these can be much more aggressive, e.g., ``gamma = 2.0``, ``time_factor = 1.0e1`` or more
  
          :param num_multistarts: number of initial guesses to try in multistarted newton (suggest: a few hundred)
          :type num_multistarts: int > 0
          :param max_num_steps: maximum number of newton iterations (per initial guess) (suggest: 100)
          :type max_num_steps: int > 0
          :param gamma: exponent controlling rate of time_factor growth (see function comments) (suggest: 1.01-1.1)
          :type gamma: float64 > 1.0
          :param time_factor: initial amount of additive diagonal dominance (see function comments) (suggest: 1.0e-3-1.0e-1)
          :type time_factor: float64 > 0.0
          :param max_relative_change: max change allowed per update (as a relative fraction of current distance to wall) (suggest: 1.0)
          :type max_relative_change: float64 in [0, 1]
          :param tolerance: when the magnitude of the gradient falls below this value, stop (suggest: 1.0e-10)
          :type tolerance: float64 >= 0.0
docstring_summary: r"""Build a NewtonParameters (C++ object) via its ctor; this object specifies multistarted Newton behavior and is required by C++ Newton optimization.
docstring_tokens: r Build a NewtonParameters ( C ++ object ) via its ctor ; this object specifies multistarted Newton behavior and is required by C ++ Newton optimization .
function: def __init__(self, *args, **kwargs):
          r"""Build a NewtonParameters (C++ object) via its ctor; this object specifies multistarted Newton behavior and is required by C++ Newton optimization.
  
          .. Note:: See gpp_optimizer_parameters.hpp for more details.
              The following comments are copied from NewtonParameters struct in gpp_optimizer_parameters.hpp.
  
          **Diagonal dominance control: ``gamma`` and ``time_factor``**
  
          On i-th newton iteration, we add ``1/(time_factor*gamma^(i+1)) * I`` to the Hessian to improve robustness
  
          Choosing a small gamma (e.g., ``1.0 < gamma <= 1.01``) and time_factor (e.g., ``0 < time_factor <= 1.0e-3``)
          leads to more consistent/stable convergence at the cost of slower performance (and in fact
          for gamma or time_factor too small, gradient descent is preferred).  Conversely, choosing more
          aggressive values may lead to very fast convergence at the cost of more cases failing to
          converge.
  
          ``gamma = 1.01``, ``time_factor = 1.0e-3`` should lead to good robustness at reasonable speed.  This should be a fairly safe default.
          ``gamma = 1.05, time_factor = 1.0e-1`` will be several times faster but not as robust.
          for "easy" problems, these can be much more aggressive, e.g., ``gamma = 2.0``, ``time_factor = 1.0e1`` or more
  
          :param num_multistarts: number of initial guesses to try in multistarted newton (suggest: a few hundred)
          :type num_multistarts: int > 0
          :param max_num_steps: maximum number of newton iterations (per initial guess) (suggest: 100)
          :type max_num_steps: int > 0
          :param gamma: exponent controlling rate of time_factor growth (see function comments) (suggest: 1.01-1.1)
          :type gamma: float64 > 1.0
          :param time_factor: initial amount of additive diagonal dominance (see function comments) (suggest: 1.0e-3-1.0e-1)
          :type time_factor: float64 > 0.0
          :param max_relative_change: max change allowed per update (as a relative fraction of current distance to wall) (suggest: 1.0)
          :type max_relative_change: float64 in [0, 1]
          :param tolerance: when the magnitude of the gradient falls below this value, stop (suggest: 1.0e-10)
          :type tolerance: float64 >= 0.0
  
          """
          super(NewtonParameters, self).__init__(*args, **kwargs)
function_tokens: def __init__ ( self , * args , * * kwargs ) : super ( NewtonParameters , self ) . __init__ ( * args , * * kwargs )