class_docstr: AbstractEnsembleSolver base class for mystic optimizers that are called within
  a parallel map.  This allows pseudo-global coverage of parameter space using
  non-global optimizers.
      
class_docstr_tok: ["AbstractEnsembleSolver","base","class","for","mystic","optimizers","that","are","called","within","a","parallel","map",".","This","allows","pseudo-global","coverage","of","parameter","space","using","non-global","optimizers","."]
docstr: perform a single optimization iteration
  
  Args:
      cost (func, default=None): objective, of form ``y = cost(x, *ExtraArgs)``,
        where ``x`` is a candidate solution vector
      ExtraArgs (tuple, default=None): tuple of positional arguments required to
        evaluate the objective
  
  Returns:
      None
  
  Notes:
      - This method accepts additional ``kwds`` that are specific for the current
        solver, as detailed in the ``_process_inputs`` method.
          
docstr_tok: ["perform","a","single","optimization","iteration","Args",":","cost","(","func",",","default=None",")",":","objective",",","of","form","``","y","=","cost","(","x",",","*","ExtraArgs",")","``",",","where","``","x","``","is","a","candidate","solution","vector","ExtraArgs","(","tuple",",","default=None",")",":","tuple","of","positional","arguments","required","to","evaluate","the","objective","Returns",":","None","Notes",":","-","This","method","accepts","additional","``","kwds","``","that","are","specific","for","the","current","solver",",","as","detailed","in","the","``","_process_inputs","``","method","."]
code: def _Step(self, cost=None, ExtraArgs=None, **kwds):
      """perform a single optimization iteration
  
      Args:
          cost (func, default=None): objective, of form ``y = cost(x, *ExtraArgs)``,
            where ``x`` is a candidate solution vector
          ExtraArgs (tuple, default=None): tuple of positional arguments required to
            evaluate the objective
  
      Returns:
          None
  
      Notes:
          - This method accepts additional ``kwds`` that are specific for the current
            solver, as detailed in the ``_process_inputs`` method.
      """
      # process and activate input settings
      kwds[
          "step"
      ] = True  # XXX: once Step is taken, step=True thereafter
      settings = self._process_inputs(kwds)
      # (hardwired: due to python exec'ing to locals())
      disp = settings["disp"] if "disp" in settings else False
      echo = settings["callback"] if "callback" in settings else None
      if disp in ["verbose", "all"]:
          verbose = True
      else:
          verbose = False
  
      # generate starting points
      if self._is_new():
          iv = self._InitialPoints()
      else:
          iv = [None] * len(self._allSolvers)
      op = self._AbstractEnsembleSolver__init_allSolvers()
      vb = [
          verbose if not s.Terminated() else False
          for s in self._allSolvers
      ]
      cb = [echo] * len(op)  # XXX: remove?
  
      # generate the _step function
      def _step(solver, x0, disp=False, callback=None):
          from copy import deepcopy as _copy
          from mystic.tools import isNull
  
          # ns = len(solver._stepmon)
          # ne = len(solver._evalmon)
          if x0 is not None:
              solver.SetInitialPoints(x0)
              if (
                  solver._useStrictRange
              ):  # XXX: always, settable, or sync'd ?
                  solver.SetStrictRanges(
                      solver._strictMin,
                      solver._strictMax,
                      tight=solver._useTightRange,
                      clip=self._useClipRange,
                  )
          _term = (solver._live is False) and solver.Terminated()
          if _term is True:
              solver._live = True  # XXX: HACK don't reset _fcalls
          solver.Step(
              cost, ExtraArgs=ExtraArgs, disp=disp, callback=callback
          )
          if _term is True:
              solver._live = False
          sm = solver._stepmon
          em = solver._evalmon
          if isNull(sm):
              sm = ([], [], [], [])
          else:
              sm = _copy(sm)  # [ns:]
              sm = (sm._x, sm._y, sm._id, sm._info)
          if isNull(em):
              em = ([], [], [], [])
          else:
              em = _copy(em)  # [ne:]
              em = (em._x, em._y, em._id, em._info)
          return solver, sm, em
  
      # map:: solver = _step(solver, x0, id, verbose)
      results = list(
          self._map(_step, op, iv, vb, cb, **self._mapconfig)
      )
      del op, iv, vb, cb
  
      # save initial state
      # self._AbstractSolver__save_state()
  
      # save results to allSolvers
      self._AbstractEnsembleSolver__update_allSolvers(results)
      del results
  
      # update state from bestSolver
      self._AbstractEnsembleSolver__update_state()
      return
  
imports: from mystic.monitors import Null
  from mystic.abstract_map_solver import AbstractMapSolver
  from mystic.tools import wrap_function
  from functools import reduce
label_desc: Use image node_id 25 for calling the AbstractEnsembleSolver obj's underlying member method code with example usage: obj._Step(cost, ExtraArgs) and returns: solver,  sm,  em