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: Launch the solver
  
  Parameters
  ----------
  x0 : `np.array`, shape=(n_coeffs,), default=`None`
      Starting point of the solver
  
  step : `float`, default=`None`
      Step-size or learning rate for the solver. This can be tuned also
      using the ``step`` attribute
  
  Returns
  -------
  output : `np.array`, shape=(n_coeffs,)
      Obtained minimizer for the problem, same as ``solution`` attribute
docstr_tok: ["Launch","the","solver","Parameters","--","--","--","--","--","x0",":","`","np.array","`",",","shape=","(","n_coeffs",",",")",",","default=","`","None","`","Starting","point","of","the","solver","step",":","`","float","`",",","default=","`","None","`","Step-size","or","learning","rate","for","the","solver",".","This","can","be","tuned","also","using","the","``","step","``","attribute","Returns","--","--","--","-","output",":","`","np.array","`",",","shape=","(","n_coeffs",",",")","Obtained","minimizer","for","the","problem",",","same","as","``","solution","``","attribute"]
code: def solve(self, x0=None, step=None):
      """
      Launch the solver
  
      Parameters
      ----------
      x0 : `np.array`, shape=(n_coeffs,), default=`None`
          Starting point of the solver
  
      step : `float`, default=`None`
          Step-size or learning rate for the solver. This can be tuned also
          using the ``step`` attribute
  
      Returns
      -------
      output : `np.array`, shape=(n_coeffs,)
          Obtained minimizer for the problem, same as ``solution`` attribute
      """
      if x0 is not None and self.dtype is not "float64":
          x0 = x0.astype(self.dtype)
  
      if self.model is None:
          raise ValueError(
              "You must first set the model using " "``set_model``."
          )
      if self.prox is None:
          raise ValueError(
              "You must first set the prox using " "``set_prox``."
          )
      solution = Solver.solve(self, x0, step)
      return solution
  
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 9 for calling the SolverFirstOrder obj's underlying member method code with example usage: obj.solve(x0, step) and returns: solution