Changeset 791


Ignore:
Timestamp:
06/10/15 09:03:56 (11 months ago)
Author:
mmckerns
Message:

use len(stepmon) more uniformly; fix _fcalls for DESolvers;
generations counted from stepmon, except in Powell where is overridden;
fix energy_history and solution_history for ensemble solvers;
add _kdiv, itertype, multiply, divide, and "related" methods to tools;
enable tools.listify to handle more robust types;
enable monitor to store values that are scaled with respect to called values;
add ay, iy, ax, ix, _k, _ik madness to deal with speed in k-scaling

Location:
mystic
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • mystic/_math/measures.py

    r789 r791  
    362362    solved = solver.Solution() 
    363363    diameter_squared = solver.bestEnergy 
    364     func_evals = len(evalmon.y) 
     364    func_evals = len(evalmon) 
    365365    return solved, diameter_squared, func_evals 
    366366 

  • mystic/examples/example08.py

    r776 r791  
    9191 
    9292    # use monitor to retrieve results information 
    93     iterations = len(stepmon.x) 
     93    iterations = len(stepmon) 
    9494    cost = stepmon.y[-1] 
    9595    print "Generation %d has best Chi-Squared: %f" % (iterations, cost) 

  • mystic/examples/example09.py

    r776 r791  
    9898 
    9999    # use monitor to retrieve results information 
    100     iterations = len(stepmon.x) 
     100    iterations = len(stepmon) 
    101101    cost = stepmon.y[-1] 
    102102    print "Generation %d has best Chi-Squared: %f" % (iterations, cost) 

  • mystic/examples/example10.py

    r776 r791  
    4747# plot the polynomial trajectories 
    4848def plot_params(monitor): 
    49     x = range(len(monitor.y)) 
    50     pylab.plot(x,monitor.y,'b-') 
    51     pylab.axis([1,0.5*x[-1],0,monitor.y[1]],'k-') 
     49    x = range(len(monitor)) 
     50    y = monitor.y 
     51    pylab.plot(x,y,'b-') 
     52    pylab.axis([1,0.5*x[-1],0,y[1]],'k-') 
    5253    pylab.draw() 
    5354    return 

  • mystic/examples/example11.py

    r776 r791  
    4646# plot the polynomial trajectories 
    4747def plot_params(monitor): 
    48     x = range(len(monitor.y)) 
     48    x = range(len(monitor)) 
    4949    y = monitor.y 
    5050    pylab.plot(x,y,'b-') 

  • mystic/mystic/abstract_solver.py

    r787 r791  
    167167    def __generations(self): 
    168168        """get the number of iterations""" 
    169         return max(0,len(self.energy_history)-1) 
    170        #return max(0,len(self._stepmon)-1) 
     169        return max(0,len(self._stepmon)-1) 
    171170 
    172171    def __energy_history(self): 

  • mystic/mystic/differential_evolution.py

    r787 r791  
    374374        raw = cost 
    375375        if ExtraArgs is None: ExtraArgs = () 
    376        #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
    377376        from python_map import python_map 
    378377        if self._map != python_map: 
    379             self._fcalls = [0] #FIXME: temporary patch for removing the following line 
    380         else: 
    381             self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
     378            pass #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
     379        else: fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
    382380        if self._useStrictRange: 
    383381            for i in range(self.nPop): 
    … …  
    428426        # calculate cost 
    429427        trialEnergy = self._map(cost, self.trialSolution, **self._mapconfig) 
     428        self._fcalls[0] += len(self.trialSolution) #FIXME: manually increment 
    430429 
    431430        # each trialEnergy should be a scalar 

  • mystic/mystic/ensemble.py

    r790 r791  
    9393        #------------------------------------------------------------- 
    9494 
    95        #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
    9695        from python_map import python_map 
    9796        if self._map != python_map: 
    98             self._fcalls = [0] #FIXME: temporary patch for removing the following line 
    99         else: 
    100             self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
     97            pass #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
     98        else: fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
    10199 
    102100        # set up signal handler 
    … …  
    210208        self._stepmon = bestpath #XXX: pointer? copy? 
    211209        self._evalmon = besteval #XXX: pointer? copy? 
     210        self.energy_history = None 
     211        self.solution_history = None 
    212212       #from mystic.tools import isNull 
    213213       #if isNull(bestpath): 
    … …  
    287287        #------------------------------------------------------------- 
    288288 
    289        #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
    290289        from python_map import python_map 
    291290        if self._map != python_map: 
    292             self._fcalls = [0] #FIXME: temporary patch for removing the following line 
    293         else: 
    294             self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
     291            pass #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp' 
     292        else: fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon) 
    295293 
    296294        # set up signal handler 
    … …  
    397395        self._stepmon = bestpath #XXX: pointer? copy? 
    398396        self._evalmon = besteval #XXX: pointer? copy? 
     397        self.energy_history = None 
     398        self.solution_history = None 
    399399       #from mystic.tools import isNull 
    400400       #if isNull(bestpath): 
    … …  
    532532    fcalls = solver.evaluations 
    533533    all_fcalls = solver._total_evals 
    534     iterations = max(0,len(solver._stepmon.y)-1) #FIXME: solver.generations 
     534    iterations = solver.generations 
    535535    allvecs = solver._stepmon.x 
    536536 
    … …  
    663663    fcalls = solver.evaluations 
    664664    all_fcalls = solver._total_evals 
    665     iterations = max(0,len(solver._stepmon.y)-1) #FIXME: solver.generations 
     665    iterations = solver.generations 
    666666    allvecs = solver._stepmon.x 
    667667 

  • mystic/mystic/monitors.py

    r776 r791  
    6565import numpy 
    6666from mystic.tools import list_or_tuple_or_ndarray 
    67 from mystic.tools import listify 
     67from mystic.tools import listify, multiply, divide, _kdiv 
    6868 
    6969class Null(object): 
    … …  
    9191# comply with monitor interface 
    9292Null.info = Null() 
     93Null.k = None 
    9394#XXX: should also have Null.x, Null.y ? 
    9495 
    … …  
    117118        self._info = [] 
    118119       #self._all = all 
     120        self.k = kwds.pop('k', None) 
    119121 
    120122    def __len__(self): 
    … …  
    126128 
    127129    def __call__(self, x, y, id=None, **kwds):#, best=0): 
    128         self._x.append(listify(x)) #XXX: better to save as-is? 
    129         self._y.append(listify(y)) #XXX: better to save as-is? 
     130        self._x.append(listify(x)) #XXX: listify? 
     131        self._y.append(listify(self._k(y, iter))) #XXX: listify? 
    130132        self._id.append(id) 
    131133       #if not self._all and list_or_tuple_or_ndarray(x): 
    … …  
    138140        if isinstance(monitor, Monitor): # is Monitor() 
    139141            pass 
    140         elif (monitor == Null) or isinstance(monitor, Null): # is Null or Null() 
     142        elif (monitor == Null) or isinstance(monitor, Null): # Null or Null() 
    141143            monitor = Monitor() 
    142144        elif hasattr(monitor, '__module__') and \ 
    143             monitor.__module__ in ['mystic._genSow']: # is CustomMonitor() 
     145            monitor.__module__ in ['mystic._genSow']: # CustomMonitor() 
    144146                pass #XXX: CustomMonitor may fail... 
    145147        else: 
    146148            raise TypeError, "'%s' is not a monitor instance" % monitor 
    147149        self._x.extend(monitor._x) 
    148         self._y.extend(monitor._y) 
     150        self._y.extend(self._get_y(monitor))      # scalar, up to 2x faster 
     151       #self._y.extend(self._k(monitor.iy, iter)) # vector, results like numpy 
    149152        self._id.extend(monitor._id) 
    150153        self._info.extend(monitor._info) 
    … …  
    154157        if isinstance(monitor, Monitor): # is Monitor() 
    155158            pass 
    156         elif (monitor == Null) or isinstance(monitor, Null): # is Null or Null() 
     159        elif (monitor == Null) or isinstance(monitor, Null): # Null or Null() 
    157160            monitor = Monitor() 
    158161        elif hasattr(monitor, '__module__') and \ 
    159             monitor.__module__ in ['mystic._genSow']: # is CustomMonitor() 
     162            monitor.__module__ in ['mystic._genSow']: # CustomMonitor() 
    160163                pass #XXX: CustomMonitor may fail... 
    161164        else: 
    162165            raise TypeError, "'%s' is not a monitor instance" % monitor 
    163         [self._x.insert(i,j) for (i,j) in list(enumerate(monitor._x))] 
    164         [self._y.insert(i,j) for (i,j) in list(enumerate(monitor._y))] 
    165         [self._id.insert(i,j) for (i,j) in list(enumerate(monitor._id))] 
    166         [self._info.insert(i,j) for (i,j) in list(enumerate(monitor._info))] 
     166        [self._x.insert(*i) for i in enumerate(monitor._x)] 
     167        [self._y.insert(*i) for i in enumerate(self._get_y(monitor))] 
     168       #[self._y.insert(*i) for i in enumerate(self._k(monitor.iy, iter))] 
     169        [self._id.insert(*i) for i in enumerate(monitor._id)] 
     170        [self._info.insert(*i) for i in enumerate(monitor._info)] 
    167171        #XXX: may be faster ways of doing the above... 
    168172        #     (e.g. deepcopy(monitor) allows enumerate w/o list()) 
    … …  
    171175        return self._x 
    172176 
    173     def get_y(self): 
    174         return self._y 
    175  
    176177    def get_id(self): 
    177178        return self._id 
    … …  
    182183    def __step(self): 
    183184        return len(self.x) 
     185 
     186    #BELOW: madness due to monitor k-conversion 
     187 
     188    def get_y(self): # can be slow if k not in (1, None) 
     189        return divide(self._y, self.k, list) 
     190        #XXX: better if everywhere y = _y, as opposed to y = _ik(_y) ? 
     191        #     better if k only applied to 'output' of __call__ ? 
     192        #     better if k ionly applied on 'exit' from solver ? 
     193 
     194    def _get_y(self, monitor): 
     195        "avoid double-conversion by combining k's" 
     196        _ik = _kdiv(monitor.k, self.k, float) #XXX: always a float? 
     197        return divide(monitor._y, _ik, iter) 
     198 
     199    def get_ix(self): 
     200        return divide(self._y, 1, iter) 
     201 
     202    def get_ax(self): 
     203        return divide(self._y, 1, numpy.array) 
     204 
     205    def get_iy(self): 
     206        return divide(self._y, self.k, iter) 
     207 
     208    def get_ay(self): 
     209        return divide(self._y, self.k, numpy.array) 
     210 
     211    def _k(self, y, type=list): 
     212        return multiply(y, self.k, type) 
     213 
     214    def _ik(self, y, k=False, type=list): 
     215        if k: return y # k's already applied, so don't un-apply it 
     216        return divide(y, self.k, type) 
     217 
    184218    _step = property(__step) 
    185219    x = property(get_x, doc = "Params") 
     220    ix = property(get_ix, doc = "Params") 
     221    ax = property(get_ax, doc = "Params") 
    186222    y = property(get_y, doc = "Costs") 
     223    iy = property(get_iy, doc = "Costs") 
     224    ay = property(get_ay, doc = "Costs") 
    187225    id = property(get_id, doc = "Id") 
    188226    pass 
    … …  
    194232current parameters every 'xinterval'. 
    195233    """ 
    196     def __init__(self, interval = 10, xinterval = numpy.inf, all=True): 
    197         super(VerboseMonitor,self).__init__() 
     234    def __init__(self, interval=10, xinterval=numpy.inf, all=True, **kwds): 
     235        super(VerboseMonitor,self).__init__(**kwds) 
    198236        if not interval or interval is numpy.nan: interval = numpy.inf 
    199237        if not xinterval or xinterval is numpy.nan: xinterval = numpy.inf 
    … …  
    206244        print "%s" % "".join(["",str(message)]) 
    207245        return 
    208     def __call__(self, x, y, id=None, best=0): 
    209         super(VerboseMonitor,self).__call__(x, y, id) 
     246    def __call__(self, x, y, id=None, best=0, k=False): 
     247        super(VerboseMonitor,self).__call__(x, y, id, k=k) 
    210248        if self._yinterval is not numpy.inf and \ 
    211249           int((self._step-1) % self._yinterval) == 0: 
    212250            if not list_or_tuple_or_ndarray(y): 
    213251                who = '' 
    214                 y = " %f" % self._y[-1] 
    215             elif self._all: 
    216                 who = '' 
    217                 y = " %s" % self._y[-1] 
     252                y = " %f" % self._ik(self._y[-1], k) 
     253            elif self._all: 
     254                who = '' 
     255                y = " %s" % self._ik(self._y[-1], k) 
    218256            else: 
    219257                who = ' best' 
    220                 y = " %f" % self._y[-1][best] 
     258                y = " %f" % self._ik(self._y[-1][best], k) 
    221259            msg = "Generation %d has%s Chi-Squared:%s" % (self._step-1,who,y) 
    222260            if id is not None: msg = "[id: %d] " % (id) + msg 
    … …  
    244282Logs ChiSq and parameters to a file every 'interval' 
    245283    """ 
    246     def __init__(self, interval=1, filename='log.txt', new=False, all=True, info=None): 
     284    def __init__(self, interval=1, filename='log.txt', new=False, all=True, info=None, **kwds): 
    247285        import datetime 
    248         super(LoggingMonitor,self).__init__() 
     286        super(LoggingMonitor,self).__init__(**kwds) 
    249287        self._filename = filename 
    250288        if not interval or interval is numpy.nan: interval = numpy.inf 
    … …  
    266304        self._file.close() 
    267305        return 
    268     def __call__(self, x, y, id=None, best=0): 
     306    def __call__(self, x, y, id=None, best=0, k=False): 
    269307        self._file = open(self._filename,'a') 
    270         super(LoggingMonitor,self).__call__(x, y, id) 
     308        super(LoggingMonitor,self).__call__(x, y, id, k=k) 
    271309        if self._yinterval is not numpy.inf and \ 
    272310           int((self._step-1) % self._yinterval) == 0: 
    273311            if not list_or_tuple_or_ndarray(y): 
    274                 y = "%f" % self._y[-1] 
    275             elif self._all: 
    276                 y = "%s" % self._y[-1] 
    277             else: 
    278                 y = "%f" % self._y[-1][best] 
     312                y = "%f" % self._ik(self._y[-1], k) 
     313            elif self._all: 
     314                y = "%s" % self._ik(self._y[-1], k) 
     315            else: 
     316                y = "%f" % self._ik(self._y[-1][best], k) 
    279317            if not list_or_tuple_or_ndarray(x): 
    280318                x = "[%f]" % self._x[-1] 
    … …  
    299337        interval = self._yinterval         
    300338        filename = self._filename 
    301         new=False 
    302         all=self._all 
    303         info=None 
    304         return (self.__class__, (interval, filename, new, all, info)) 
     339        new = False 
     340        all = self._all 
     341        info = None 
     342        args = (interval, filename, new, all, info) 
     343        k = self.k 
     344        state = dict(_x=self._x,_y=self._y,_id=self._id,_info=self._info,k=k) 
     345        return (self.__class__, args, state) 
     346    def __setstate__(self, state): 
     347        self.__dict__.update(state) 
     348        return 
    305349    pass 
    306350 
    … …  
    310354Logs ChiSq and parameters to a file every 'interval', print every 'yinterval' 
    311355    """ 
    312     def __init__(self, interval=1, yinterval=10, xinterval=numpy.inf, filename='log.txt', new=False, all=True, info=None): 
    313         super(VerboseLoggingMonitor,self).__init__(interval,filename,new,all,info) 
     356    def __init__(self, interval=1, yinterval=10, xinterval=numpy.inf, filename='log.txt', new=False, all=True, info=None, **kwds): 
     357        super(VerboseLoggingMonitor,self).__init__(interval,filename,new,all,info,**kwds) 
    314358        if not yinterval or yinterval is numpy.nan: yinterval = numpy.inf 
    315359        if not xinterval or xinterval is numpy.nan: xinterval = numpy.inf 
    … …  
    321365        print "%s" % "".join(["",str(message)]) 
    322366        return 
    323     def __call__(self, x, y, id=None, best=0): 
    324         super(VerboseLoggingMonitor,self).__call__(x, y, id, best) 
     367    def __call__(self, x, y, id=None, best=0, k=False): 
     368        super(VerboseLoggingMonitor,self).__call__(x, y, id, best, k=k) 
    325369        if self._vyinterval is not numpy.inf and \ 
    326370           int((self._step-1) % self._vyinterval) == 0: 
    327371            if not list_or_tuple_or_ndarray(y): 
    328372                who = '' 
    329                 y = " %f" % self._y[-1] 
    330             elif self._all: 
    331                 who = '' 
    332                 y = " %s" % self._y[-1] 
     373                y = " %f" % self._ik(self._y[-1], k) 
     374            elif self._all: 
     375                who = '' 
     376                y = " %s" % self._ik(self._y[-1], k) 
    333377            else: 
    334378                who = ' best' 
    335                 y = " %f" % self._y[-1][best] 
     379                y = " %f" % self._ik(self._y[-1][best], k) 
    336380            msg = "Generation %d has%s Chi-Squared:%s" % (self._step-1,who,y) 
    337381            if id is not None: msg = "[id: %d] " % (id) + msg 
    … …  
    353397        return 
    354398    def __reduce__(self): 
    355         interval = self._yinterval         
    356         yinterval = self._vyinterval 
    357         xinterval = self._vxinterval 
     399        interval = self._yinterval 
     400        yint = self._vyinterval 
     401        xint = self._vxinterval 
    358402        filename = self._filename 
    359         new=False 
    360         all=self._all 
    361         info=None 
    362         return (self.__class__, (interval, yinterval, xinterval, filename, new, all, info)) 
     403        new = False 
     404        all = self._all 
     405        info = None 
     406        args = (interval, yint, xint, filename, new, all, info) 
     407        k = self.k 
     408        state = dict(_x=self._x,_y=self._y,_id=self._id,_info=self._info,k=k) 
     409        return (self.__class__, args, state) 
     410    def __setstate__(self, state): 
     411        self.__dict__.update(state) 
     412        return 
    363413    pass 
    364414 

  • mystic/mystic/munge.py

    r776 r791  
    8181  return steps, energy, id  
    8282 
    83 def write_monitor(steps, energy, id=[]): 
     83def write_monitor(steps, energy, id=[], k=None): 
    8484  from mystic.monitors import Monitor 
    8585  mon = Monitor() 
    86   mon._x = steps[:] 
    87   mon._y = energy[:] 
    88   mon._id = id[:] 
     86  mon.k = k 
     87  mon._x.extend(steps) 
     88  mon._y.extend(mon._k(energy, iter)) 
     89  mon._id.extend(id) 
    8990  return mon 
    9091 

  • mystic/mystic/scipy_optimize.py

    r785 r791  
    463463        self._termination = NCOG(ftol,gtol) 
    464464 
     465    def __generations(self): 
     466        """get the number of iterations""" 
     467        return max(0,len(self.energy_history)-1)  #XXX: slower for k=-1 ? 
     468 
    465469    def _SetEvaluationLimits(self, iterscale=1000, evalscale=1000): 
    466470        super(PowellDirectionalSolver, self)._SetEvaluationLimits(iterscale,evalscale) 
    … …  
    632636                                                   ExtraArgs, **kwds) 
    633637        return 
     638 
     639    # extensions to the solver interface 
     640    generations = property(__generations ) 
     641    pass 
    634642 
    635643 

  • mystic/mystic/tools.py

    r781 r791  
    1616Main functions exported are::  
    1717    - isiterable: check if an object is iterable 
     18    - itertype: get the 'underlying' type used to construct x 
     19    - multiply: recursive elementwise casting multiply of x by n 
     20    - divide: recursive elementwise casting divide of x by n 
    1821    - flatten: flatten a sequence 
    1922    - flatten_array: flatten an array  
    … …  
    5053   #return hasattr(x, '__len__') or hasattr(x, '__iter__') 
    5154 
    52 def list_or_tuple(x): 
     55def itertype(x, default=tuple): 
     56    """get the 'underlying' type used to construct x""" 
     57    _type = type(x) 
     58    try: 
     59        if _type((0,)): return _type # non-iterator iterables 
     60    except TypeError: pass 
     61    try: 
     62        if _type(1): return _type # non-iterables 
     63    except TypeError: pass 
     64    # iterators, etc 
     65    _type = type(x).__name__.split('iterator')[0] 
     66    types = ('xrange','generator','') # and ...? 
     67    if _type in types: return default 
     68    try: 
     69        return eval(_type) 
     70    except NameError: return default 
     71 
     72def _kdiv(num, denom, type=None): 
     73    """'special' scalar division for 'k'""" 
     74    if num is denom is None: return None 
     75    if denom is None: denom = 1 
     76    if num is None: num = 1 
     77    if type is not None: num = type(num) 
     78    return num/denom 
     79 
     80def multiply(x, n, type=list, recurse=False): # list, iter, numpy.array, ... 
     81    """multiply: recursive elementwise casting multiply of x by n""" 
     82    # short-circuit cases for speed 
     83    if n is None: return x 
     84    try:   # for scalars and vectors (numpy.arrays) 
     85        -x # x*n might not throw an error 
     86        return x*n 
     87    except TypeError: pass 
     88    if n is 1: return type(x) 
     89    if type.__name__ == 'array': return type(x)*n 
     90    # multiply by n != 1 for iterables (iter and non-iter) 
     91    if recurse: 
     92        return type(multiply(i,n,type) for i in x) 
     93    return type(i*n for i in x) 
     94 
     95def divide(x, n, type=list, recurse=False): # list, iter, numpy.array, ... 
     96    """elementwise division of x by n, returning the selected type""" 
     97    # short-circuit cases for speed 
     98    if n is None: return x 
     99    try:   # for scalars and vectors (numpy.arrays) 
     100        return x/n 
     101    except TypeError: pass 
     102    if n is 1: return type(x) 
     103    if type.__name__ == 'array': return type(x)/n 
     104    # divide by n != 1 for iterables (iter and non-iter) 
     105    if recurse: 
     106        return type(divide(i,n,type) for i in x) 
     107    return type(i/n for i in x) 
     108 
     109def _multiply(x, n): 
     110    """elementwise multiplication of x by n, as if x were an array""" 
     111    # short-circuit cases for speed 
     112    if n is None: return x 
     113    try:   # for scalars and vectors (numpy.arrays) 
     114        -x # x*n might not throw an error 
     115        return x*n 
     116    except TypeError: pass 
     117    if n is 1: return itertype(x)(x) 
     118    # multiply by n != 1 for iterables (iter and non-iter) 
     119    xn = (_multiply(i,n) for i in x) 
     120    # return astype used to construct x, if possible 
     121    return itertype(x)(xn) 
     122 
     123def _divide(x, n): 
     124    """elementwise division of x by n, as if x were an array""" 
     125    # short-circuit cases for speed 
     126    if n is None: return x 
     127    try:   # for scalars and vectors (numpy.arrays) 
     128        return x/n 
     129    except TypeError: pass 
     130    if n is 1: return itertype(x)(x) 
     131    # divide by n != 1 for iterables (iter and non-iter) 
     132    xn = (_divide(i,n) for i in x) 
     133    # return astype used to construct x, if possible 
     134    return itertype(x)(xn) 
     135 
     136def _imultiply(x, n): 
     137    """iterator for elementwise 'array-like' multiplication of x by n""" 
     138    # short-circuit cases for speed 
     139    if n is None: return x 
     140    try:   # for scalars and vectors (numpy.arrays) 
     141        -x # x*n might not throw an error 
     142        return iter(x*n) 
     143    except TypeError: pass 
     144    if n is 1: return iter(x) 
     145    # multiply by n != 1 for iterables (iter and non-iter) 
     146    return (_multiply(i,n) for i in x) 
     147 
     148def _idivide(x, n): 
     149    """iterator for elementwise 'array-like' division of x by n""" 
     150    # short-circuit cases for speed 
     151    if n is None: return x 
     152    try:   # for scalars and vectors (numpy.arrays) 
     153        return iter(x/n) 
     154    except TypeError: pass 
     155    if n is 1: return iter(x) 
     156    # divide by n != 1 for iterables (iter and non-iter) 
     157    return (_divide(i,n) for i in x) 
     158 
     159def _amultiply(x, n): 
     160    """elementwise 'array-casting' multiplication of x by n""" 
     161    # short-circuit cases for speed 
     162    if n is None: return x 
     163    # convert to numpy array 
     164    import numpy 
     165    x = numpy.asarray(x) 
     166    if n is 1: return x 
     167    return x*n 
     168 
     169def _adivide(x, n): 
     170    """elementwise 'array-casting' division of x by n""" 
     171    # short-circuit cases for speed 
     172    if n is None: return x 
     173    # convert to numpy array 
     174    import numpy 
     175    x = numpy.asarray(x) 
     176    if n is 1: return x 
     177    return x/n 
     178 
     179def list_or_tuple(x): # set, ...? 
    53180    "True if x is a list or a tuple" 
    54181    return isinstance(x, (list, tuple)) 
    55182 
    56 def list_or_tuple_or_ndarray(x): 
     183def list_or_tuple_or_ndarray(x): # set, ...? 
    57184    "True if x is a list, tuple, or a ndarray" 
    58185    import numpy 
    … …  
    61188def listify(x): 
    62189    "recursivly convert all members of a sequence to a list" 
    63     if not list_or_tuple_or_ndarray(x): return x 
    64     #if isinstance(x, numpy.ndarray) and x.ndim == 0: return x # i.e. array(1) 
    65     if not list_or_tuple(x) and x.ndim == 0: return x.flatten()[0] 
     190    if not isiterable(x): return x 
     191    if x is iter(x): return listify(list(x)) 
     192    try: # e.g. if array(1) 
     193        if x.ndim == 0: return x.flatten()[0] 
     194    except Exception: pass 
    66195    return [listify(i) for i in x] 
    67196 

  • mystic/tests/test_solver_sanity.py

    r776 r791  
    7474       #if self.uselimits and self.maxiter == 0: iter=0 
    7575        # sanity check solver internals 
    76         self.assertTrue(solver.generations == len(solver._stepmon.y)-iter) 
     76        self.assertTrue(solver.generations == len(solver._stepmon._y)-iter) 
    7777        self.assertTrue(list(solver.bestSolution) == solver._stepmon.x[-1]) #XXX 
    7878        self.assertTrue(solver.bestEnergy == solver._stepmon.y[-1]) 
    … …  
    8282            self.assertTrue(ssow.x == solver._stepmon.x) 
    8383            self.assertTrue(ssow.y == solver._stepmon.y) 
     84            self.assertTrue(ssow._y == solver._stepmon._y) 
    8485        if self.useevalmon: 
    85             self.assertTrue(solver.evaluations == len(solver._evalmon.y)) 
     86            self.assertTrue(solver.evaluations == len(solver._evalmon._y)) 
    8687            self.assertTrue(esow.x == solver._evalmon.x) 
    8788            self.assertTrue(esow.y == solver._evalmon.y) 
     89            self.assertTrue(esow._y == solver._evalmon._y) 
    8890 
    8991        # Fail appropriately for solver/termination mismatch 
Note: See TracChangeset for help on using the changeset viewer.