Vegas

========================

- Introduced new method Integrator.multi for doing multiple integrals
simultaneously, using the same integration points for all of the
integrals. Integrating simultaneously can lead to very large reductions
in the uncertainties for ratios or differences of integrals whose
integrands are very similar. See discussion in the documentation under
"Multiple Integrands Simultaneously."

- Introduced iterators (Integrator.random and Integrator.random_vec)
that return |vegas| integration points and weights
for applications that use |vegas| as a random number generator.

- Changed the semantics concerning the memory optimization introduced in
v1.2. To run with minimum memory set parameter minimize_mem = True. This
will cause vegas to use extra integrand evaluations, which can slow it by
50-100%, but also decouples the internal memory used from neval. The
default value, False, is the better choice unless vegas is running out
of RAM. Parameter max_nhcube limits the number of h-cubes used in the
stratification, unless beta=0 or minimize_mem=True in which case it is
ignored.

========================

- Memory optimization: The (new) adaptive stratified sampling algorithm
can use a lot of memory since it must store a float (sigf = the std dev of
the integrand) for each h-cube. When neval gets to be 1e8 or larger,
the memory needs start to approach typical RAM limits (in laptops,
anyway). To avoid exceeding these limits, which would greatly slow
progress, vegas now switches to a different mode of operation when
the number of h-cubes exceeds parameter max_nhcube (set by default
to 5e8). Rather than store values of sigf for every h-cube for use
in the next iteration, it recomputes sigf just before it uses it
to move integrand evalutions around (and then throws the sigf value away).
This requires extra integrand evaluations, beyond those used to estimate
the integral. The number of extra evaluations is between 50% and 100% of
the number used to estimate the integral, typically increasing
execution time by the same fractions. This is worthwhile provided the
adaptive stratified sampling decreases errors by at least 30%
(since omitting it would allow up to 2x as many integration points
for the same cost, decreasing errors by a factor of 1/sqrt(2)). The
adaptive stratified sampling usually decreases errors by this amount,
and frequently by much more. The new mode is in operation if (internal)
attribute minimize_sigf_mem is True. Again the threshold for this
new behavior is set by max_nhcube which is 5e8 by default, which
is sufficiently large that this new mode will be used quite
infrequently.

- Refactored Integrator._integrate to prepare for future project.

- Tests for beta=0.0 mode and for the propagation of Python exceptions
from the integrand.

- More polished documentation - still a work in progress.

- Fixed bug in pickling of Integrator. Added testing for pickling.

============================
Fixed a tiny typo that would not cause problems particularly,
but needed to be fixed --- code would not import gvar from lsqfit
even if it was present.

Also made the slower examples run faster, so you don't have
to wait so long. Added a plot to the path-integral example to
compare the lattice path-integral result with the exact result
(provided matplotlib installed).

=========================

Original release made use of the lsqfit package in the testing. This package
is quite useful in conjunction with vegas (for the gvar module) but it is not
required. The testing and examples now work without lsqfit present, which was
the original intent. See discussion at the end of the Tutorial about the role
of lsqfit.

==========================
This is the first version of a new implementation
of the vegas algorithm for adaptive multidimensional
Monte Carlo integration. It is written in Python/Cython
and features a significantly improved algorithm
relative to earlier versions of vegas. In particular
it now uses two adaptive strategies instead of one.