vegas 6.2__tar.gz → 6.3__tar.gz

{vegas-6.2 → vegas-6.3}/CHANGES.txt

@@ -1,3 +1,19 @@
+Version 6.3 2025-05-24
+========================
+Adds option gpu_pad to Integrator. Setting gpu_pad=True can make 
+GPU-based integrands run much faster. Thanks to Dmitriy Kim for 
+suggesting this quick fix.
+
+Version 6.2.1 2025-02-07
+========================
+- Integrator.random_batch() no longer exposes internal work buffers to users (it 
+  now makes copies).
+
+- Inconsistent behavior between adapt=False with minimize_mem=True 
+  or with minimize_mem=False is now fixed.
+
+- Cleaned up Cython.
+
 Version 6.2 2024-12-07
 ======================
 Modified so Integrator works with integrands that return 32-bit floats 

{vegas-6.2 → vegas-6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vegas
-Version: 6.2
+Version: 6.3
 Summary: Tools for adaptive multidimensional Monte Carlo integration.
 Home-page: https://github.com/gplepage/vegas
 Author: G. Peter Lepage
@@ -9,7 +9,7 @@ License: GPLv3
 Requires-Python: >=3.9
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.24
-Requires-Dist: gvar>=13.0.1
+Requires-Dist: gvar>=13.1.5
 
 vegas
 -----

{vegas-6.2 → vegas-6.3}/doc/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 400f818b4e250f87ae492a023cdea619
+config: c8492e4d0b3260fbb5d499fe8395f3a8
 tags: 645f666f9bcd5a90fca523b33c5a78b7

{vegas-6.2 → vegas-6.3}/doc/html/_sources/compiled_integrands.rst.txt

@@ -128,7 +128,7 @@ The main code is then::
 
     import vegas
 
-    from cython_ridge import ridge
+    from pythran_ridge import ridge
     ridge = vegas.lbatchintegrand(ridge)
 
     integ = vegas.Integrator(4 * [[0, 1]])
@@ -149,6 +149,7 @@ The following integrand ``ridge(x)`` uses the :mod:`jax` module to compile
 and run the ``ridge`` 
 integrand (from the previous sections) on a GPU::
 
+    import vegas 
     import jax 
     jnp = jax.numpy         
 
@@ -165,8 +166,15 @@ integrand (from the previous sections) on a GPU::
     def ridge(x):
         return _jridge(jnp.array(x))
 
+    integ = vegas.Integrator(4 * [[0, 1]], gpu_pad=True)
+
+    integ(ridge, nitn=10, neval=2e5)
+    result = integ(ridge, nitn=10, neval=2e5, adapt=False)
+    print('result = %s   Q = %.2f' % (result, result.Q))
+
 Code for the :mod:`mlx` module is almost identical::
 
+    import vegas
     import mlx.core as mx 
 
     @mx.compile
@@ -182,12 +190,37 @@ Code for the :mod:`mlx` module is almost identical::
     def ridge(x):
         return _mridge(mx.array(x))    
 
-These integrands run 20 times faster than  the original (vectorized) batch 
-integrand (1 sec versus 20 sec using the built-in GPU on a 2024 laptop). 
+    integ = vegas.Integrator(4 * [[0, 1]], gpu_pad=True)
+
+    integ(ridge, nitn=10, neval=2e5)
+    result = integ(ridge, nitn=10, neval=2e5, adapt=False)
+    print('result = %s   Q = %.2f' % (result, result.Q))
+
+These integrands run more than 20 times faster than  the  
+:ref:`original (vectorized) batch integrand<faster_integrands>`
+(less than 1 sec versus 20 sec using the built-in GPU on a 2024 laptop). 
 The speedup is substantial because this integrand is quite 
 costly to evaluate; the original batch integrand is just as fast as the GPU
 versions when ``N=1`` (instead of ``N=1000``).
 
+Note that :class:`vegas.Integrator` parameter ``gpu_pad`` is set equal 
+to ``True`` in the GPU examples. This instructs |vegas| to pad the batches 
+of integrator points sent to the integrand so that each batch is the same 
+size, which typically improves GPU performance. The number of integration 
+points in each batch is the smaller of ``neval``, and the sum of 
+the  :class:`vegas.Integrator` 
+parameters ``min_neval_batch`` and ``max_neval_hcube``. 
+
+The number of integration points added in the pad is smaller than 
+``max_neval_hcube`` (unless ``neval`` sets the batch size). The integrand 
+is evaluated for these points, but the results are discarded. The additional 
+cost from evaluating the integrand for the discarded points is generally 
+much smaller than the 
+benefit coming from a constant batch size. The fraction of integrand 
+evaluations discarded in this way is smaller than ``max_neval_hcube`` divided 
+by ``min_neval_batch``, and therefore can be reduced by increasing the latter 
+parameter (or decreasing the former paramter).
+
 
 
 C and Fortran

{vegas-6.2 → vegas-6.3}/doc/html/_sources/tutorial.rst.txt

@@ -1029,23 +1029,33 @@ Adding a decorator to the integrand function ``ridge(x)`` ::
 reduces the run time to 20 sec, which is more than 170 times faster.
 
 The decorator instructs |vegas| to present integration points to 
-the integrand in batches of 50,000 points 
+the integrand in batches of approximately 50,000 points 
 (|vegas| parameter ``min_neval_batch``)
 rather than offering them one at a time.
 Here, for example, function ``ridge(x)`` with the decorator
 takes as its argument  an array of integration
 points --- ``x[d, i]`` where ``d=0...`` labels the direction and 
 ``i=0...`` the integration point --- and returns an array of integrand 
-values ``ans[i] * norm`` corresponding  to those points. Typically one 
-must modify the integrand code to deal with the extra index ``i``, 
-but that is not necessary in ``ridge`` because the extra index is handled 
-implicitly: ``x[d]`` represents an array ``x[d, :]`` of values when 
-using the decorator. 
-The batch integrand is faster because the arrays are :mod:`numpy` 
-arrays, and therefore arithmetic operators act on the entire arrays using
-highly optimized (compiled) :mod:`numpy` code. 
-The integrand is evaluated for all integration points in a batch at 
-the same time. 
+values ``ans[i] * norm`` corresponding  to those points. As a result 
+the code uses :mod:`numpy` vectorization to evaluate the integrand 
+for all 50,000 integration points in the batch at the same time, which is 
+much faster than handling the points separately. 
+The loop in the integrand could have been rewritten ::
+
+        for x0 in np.linspace(0.25, 0.75, N):
+            dx2 = (x[0, :] - x0) ** 2
+            for d in range(1, dim):
+                dx2[:] += (x[d, :] - x0) ** 2
+            ans[:] += np.exp(-100. * dx2[:]) 
+
+to make the batch index explicit (``:``); here ``x[d]``, 
+``dx2``, and ``ans`` are all :mod:`numpy` arrays with 
+50,000 values, one for each integration point. Typically 
+one must modify the integrand 
+code to deal with the extra index ``i``
+when adding a batch decorator, but that wasn't 
+necessary in ``ridge`` because trailing indices can be 
+left implicit in :mod:`numpy` arrays.
 
 The advantage gained from using |vegas|'s batch mode 
 (with :mod:`numpy` vectorization)
@@ -1181,7 +1191,7 @@ Here the decorator ``@numba.njit`` causes the ``ridge`` function to be
 compiled into efficient machine code the first time it is called, and 
 the machine code is used in place of the Python function for that 
 and all subsequent calls. :mod:`numba` is particularly effective when 
-used with low-level code such as this, where standard numerical 
+compiling low-level code such as this, where standard numerical 
 datatypes (integers, floats) are manipulated directly (rather than 
 relying on :mod:`numpy` array operations). This code is somewhat 
 faster than the batch integrands above that use :mod:`numpy` array 
@@ -1951,33 +1961,35 @@ The final result is the sum of the results from all the hypercubes.
 
 To mimic a full |vegas| integral estimate using the iterators above, we need
 to know which points belong to which hypercubes. The following code
-shows how this is done::
+shows how this is done, now averaging over ``nitn`` iterations (equivalent 
+to what |vegas| does when ``adapt=False``)::
 
     import gvar as gv 
 
     integral = 0.0
     variance = 0.0
-    for x, wgt, hcube in integ.random_batch(yield_hcube=True):
-        wgt_fx = wgt * batch_f(x)
-        # iterate over hypercubes: compute variance for each,
-        #                          and accumulate for final result
-        for i in range(hcube[0], hcube[-1] + 1):
-            idx = (hcube == i)          # select array items for h-cube i
-            nwf = np.sum(idx)           # number of points in h-cube i
-            wf = wgt_fx[idx]
-            sum_wf = np.sum(wf)         # sum of wgt * f(x) for h-cube i
-            sum_wf2 = np.sum(wf ** 2)   # sum of (wgt * f(x)) ** 2
-            integral += sum_wf
-            variance += (sum_wf2 * nwf - sum_wf ** 2) / (nwf - 1.)
-    # answer = integral;   standard deviation = variance ** 0.5
-    result = gv.gvar(integral, variance ** 0.5)
+    nitn = 10                                       # number of iterations
+    for it in range(1, nitn + 1):
+        for x, wgt, hcube in integ.random_batch(yield_hcube=True):
+            wgt_fx = wgt * batch_f(x)
+            # iterate over hypercubes: compute variance for each,
+            #                          and accumulate for final result
+            for i in range(hcube[0], hcube[-1] + 1):
+                idx = (hcube == i)                  # select array items for h-cube i
+                nwf = np.sum(idx)                   # number of points in h-cube i
+                wf = wgt_fx[idx]
+                sum_wf = np.sum(wf, axis=0)         # sum of wgt * f(x) for h-cube i
+                sum_wf2 = np.sum(wf ** 2, axis=0)   # sum of (wgt * f(x)) ** 2
+                integral += sum_wf
+                variance += (sum_wf2 * nwf - sum_wf ** 2) / (nwf - 1.)
+    # answer = integral/nitn;   standard deviation = (variance/nitn**2) ** 0.5
+    result = gv.gvar(integral / nitn, (variance / nitn**2) ** 0.5)
 
 Here ``hcube[i]`` identifies the hypercube containing ``x[i, d]``. This example is 
 easily modified to provide information about the |vegas| Jacobian to the integrand, if needed 
 (see the section :ref:`vegas_Jacobian`)::
 
-    integral = 0.0
-    variance = 0.0
+    ...
     for x, y, wgt, hcube in integ.random_batch(yield_hcube=True, yield_y=True):
         wgt_fx = wgt * batch_f(x, jac=integ.map.jac1d(y))
         ...
@@ -1985,8 +1997,7 @@ easily modified to provide information about the |vegas| Jacobian to the integra
 The example is also easily modified for integrands ``batch_f(xd)`` where ``xd`` 
 is a dictionary::
 
-    integral = 0.0
-    variance = 0.0
+    ...
     for x, wgt, hcube in integ.random_batch(yield_hcube=True):
         xd = gv.BufferDict(integ.xdict, lbatch_buf=x)
         wgt_fx = wgt * batch_f(xd)

{vegas-6.2 → vegas-6.3}/doc/html/_static/documentation_options.js

@@ -1,5 +1,5 @@
 const DOCUMENTATION_OPTIONS = {
-    VERSION: '6.2',
+    VERSION: '6.3',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',

{vegas-6.2 → vegas-6.3}/doc/html/background.html

@@ -5,10 +5,10 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
-    <title>How vegas Works &#8212; vegas 6.2 documentation</title>
+    <title>How vegas Works &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="genindex.html" />
@@ -38,7 +38,7 @@
         <li class="right" >
           <a href="compiled_integrands.html" title="Compiled Integrands for Speed; GPUs"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">How <code class="xref py py-mod docutils literal notranslate"><span class="pre">vegas</span></code> Works</a></li> 
       </ul>
     </div>  
@@ -376,7 +376,7 @@ integrals.</p>
         <li class="right" >
           <a href="compiled_integrands.html" title="Compiled Integrands for Speed; GPUs"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">How <code class="xref py py-mod docutils literal notranslate"><span class="pre">vegas</span></code> Works</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/compiled_integrands.html

@@ -5,10 +5,10 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
-    <title>Compiled Integrands for Speed; GPUs &#8212; vegas 6.2 documentation</title>
+    <title>Compiled Integrands for Speed; GPUs &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="genindex.html" />
@@ -38,7 +38,7 @@
         <li class="right" >
           <a href="tutorial.html" title="Tutorial"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Compiled Integrands for Speed; GPUs</a></li> 
       </ul>
     </div>  
@@ -162,7 +162,7 @@ an optimized Python module <code class="xref py py-mod docutils literal notransl
 <p>The main code is then:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">vegas</span>
 
-<span class="kn">from</span> <span class="nn">cython_ridge</span> <span class="kn">import</span> <span class="n">ridge</span>
+<span class="kn">from</span> <span class="nn">pythran_ridge</span> <span class="kn">import</span> <span class="n">ridge</span>
 <span class="n">ridge</span> <span class="o">=</span> <span class="n">vegas</span><span class="o">.</span><span class="n">lbatchintegrand</span><span class="p">(</span><span class="n">ridge</span><span class="p">)</span>
 
 <span class="n">integ</span> <span class="o">=</span> <span class="n">vegas</span><span class="o">.</span><span class="n">Integrator</span><span class="p">(</span><span class="mi">4</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]])</span>
@@ -183,7 +183,8 @@ the <code class="xref py py-mod docutils literal notranslate"><span class="pre">
 The following integrand <code class="docutils literal notranslate"><span class="pre">ridge(x)</span></code> uses the <code class="xref py py-mod docutils literal notranslate"><span class="pre">jax</span></code> module to compile
 and run the <code class="docutils literal notranslate"><span class="pre">ridge</span></code>
 integrand (from the previous sections) on a GPU:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">jax</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">vegas</span>
+<span class="kn">import</span> <span class="nn">jax</span>
 <span class="n">jnp</span> <span class="o">=</span> <span class="n">jax</span><span class="o">.</span><span class="n">numpy</span>
 
 <span class="nd">@jax</span><span class="o">.</span><span class="n">jit</span>
@@ -198,10 +199,17 @@ integrand (from the previous sections) on a GPU:</p>
 <span class="nd">@vegas</span><span class="o">.</span><span class="n">rbatchintegrand</span>
 <span class="k">def</span> <span class="nf">ridge</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
     <span class="k">return</span> <span class="n">_jridge</span><span class="p">(</span><span class="n">jnp</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
+
+<span class="n">integ</span> <span class="o">=</span> <span class="n">vegas</span><span class="o">.</span><span class="n">Integrator</span><span class="p">(</span><span class="mi">4</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]],</span> <span class="n">gpu_pad</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
+
+<span class="n">integ</span><span class="p">(</span><span class="n">ridge</span><span class="p">,</span> <span class="n">nitn</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">neval</span><span class="o">=</span><span class="mf">2e5</span><span class="p">)</span>
+<span class="n">result</span> <span class="o">=</span> <span class="n">integ</span><span class="p">(</span><span class="n">ridge</span><span class="p">,</span> <span class="n">nitn</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">neval</span><span class="o">=</span><span class="mf">2e5</span><span class="p">,</span> <span class="n">adapt</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
+<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;result = </span><span class="si">%s</span><span class="s1">   Q = </span><span class="si">%.2f</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">Q</span><span class="p">))</span>
 </pre></div>
 </div>
 <p>Code for the <code class="xref py py-mod docutils literal notranslate"><span class="pre">mlx</span></code> module is almost identical:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">mlx.core</span> <span class="k">as</span> <span class="nn">mx</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">vegas</span>
+<span class="kn">import</span> <span class="nn">mlx.core</span> <span class="k">as</span> <span class="nn">mx</span>
 
 <span class="nd">@mx</span><span class="o">.</span><span class="n">compile</span>
 <span class="k">def</span> <span class="nf">_mridge</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
@@ -215,13 +223,36 @@ integrand (from the previous sections) on a GPU:</p>
 <span class="nd">@vegas</span><span class="o">.</span><span class="n">rbatchintegrand</span>
 <span class="k">def</span> <span class="nf">ridge</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
     <span class="k">return</span> <span class="n">_mridge</span><span class="p">(</span><span class="n">mx</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
+
+<span class="n">integ</span> <span class="o">=</span> <span class="n">vegas</span><span class="o">.</span><span class="n">Integrator</span><span class="p">(</span><span class="mi">4</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]],</span> <span class="n">gpu_pad</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
+
+<span class="n">integ</span><span class="p">(</span><span class="n">ridge</span><span class="p">,</span> <span class="n">nitn</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">neval</span><span class="o">=</span><span class="mf">2e5</span><span class="p">)</span>
+<span class="n">result</span> <span class="o">=</span> <span class="n">integ</span><span class="p">(</span><span class="n">ridge</span><span class="p">,</span> <span class="n">nitn</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">neval</span><span class="o">=</span><span class="mf">2e5</span><span class="p">,</span> <span class="n">adapt</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
+<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;result = </span><span class="si">%s</span><span class="s1">   Q = </span><span class="si">%.2f</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">Q</span><span class="p">))</span>
 </pre></div>
 </div>
-<p>These integrands run 20 times faster than  the original (vectorized) batch
-integrand (1 sec versus 20 sec using the built-in GPU on a 2024 laptop).
+<p>These integrands run more than 20 times faster than  the
+<a class="reference internal" href="tutorial.html#faster-integrands"><span class="std std-ref">original (vectorized) batch integrand</span></a>
+(less than 1 sec versus 20 sec using the built-in GPU on a 2024 laptop).
 The speedup is substantial because this integrand is quite
 costly to evaluate; the original batch integrand is just as fast as the GPU
 versions when <code class="docutils literal notranslate"><span class="pre">N=1</span></code> (instead of <code class="docutils literal notranslate"><span class="pre">N=1000</span></code>).</p>
+<p>Note that <a class="reference internal" href="vegas.html#vegas.Integrator" title="vegas.Integrator"><code class="xref py py-class docutils literal notranslate"><span class="pre">vegas.Integrator</span></code></a> parameter <code class="docutils literal notranslate"><span class="pre">gpu_pad</span></code> is set equal
+to <code class="docutils literal notranslate"><span class="pre">True</span></code> in the GPU examples. This instructs <a class="reference internal" href="vegas.html#module-vegas" title="vegas: Adaptive multidimensional Monte Carlo integration"><code class="xref py py-mod docutils literal notranslate"><span class="pre">vegas</span></code></a> to pad the batches
+of integrator points sent to the integrand so that each batch is the same
+size, which typically improves GPU performance. The number of integration
+points in each batch is the smaller of <code class="docutils literal notranslate"><span class="pre">neval</span></code>, and the sum of
+the  <a class="reference internal" href="vegas.html#vegas.Integrator" title="vegas.Integrator"><code class="xref py py-class docutils literal notranslate"><span class="pre">vegas.Integrator</span></code></a>
+parameters <code class="docutils literal notranslate"><span class="pre">min_neval_batch</span></code> and <code class="docutils literal notranslate"><span class="pre">max_neval_hcube</span></code>.</p>
+<p>The number of integration points added in the pad is smaller than
+<code class="docutils literal notranslate"><span class="pre">max_neval_hcube</span></code> (unless <code class="docutils literal notranslate"><span class="pre">neval</span></code> sets the batch size). The integrand
+is evaluated for these points, but the results are discarded. The additional
+cost from evaluating the integrand for the discarded points is generally
+much smaller than the
+benefit coming from a constant batch size. The fraction of integrand
+evaluations discarded in this way is smaller than <code class="docutils literal notranslate"><span class="pre">max_neval_hcube</span></code> divided
+by <code class="docutils literal notranslate"><span class="pre">min_neval_batch</span></code>, and therefore can be reduced by increasing the latter
+parameter (or decreasing the former paramter).</p>
 </section>
 <section id="c-and-fortran">
 <h2>C and Fortran<a class="headerlink" href="#c-and-fortran" title="Link to this heading">¶</a></h2>
@@ -691,7 +722,7 @@ speed as the batch versions of the C code, above.</p>
         <li class="right" >
           <a href="tutorial.html" title="Tutorial"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Compiled Integrands for Speed; GPUs</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/genindex.html

@@ -4,10 +4,10 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Index &#8212; vegas 6.2 documentation</title>
+    <title>Index &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="#" />
@@ -29,7 +29,7 @@
         <li class="right" >
           <a href="py-modindex.html" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Index</a></li> 
       </ul>
     </div>  
@@ -422,7 +422,7 @@
         <li class="right" >
           <a href="py-modindex.html" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Index</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/index.html

@@ -5,10 +5,10 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
-    <title>vegas Documentation &#8212; vegas 6.2 documentation</title>
+    <title>vegas Documentation &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="genindex.html" />
@@ -34,7 +34,7 @@
         <li class="right" >
           <a href="tutorial.html" title="Tutorial"
              accesskey="N">next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="#">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">vegas Documentation</a></li> 
       </ul>
     </div>  
@@ -159,7 +159,7 @@
         <li class="right" >
           <a href="tutorial.html" title="Tutorial"
              >next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="#">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">vegas Documentation</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/outliers.html

@@ -5,10 +5,10 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
-    <title>Case Study: Bayesian Curve Fitting &#8212; vegas 6.2 documentation</title>
+    <title>Case Study: Bayesian Curve Fitting &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="genindex.html" />
@@ -38,7 +38,7 @@
         <li class="right" >
           <a href="background.html" title="How vegas Works"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Case Study: Bayesian Curve Fitting</a></li> 
       </ul>
     </div>  
@@ -472,7 +472,7 @@ example, the intercept would be 0.35(17).</p>
         <li class="right" >
           <a href="background.html" title="How vegas Works"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Case Study: Bayesian Curve Fitting</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/py-modindex.html

@@ -4,10 +4,10 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Python Module Index &#8212; vegas 6.2 documentation</title>
+    <title>Python Module Index &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <link rel="index" title="Index" href="genindex.html" />
@@ -36,7 +36,7 @@
         <li class="right" >
           <a href="#" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Python Module Index</a></li> 
       </ul>
     </div>  
@@ -94,7 +94,7 @@
         <li class="right" >
           <a href="#" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Python Module Index</a></li> 
       </ul>
     </div>

{vegas-6.2 → vegas-6.3}/doc/html/search.html

@@ -4,11 +4,11 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Search &#8212; vegas 6.2 documentation</title>
+    <title>Search &#8212; vegas 6.3 documentation</title>
     <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4848ba22" />
     <link rel="stylesheet" type="text/css" href="_static/pyramid.css?v=310c80ee" />
     
-    <script src="_static/documentation_options.js?v=ef7fcc1c"></script>
+    <script src="_static/documentation_options.js?v=4b074805"></script>
     <script src="_static/doctools.js?v=9a2dae69"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/searchtools.js"></script>
@@ -36,7 +36,7 @@
         <li class="right" >
           <a href="py-modindex.html" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Search</a></li> 
       </ul>
     </div>  
@@ -93,7 +93,7 @@
         <li class="right" >
           <a href="py-modindex.html" title="Python Module Index"
              >modules</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.2 documentation</a> &#187;</li>
+        <li class="nav-item nav-item-0"><a href="index.html">vegas 6.3 documentation</a> &#187;</li>
         <li class="nav-item nav-item-this"><a href="">Search</a></li> 
       </ul>
     </div>