Changeset 769

Timestamp:

11/14/14 16:34:38 (18 months ago)

Author:

mmckerns

Message:

add ones and exact keyword options to math.grid.randomly_bin;
lattice solver now takes same nbins as LatticeSolver? (defaults to 2ndim)

Location:

mystic

Files:

• _math/grid.py (modified) (3 diffs)
• mystic/abstract_ensemble_solver.py (modified) (1 diff)
• mystic/ensemble.py (modified) (3 diffs)

mystic/_math/grid.py

@@ -25 +25 @@
 def samplepts(lb,ub,npts):
     """
-takes upper and lower bounds (e.g. ub = [2,4], lb = [0,3])
+takes lower and upper bounds (e.g. lb = [0,3], ub = [2,4])
 produces a list of sample points s = [[1,3],[1,4],[2,3],[2,4]]
 
 Inputs:
-    lower bounds  --  a list of the lower bounds
-    upper bounds  --  a list of the upper bounds
+    lb  --  a list of the lower bounds
+    ub  --  a list of the upper bounds
     npts  --  number of sample points
     """
@@ -40 +40 @@
 
 
-def randomly_bin(nbins, ndim):
-    """generate n bins randomly gridded across ndim dimensions"""
+def randomly_bin(N, ndim=None, ones=True, exact=True):
+    """
+generate N bins randomly gridded across ndim dimensions
+
+Inputs:
+    N  --  integer number of bins, where N = prod(bins)
+    ndim  --  integer length of bins, thus ndim = len(bins)
+    ones  --  if False, prevent bins from containing "1s", wherever possible
+    exact  --  if False, find N-1 bins for prime numbers
+    """
+    if ndim == 0: return []
+    if N == 0: return [0] if ndim else [0]*ndim
     from itertools import chain
     from random import random
@@ -54 +64 @@
             if n == 1:
                 return result
-    result = factors(nbins)
-    result += [1] * (ndim - (len(result) / ndim))
-    result = sorted(result, key=lambda v: random())
+    result = factors(N)
+    dim = nfact = len(result)
+    prime = nfact == 1
+    if ndim: result += [1] * (ndim - (nfact / ndim));  dim = ndim
+    elif ones: result += [1] # add some 'randomness' by adding a "1"
+    # if ones, mix in the 1s; otherwise, only use 1s when ndim < len(result)
+    if ones: result = sorted(result, key=lambda v: random())
+    else: result[:nfact] = sorted(result[:nfact], key=lambda v: random())
     from numpy import prod
-    return [prod(result[i::ndim]) for i in range(ndim)]
+    result = [prod(result[i::dim]) for i in range(dim)]
+    # if not ones, now needs a full sort to sort in the 1s
+    if not ones: result = sorted(result, key=lambda v: random())
+    elif not ndim and 1 in result: result.remove(1) # remove the added "1"
+    # if it's a prime, then do N-1 if exact=False
+    if not exact and N > 3 and prime:
+        result = randomly_bin(N-1, ndim, ones)
+    return result
 
 

mystic/mystic/abstract_ensemble_solver.py

@@ -120 +120 @@
         if isinstance(nbins, int):
             from mystic.math.grid import randomly_bin
-            nbins = randomly_bin(nbins, dim)
+            nbins = randomly_bin(nbins, dim, ones=True, exact=True)
         self._nbins           = nbins
         npts = 1

mystic/mystic/ensemble.py

@@ -366 +366 @@
 
 
-def lattice(cost,ndim,nbins=2,args=(),bounds=None,ftol=1e-4,maxiter=None, \
+def lattice(cost,ndim,nbins=None,args=(),bounds=None,ftol=1e-4,maxiter=None, \
             maxfun=None,full_output=0,disp=1,retall=0,callback=None,**kwds):
     """Minimize a function using the lattice ensemble solver.
@@ -381 +381 @@
     cost -- the Python function or method to be minimized.
     ndim -- dimensionality of the problem.
-    nbins -- tuple of number of bins in each dimension.
+    nbins -- tuple of number of bins in each dimension. [default = (2,)*ndim]
 
 Additional Inputs:
@@ -448 +448 @@
         termination = VTRChangeOverGeneration(ftol)
 
-    if isinstance(nbins, int): nbins = [nbins]*ndim
+    if nbins is None: nbins = 2**ndim
 
     solver = LatticeSolver(ndim,nbins)