vegas 6.1.2__cp311-cp311-macosx_11_0_arm64.whl → 6.2__cp311-cp311-macosx_11_0_arm64.whl

vegas/_vegas.pyx

@@ -34,6 +34,11 @@ import warnings
 import numpy
 import gvar
 
+if numpy.version.version >= '2.0':
+    FLOAT_TYPE = numpy.float64
+else:
+    FLOAT_TYPE = numpy.float_
+
 cdef double TINY = 10 ** (sys.float_info.min_10_exp + 50)  # smallest and biggest
 cdef double HUGE = 10 ** (sys.float_info.max_10_exp - 50)  # with extra headroom
 cdef double EPSILON = sys.float_info.epsilon * 1e4        # roundoff error threshold (see Schubert and Gertz Table 2)
@@ -230,8 +235,8 @@ cdef class AdaptiveMap:
                 "no of increments < 1 in AdaptiveMap -- %s"
                 % str(ninc)
                 )
-        new_inc = numpy.empty((dim, max(ninc)), numpy.float_)
-        new_grid = numpy.empty((dim, new_inc.shape[1] + 1), numpy.float_)
+        new_inc = numpy.empty((dim, max(ninc)), FLOAT_TYPE)
+        new_grid = numpy.empty((dim, new_inc.shape[1] + 1), FLOAT_TYPE)
         for d in range(dim):
             tmp = numpy.linspace(self.grid[d, 0], self.grid[d, self.ninc[d]], ninc[d] + 1)
             for i in range(ninc[d] + 1):
@@ -256,11 +261,11 @@ cdef class AdaptiveMap:
         if y is None:
             y = gvar.RNG.random(size=self.dim)
         else:
-            y = numpy.asarray(y, numpy.float_)
+            y = numpy.asarray(y, FLOAT_TYPE)
         y_shape = y.shape
         y.shape = -1, y.shape[-1]
         x = 0 * y
-        jac = numpy.empty(y.shape[0], numpy.float_)
+        jac = numpy.empty(y.shape[0], FLOAT_TYPE)
         self.map(y, x, jac)
         x.shape = y_shape
         return x
@@ -282,7 +287,7 @@ cdef class AdaptiveMap:
         y_shape = y.shape 
         y.shape = -1, y.shape[-1]
         ny = y.shape[0]
-        jac = numpy.empty(y.shape, numpy.float_)
+        jac = numpy.empty(y.shape, FLOAT_TYPE)
         for i in range(ny):
             for d in range(dim):
                 ninc = self.ninc[d]
@@ -451,8 +456,8 @@ cdef class AdaptiveMap:
         cdef numpy.npy_intp i, d
         if self.sum_f is None:
             shape = (self.inc.shape[0], self.inc.shape[1])
-            self.sum_f = numpy.zeros(shape, numpy.float_)
-            self.n_f = numpy.zeros(shape, numpy.float_) + TINY
+            self.sum_f = numpy.zeros(shape, FLOAT_TYPE)
+            self.n_f = numpy.zeros(shape, FLOAT_TYPE) + TINY
         if ny < 0:
             ny = y.shape[0]
         elif ny > y.shape[0]:
@@ -520,12 +525,12 @@ cdef class AdaptiveMap:
         if min(new_ninc) < 1:
             raise ValueError('ninc < 1: ' + str(list(new_ninc)))
         if max(new_ninc) == 1:
-            new_grid = numpy.empty((dim, 2), numpy.float_)
+            new_grid = numpy.empty((dim, 2), FLOAT_TYPE)
             for d in range(dim):
                 new_grid[d, 0] = self.grid[d, 0]
                 new_grid[d, 1] = self.grid[d, self.ninc[d]]
             self.grid = numpy.asarray(new_grid)
-            self.inc = numpy.empty((dim, 1), numpy.float_)
+            self.inc = numpy.empty((dim, 1), FLOAT_TYPE)
             self.ninc = numpy.array(dim * [1], dtype=numpy.intp)
             for d in range(dim):
                 self.inc[d, 0] = self.grid[d, 1] - self.grid[d, 0]
@@ -533,10 +538,10 @@ cdef class AdaptiveMap:
             return
 
         # smooth and regrid
-        new_grid = numpy.empty((dim, max(new_ninc) + 1), numpy.float_)
-        avg_f = numpy.ones(self.inc.shape[1], numpy.float_) # default = uniform
+        new_grid = numpy.empty((dim, max(new_ninc) + 1), FLOAT_TYPE)
+        avg_f = numpy.ones(self.inc.shape[1], FLOAT_TYPE) # default = uniform
         if alpha > 0 and max(self.ninc) > 1:
-            tmp_f = numpy.empty(self.inc.shape[1], numpy.float_)
+            tmp_f = numpy.empty(self.inc.shape[1], FLOAT_TYPE)
         for d in range(dim):
             old_ninc = self.ninc[d]
             if alpha != 0 and old_ninc > 1:
@@ -893,7 +898,7 @@ cdef class Integrator(object):
 
             More generally, the integrator packages integration points in 
             multidimensional arrays ``x[d1, d2..dn]`` when the integration 
-            limits are specified by ``map[d1, d2...dn, i]` with ``i=0,1``. 
+            limits are specified by ``map[d1, d2...dn, i]`` with ``i=0,1``. 
             These arrays can have any shape.
 
             Alternatively, the integration region can be specified by a 
@@ -1142,7 +1147,7 @@ cdef class Integrator(object):
             self.sum_sigf = numpy.sum(self.sigf)
             self.nstrat = numpy.array(map.nstrat)
         else:
-            self.sigf = numpy.array([], numpy.float_) # reset sigf (dummy)
+            self.sigf = numpy.array([], FLOAT_TYPE) # reset sigf (dummy)
             self.sum_sigf = HUGE
             args = dict(Integrator.defaults)
             if 'map' in args:
@@ -1169,7 +1174,7 @@ cdef class Integrator(object):
             self.sigf_h5.close()
             os.unlink(fname)
             self.sigf_h5 = None
-            self.sigf = numpy.array([], numpy.float_) # reset sigf (dummy)
+            self.sigf = numpy.array([], FLOAT_TYPE) # reset sigf (dummy)
             self.sum_sigf = HUGE
 
     def __reduce__(Integrator self not None):
@@ -1371,7 +1376,7 @@ cdef class Integrator(object):
                 # need to recalculate stratification distribution for beta>0
                 # unless a new sigf was set
                 old_val['sigf'] = self.sigf
-                self.sigf = numpy.array([], numpy.float_) # reset sigf (dummy)
+                self.sigf = numpy.array([], FLOAT_TYPE) # reset sigf (dummy)
                 self.sum_sigf = HUGE
             self.nstrat = nstrat
 
@@ -1398,7 +1403,7 @@ cdef class Integrator(object):
             # set up sigf
             self._clear_sigf_h5()
             if not self.minimize_mem:
-                self.sigf = numpy.ones(nsigf, numpy.float_)
+                self.sigf = numpy.ones(nsigf, FLOAT_TYPE)
             else:
                 try: 
                     import h5py
@@ -1410,10 +1415,10 @@ cdef class Integrator(object):
             self.sum_sigf = nsigf 
         self.neval_hcube = numpy.empty(self.min_neval_batch // 2 + 1, dtype=numpy.intp) 
         self.neval_hcube[:] = avg_neval_hcube
-        self.y = numpy.empty((self.min_neval_batch, self.dim), numpy.float_)
-        self.x = numpy.empty((self.min_neval_batch, self.dim), numpy.float_)
-        self.jac = numpy.empty(self.min_neval_batch, numpy.float_)
-        self.fdv2 = numpy.empty(self.min_neval_batch, numpy.float_)
+        self.y = numpy.empty((self.min_neval_batch, self.dim), FLOAT_TYPE)
+        self.x = numpy.empty((self.min_neval_batch, self.dim), FLOAT_TYPE)
+        self.jac = numpy.empty(self.min_neval_batch, FLOAT_TYPE)
+        self.fdv2 = numpy.empty(self.min_neval_batch, FLOAT_TYPE)
         return old_val
 
     def settings(Integrator self not None, ngrid=0):
@@ -1569,9 +1574,9 @@ cdef class Integrator(object):
         Integrator self not None,
         bint yield_hcube=False,
         bint yield_y=False,
-        fcn = None,
+        # fcn = None,
         ):
-        """ Iterator over integration points and weights.
+        """ Low-level batch iterator over integration points and weights.
 
         This method creates an iterator that returns integration
         points from |vegas|, and their corresponding weights in an
@@ -1669,10 +1674,10 @@ cdef class Integrator(object):
 
             # 1) resize work arrays if needed (to double what is needed)
             if neval_batch > self.y.shape[0]:
-                self.y = numpy.empty((2 * neval_batch, self.dim), numpy.float_)
-                self.x = numpy.empty((2 * neval_batch, self.dim), numpy.float_)
-                self.jac = numpy.empty(2 * neval_batch, numpy.float_)
-                self.fdv2 = numpy.empty(2 * neval_batch, numpy.float_)
+                self.y = numpy.empty((2 * neval_batch, self.dim), FLOAT_TYPE)
+                self.x = numpy.empty((2 * neval_batch, self.dim), FLOAT_TYPE)
+                self.jac = numpy.empty(2 * neval_batch, FLOAT_TYPE)
+                self.fdv2 = numpy.empty(2 * neval_batch, FLOAT_TYPE)
             y = self.y
             x = self.x
             jac = self.jac
@@ -1689,7 +1694,7 @@ cdef class Integrator(object):
                     tmp_hcube = (tmp_hcube - y0[d]) // self.nstrat[d]
                 for d in range(self.dim):
                     for i in range(i_start, i_start + neval_hcube[ihcube]):
-                        y[i, d] = (y0[d] + yran[i, d]) / self.nstrat[d]
+                        y[i, d] = (y0[d] + yran[i, d]) / self.nstrat[d] 
                 i_start += neval_hcube[ihcube]
             self.map.map(y, x, jac, neval_batch)
 
@@ -1721,7 +1726,7 @@ cdef class Integrator(object):
     def random(
         Integrator self not None, bint yield_hcube=False, bint yield_y=False
         ):
-        """ Iterator over integration points and weights.
+        """ Low-level iterator over integration points and weights.
 
         This method creates an iterator that returns integration
         points from |vegas|, and their corresponding weights in an
@@ -1764,6 +1769,56 @@ cdef class Integrator(object):
                 for i in range(x.shape[0]):
                     yield (x[i], wgt[i])
 
+    def sample(self, nbatch=None, mode='rbatch'):
+        """ Generate random sample of integration weights and points.
+
+        Given a :class:`vegas.Integrator` called ``integ``, the code ::
+
+            wgt, x = integ.sample(mode='lbatch')
+
+        generates a random array of integration points  ``x`` and the
+        array of corresponding weights ``w`` such that ::
+
+            r = sum(wgt * f(x))
+
+        is an estimate of the integral of ``lbatch`` integrand ``f(x)``. 
+        Setting parameter ``mode='rbatch'`` formats ``x`` for use 
+        in ``rbatch`` integrands.
+
+        Parameter ``nbatch`` specifies the minimum number of integration
+        points in the sample. The actual number is the smallest integer
+        multiple of ``integ.last_neval`` that is equal to or larger than  
+        ``nbatch``.
+        """
+        neval = self.last_neval if self.last_neval > 0 else self.neval
+        nbatch = neval if nbatch is None else int(nbatch)
+        nit = nbatch // neval 
+        if nit * neval < nbatch:
+            nit += 1    
+        samples = []
+        wgts = []
+        for _ in range(nit):
+            for x, w in self.random_batch():
+                samples.append(numpy.array(x))
+                wgts.append(numpy.array(w))
+        samples =  numpy.concatenate(samples, axis=0)
+        wgts = numpy.concatenate(wgts) / nit
+        # need to fix following to allow other formats for x
+        if self.xsample.shape is None:
+            if mode == 'rbatch':
+                samples = gvar.BufferDict(self.xsample, rbatch_buf=samples.T)
+            else:
+                samples = gvar.BufferDict(self.xsample, lbatch_buf=samples)
+        else:
+            if self.xsample.shape != ():
+                if mode == 'rbatch':
+                    samples = samples.T 
+                    samples.shape = self.xsample.shape + (-1,)
+                else:
+                    samples.shape = (-1,) + self.xsample.shape
+        return wgts, samples
+
+
     @staticmethod
     def synchronize_random():
         try:
@@ -1788,14 +1843,14 @@ cdef class Integrator(object):
     def _make_std_integrand(self, fcn, xsample=None):
         """ Convert integrand ``fcn`` into an lbatch integrand.
         
-        Returns an object of ``vi`` of type :class:`VegasIntegrand`.  
+        Returns an object ``vi`` of type :class:`VegasIntegrand`.  
         This object converts an arbitrary integrand ``fcn`` (``lbatch`, `rbatch`, 
         and non-batch, with or without dictionaries for input or output)
         into a standard form: an lbatch integrand whose output is a
         2-d lbatch array.
 
         This is useful when building integrands that call other 
-        functions of the parameters. The latter are converted 
+        functions of the parameters. The latter are converted to
         lbatch integrands irrespective of what they were 
         originally. This standardizes them, making it straightforward
         to build them into a new integrand.
@@ -1931,8 +1986,8 @@ cdef class Integrator(object):
         cdef double[::1] sum_wf
         cdef double[::1] sum_dwf
         cdef double[:, ::1] sum_dwf2
-        cdef double[::1] mean = numpy.empty(1, numpy.float_)
-        cdef double[:, ::1] var = numpy.empty((1, 1), numpy.float_)
+        cdef double[::1] mean = numpy.empty(1, FLOAT_TYPE)
+        cdef double[:, ::1] var = numpy.empty((1, 1), FLOAT_TYPE)
         cdef numpy.npy_intp itn, i, j, jtmp, s, t, neval, fcn_size, len_hcube
         cdef bint adaptive_strat
         cdef double sum_sigf, sigf2
@@ -1963,12 +2018,12 @@ cdef class Integrator(object):
         fcn_size = fcn.size
 
         # allocate work arrays
-        dwf = numpy.empty(fcn_size, numpy.float_)
-        sum_wf = numpy.empty(fcn_size, numpy.float_)
-        sum_dwf = numpy.empty(fcn_size, numpy.float_)
-        sum_dwf2 = numpy.empty((fcn_size, fcn_size), numpy.float_)
-        mean = numpy.empty(fcn_size, numpy.float_)
-        var = numpy.empty((fcn_size, fcn_size), numpy.float_)
+        dwf = numpy.empty(fcn_size, FLOAT_TYPE)
+        sum_wf = numpy.empty(fcn_size, FLOAT_TYPE)
+        sum_dwf = numpy.empty(fcn_size, FLOAT_TYPE)
+        sum_dwf2 = numpy.empty((fcn_size, fcn_size), FLOAT_TYPE)
+        mean = numpy.empty(fcn_size, FLOAT_TYPE)
+        var = numpy.empty((fcn_size, fcn_size), FLOAT_TYPE)
         mean[:] = 0.0
         var[:, :] = 0.0
         result = VegasResult(fcn, weighted=self.adapt)
@@ -1984,7 +2039,7 @@ cdef class Integrator(object):
 
             # iterate batch-slices of integration points
             for x, y, wgt, hcube in self.random_batch(
-                yield_hcube=True, yield_y=True, fcn=fcn
+                yield_hcube=True, yield_y=True, #fcn=fcn
                 ):
                 fdv2 = self.fdv2        # must be inside loop
                 len_hcube = len(hcube)
@@ -2005,10 +2060,13 @@ cdef class Integrator(object):
                             [(x[i*nx : (i+1)*nx], None) for i in range(self.nproc) if i*nx < x.shape[0]],
                             1,
                             )
-                    fx = numpy.concatenate(results, axis=0)
-                else:
-                    fx = fcn.eval(x, jac=self.map.jac1d(y) if self.uses_jac else None)
-                
+                    fx = numpy.concatenate(results, axis=0, dtype=float)
+                else: 
+                    # fx = fcn.eval(x, jac=self.map.jac1d(y) if self.uses_jac else None)
+                    fx = numpy.asarray(
+                        fcn.eval(x, jac=self.map.jac1d(y) if self.uses_jac else None),
+                        dtype=float
+                        )
                 # sanity check
                 if numpy.any(numpy.isnan(fx)):
                     raise ValueError('integrand evaluates to nan')
@@ -2958,14 +3016,14 @@ cdef class VegasIntegrand:
                 nx = x.shape[0] // self.mpi_nproc + 1
                 i0 = self.rank * nx
                 i1 = min(i0 + nx, x.shape[0])
-                f = numpy.empty((nx, self.size), numpy.float_)
+                f = numpy.empty((nx, self.size), FLOAT_TYPE)
                 if i1 > i0:
                     # fill f so long as haven't gone off end
                     if jac is None:
                         f[:(i1-i0)] = _eval(x[i0:i1], jac=None)
                     else:
                         f[:(i1-i0)] = _eval(x[i0:i1], jac=jac[i0:i1])
-                results = numpy.empty((self.mpi_nproc * nx, self.size), numpy.float_)
+                results = numpy.empty((self.mpi_nproc * nx, self.size), FLOAT_TYPE)
                 self.comm.Allgather(f, results)
                 return results[:x.shape[0]]
             self.eval = _mpi_eval
@@ -3108,7 +3166,7 @@ cdef class _BatchIntegrand_from_NonBatch(_BatchIntegrand_from_Base):
     def __call__(self, numpy.ndarray[numpy.double_t, ndim=2] x, jac=None):
         cdef numpy.npy_intp i
         cdef numpy.ndarray[numpy.float_t, ndim=2] f = numpy.empty(
-            (x.shape[0], self.size),  numpy.float_
+            (x.shape[0], self.size),  FLOAT_TYPE
             )
         if self.shape == ():
             # very common special case

vegas/_version.py

@@ -1 +1 @@
-__version__ = '6.1.2'
+__version__ = '6.2'

{vegas-6.1.2.dist-info → vegas-6.2.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: vegas
-Version: 6.1.2
+Version: 6.2
 Summary: Tools for adaptive multidimensional Monte Carlo integration.
 Home-page: https://github.com/gplepage/vegas
 Author: G. Peter Lepage
 Author-email: g.p.lepage@cornell.edu
 License: GPLv3
-Requires-Python: >=2.7
+Requires-Python: >=3.9
 License-File: LICENSE.txt
-Requires-Dist: numpy >=1.16
-Requires-Dist: gvar >=13.0.1
+Requires-Dist: numpy>=1.24
+Requires-Dist: gvar>=13.0.1
 
 vegas
 -----

vegas-6.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+vegas-6.2.dist-info/RECORD,,
+vegas-6.2.dist-info/WHEEL,sha256=aDf-IWQmq1RVXR_5Ck1qPm3e7xxy4ZeSSdW4ZZA07R8,109
+vegas-6.2.dist-info/top_level.txt,sha256=rnAmsIvsHyplln9ev-uw4hM7slW7VUdBQu9VgX8knkE,6
+vegas-6.2.dist-info/LICENSE.txt,sha256=YQSKRpj-PNC7SScHem3AECgwVONM-whKrs74SDueZxM,31996
+vegas-6.2.dist-info/METADATA,sha256=3YW5kUFPh3I6KynW55Y5htgIy8BYgRMGyaIslTzmj0Q,1837
+vegas/_version.py,sha256=NFnZu6AHpSuEkoJMZnfac0tWxuaxUxoN8Zg1vDKb_RE,20
+vegas/__init__.pxd,sha256=MzfsI-0xD0rFnyHl1UFXz-2wSvGjfGA9QFKuCTr5nhs,646
+vegas/_vegas.cpython-311-darwin.so,sha256=UePMGkRqc3UxrJHzP9b_YymZ-vkHbo89M3U9ZElM4Aw,1291264
+vegas/__init__.py,sha256=TWzA9zsS_xiNa_K3nC1NZZ4MlU7Vwaz0YtGJatzn3Jw,55840
+vegas/_vegas.pyx,sha256=XStCrwRe6kq8sCChLeaK2mQia89K8Jqhpp6s_84KhzE,143436
+vegas/_vegas.pxd,sha256=Qe0-Zuep8t9OXUq8yLLZ1T_e-7zABM4aN2inX6N4BX4,3035
+vegas/_vegas.c,sha256=t5KqhTYprI6yTSqjIA6zwn_VridiHWQGDDjhbciZWTs,5543127

{vegas-6.1.2.dist-info → vegas-6.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_11_0_arm64
 

vegas-6.1.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-vegas-6.1.2.dist-info/RECORD,,
-vegas-6.1.2.dist-info/WHEEL,sha256=sieEctgmsyAnWfDYOiunmkigyyjGmYuUaApm_YItwoI,110
-vegas-6.1.2.dist-info/top_level.txt,sha256=rnAmsIvsHyplln9ev-uw4hM7slW7VUdBQu9VgX8knkE,6
-vegas-6.1.2.dist-info/LICENSE.txt,sha256=YQSKRpj-PNC7SScHem3AECgwVONM-whKrs74SDueZxM,31996
-vegas-6.1.2.dist-info/METADATA,sha256=kL6jNelQ5SZFzJY3F8WlI6MsbskzBWxD7muxn6WQxUM,1841
-vegas/_version.py,sha256=Uej179rJLsiLVamUZe0A6Q6mYkLR6ugvUdzQjDyWjdU,22
-vegas/__init__.pxd,sha256=MzfsI-0xD0rFnyHl1UFXz-2wSvGjfGA9QFKuCTr5nhs,646
-vegas/_vegas.cpython-311-darwin.so,sha256=jPMJId8d5q9qu8WQ81Onf0p55OVu6Yx7etwpWzBeE2s,1290560
-vegas/__init__.py,sha256=TWzA9zsS_xiNa_K3nC1NZZ4MlU7Vwaz0YtGJatzn3Jw,55840
-vegas/_vegas.pyx,sha256=jc9SbG7IUP4c16Sn65zb-avP3Hdjz3S7LMunbVVEpe8,141213
-vegas/_vegas.pxd,sha256=Qe0-Zuep8t9OXUq8yLLZ1T_e-7zABM4aN2inX6N4BX4,3035
-vegas/_vegas.c,sha256=9TxLr6vSRFu07DQnRn6SYGDix5SrnwmcbcljhsrwYbQ,5460149