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: Initialize values
  
  Parameters
  ----------
  x0 : `numpy.ndarray`
      Starting point
  
  step : `float`
      Initial step
  
  n_empty_vectors : `int`
      Number of empty vector of like x0 needed
  
  Returns
  -------
  step : `float`
      Initial step
  
  obj : `float`
      Initial value of objective function
  
  iterate : `numpy.ndarray`
      copy of starting point
  
  empty vectors : `numpy.ndarray`
      n_empty_vectors empty vectors shaped as x0. For example, those
      vectors can be used to store previous iterate values during
      a solver execution.
docstr_tok: ["Initialize","values","Parameters","--","--","--","--","--","x0",":","`","numpy.ndarray","`","Starting","point","step",":","`","float","`","Initial","step","n_empty_vectors",":","`","int","`","Number","of","empty","vector","of","like","x0","needed","Returns","--","--","--","-","step",":","`","float","`","Initial","step","obj",":","`","float","`","Initial","value","of","objective","function","iterate",":","`","numpy.ndarray","`","copy","of","starting","point","empty","vectors",":","`","numpy.ndarray","`","n_empty_vectors","empty","vectors","shaped","as","x0",".","For","example",",","those","vectors","can","be","used","to","store","previous","iterate","values","during","a","solver","execution","."]
code: def _initialize_values(
      self,
      x0: np.ndarray = None,
      step: float = None,
      n_empty_vectors: int = 0,
  ):
      """Initialize values
  
      Parameters
      ----------
      x0 : `numpy.ndarray`
          Starting point
  
      step : `float`
          Initial step
  
      n_empty_vectors : `int`
          Number of empty vector of like x0 needed
  
      Returns
      -------
      step : `float`
          Initial step
  
      obj : `float`
          Initial value of objective function
  
      iterate : `numpy.ndarray`
          copy of starting point
  
      empty vectors : `numpy.ndarray`
          n_empty_vectors empty vectors shaped as x0. For example, those
          vectors can be used to store previous iterate values during
          a solver execution.
      """
      # Initialization
      if step is None:
          if self.step is None:
              raise ValueError("No step specified.")
          else:
              step = self.step
      else:
          self.step = step
      if x0 is None:
          x0 = np.zeros(self.model.n_coeffs, dtype=self.dtype)
      iterate = x0.copy()
      obj = self.objective(iterate)
  
      result = [step, obj, iterate]
      for _ in range(n_empty_vectors):
          result.append(np.zeros_like(x0))
  
      return tuple(result)
  
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 4 for calling the SolverFirstOrder obj's underlying member method code with example usage: obj._initialize_values(x0, step, n_empty_vectors) and returns: tuple