class_docstr: The base class for a first order solver. It defines methods for
  setting a model (giving first order information) and a proximal
  operator
  
  In only deals with verbosing information, and setting parameters
  
  Parameters
  ----------
  step : `float` default=None
      Step-size of the algorithm
  
  tol : `float`, default=0
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it). By default the solver does ``max_iter``
      iterations
  
  max_iter : `int`
      Maximum number of iterations of the solver
  
  verbose : `bool`, default=True
      If `True`, we verbose things, otherwise the solver does not
      print anything (but records information in history anyway)
  
  print_every : `int`, default = 10
      Print history information every time the iteration number is a
      multiple of ``print_every``
  
  record_every : `int`, default = 1
      Information along iteration is recorded in history each time the
      iteration number of a multiple of ``record_every``
  
  Attributes
  ----------
  model : `Model`
      The model to solve
  
  prox : `Prox`
      Proximal operator to solve
  
  dtype : `{'float64', 'float32'}`, default='float64'
      Type of the arrays used. This value is set from model and prox dtypes.
  
  Notes
  -----
  This class should not be used by end-users
docstr: Updates the history of the solver.
  
  Parameters
  ----------
  
  Notes
  -----
  This should not be used by end-users.
docstr_tok: ["Updates","the","history","of","the","solver",".","Parameters","--","--","--","--","--","Notes","--","--","-","This","should","not","be","used","by","end-users","."]
code: def _handle_history(self, n_iter: int, force: bool = False, **kwargs):
      """Updates the history of the solver.
  
      Parameters
      ----------
  
      Notes
      -----
      This should not be used by end-users.
      """
      # self.model.n_calls_loss_and_grad is shared by all
      # solvers using this model
      # hence it might not be at 0 while starting
      # /!\ beware if parallel computing...
      if n_iter == 1:
          self._set(
              "_initial_n_calls_loss_and_grad",
              self.model.n_calls_loss_and_grad,
          )
          self._set("_initial_n_calls_loss", self.model.n_calls_loss)
          self._set("_initial_n_calls_grad", self.model.n_calls_grad)
          self._set(
              "_initial_n_passes_over_data",
              self.model.n_passes_over_data,
          )
      n_calls_loss_and_grad = (
          self.model.n_calls_loss_and_grad
          - self._initial_n_calls_loss_and_grad
      )
      n_calls_loss = (
          self.model.n_calls_loss - self._initial_n_calls_loss
      )
      n_calls_grad = (
          self.model.n_calls_grad - self._initial_n_calls_grad
      )
      n_passes_over_data = (
          self.model.n_passes_over_data
          - self._initial_n_passes_over_data
      )
      Solver._handle_history(
          self,
          n_iter,
          force=force,
          n_calls_loss_and_grad=n_calls_loss_and_grad,
          n_calls_loss=n_calls_loss,
          n_calls_grad=n_calls_grad,
          n_passes_over_data=n_passes_over_data,
          **kwargs,
      )
  
file_path: tick/tick/solver/base/first_order.py
imports: import numpy
  from .None import Solver
  from tick.base_model import Model
  from tick.prox.base import Prox
label_desc: Use image node_id 10 for calling the SolverFirstOrder obj's underlying member method code with example usage: obj._handle_history(n_iter, force) without return types