class_docstr: AbstractSolver base class for mystic optimizers.
      
class_docstr_tok: ["AbstractSolver","base","class","for","mystic","optimizers","."]
docstr: Set Initial Points with Guess (``x0``)
  
  Args:
      x0 (list[float]): a sequence of length ``self.nDim``
      radius (float): generate random points within ``[-radius*x0, radius*x0]``
          for ``i!=0`` when a simplex-type initial guess is required
  
  Returns:
      None
          
code: def SetInitialPoints(self, x0, radius=0.05):
      """Set Initial Points with Guess (``x0``)
  
      Args:
          x0 (list[float]): a sequence of length ``self.nDim``
          radius (float): generate random points within ``[-radius*x0, radius*x0]``
              for ``i!=0`` when a simplex-type initial guess is required
  
      Returns:
          None
      """
      x0 = asfarray(x0)
      rank = len(x0.shape)
      if rank == 0:
          x0.shape = (1,)
          rank = 1
      if not -1 < rank < 2:
          raise ValueError(
              "Initial guess must be a scalar or rank-1 sequence."
          )
      if len(x0) != self.nDim:
          raise ValueError(
              "Initial guess must be length %s" % self.nDim
          )
  
      radius = asfarray(radius)  # may be scalar or a nDim array
      _rank = len(radius.shape)
  
      if _rank and len(radius) != self.nDim:
          raise ValueError("Radius must be length %s" % self.nDim)
  
      # slightly alter initial values for solvers that depend on randomness
      min = x0 * (1 - radius)
      max = x0 * (1 + radius)
      min[min == 0] = -radius[min == 0] if _rank else -radius
      max[max == 0] = radius[max == 0] if _rank else radius
      self.SetRandomInitialPoints(min, max)
      # stick initial values in population[i], i=0
      self.population[0][:] = x0.tolist()
  
imports: import random
  import numpy
  from numpy import inf, shape, asarray, absolute, asfarray, seterr
  from mystic.tools import wrap_function, wrap_nested, wrap_reducer
  from mystic.tools import wrap_bounds, wrap_penalty, reduced
  from klepto import isvalid, validate
  from collections.abc import Callable
label_desc: Use image node_id 21 for calling the AbstractSolver obj's underlying member method code with example usage: obj.SetInitialPoints(x0, radius) without return types