2004-06-02  Brian Gough  <bjg@network-theory.co.uk>

	* test_main.c: handle the case where sd==0 && error[i] !=0 more
	carefully

Mon Apr 23 13:23:47 2001  Brian Gough  <bjg@network-theory.co.uk>

	* test_main.c: removed unused status variable

Sat Jan  6 19:56:49 2001  Brian Gough  <bjg@network-theory.co.uk>

	* miser.c (gsl_monte_miser_free): fixed memory leak for s->hits_{r,l}

	* vegas.c (gsl_monte_vegas_free): fixed memory leak for s->x

Fri Dec 22 21:43:04 2000  Brian Gough  <bjg@network-theory.co.uk>

	* miser.c: removed max-min estimation method for subvolumes. We
 	will use the standard variance method and try to use a sufficient
 	number of points to estimate the variance reliably.

Wed Dec 20 21:32:40 2000  Brian Gough  <bjg@network-theory.co.uk>

	* vegas.c: tidied up the algorithm, deal with cases of sigma = 0
 	explicitly.

Sat Dec  9 14:19:53 2000  Brian Gough  <bjg@network-theory.co.uk>

	* reorganization and clean up

Thu Nov 16 19:50:27 2000  Brian Gough  <bjg@network-theory.co.uk>

	* miser.c: rewrite to fix overflows and make calling conventions
 	consistent 

	* plain.c: rewrite to fix overflows and make calling conventions
 	consistent

Thu Oct 26 20:06:36 2000  Brian Gough  <bjg@network-theory.co.uk>

	* plain.c (gsl_monte_plain_integrate): integer factor
 	calls*(calls-1) used in numerical expression can easily overflow,
 	changed to calls*(calls-1.0).
	
Sat Oct 21 20:36:06 2000  Brian Gough  <bjg@network-theory.co.uk>
 
        * miser.c (gsl_monte_miser_integrate): fixed bug where hits_l was
        used in place of hits_r

Tue Sep 19 19:16:37 2000  Brian Gough  <bjg@network-theory.co.uk>

	* plain.c (gsl_monte_plain_alloc): initialise check_done to avoid
 	warning about use of unitialised memory

	* vegas.c (gsl_monte_vegas_alloc): as above

	* miser.c (gsl_monte_miser_alloc): as above

	* plain.c miser.c: removed use of sprintf for error messages

Wed May 31 19:50:19 2000  Brian Gough  <bjg@network-theory.co.uk>

	* miser_test.c (main): increased tolerances to allow tests to pass
 	with different compilers

Mon May 15 15:26:22 2000  Brian Gough  <bjg@network-theory.co.uk>

	* vegas_test.c (main): added gsl_ieee_env_setup() to allow change
 	of precision in tests

	* miser_test.c (main): ditto

	* plain_test.c (main): ditto

Fri Feb 26 14:49:56 1999  Brian Gough  <bjg@netsci.freeserve.co.uk>

	* Makefile.am: removed ..._LDFLAGS = -static since this is
 	specific to gcc



Wed Nov 18 10:59:56 1998  Brian Gough  <bjg@vvv.lanl.gov>

	* use standard headers templates_on.h and templates_off.h instead
 	of source.h

Tue Nov 17 16:49:12 1998  Brian Gough  <bjg@vvv.lanl.gov>

	* added #include <config.h> to all top-level source files

	* plain.c (gsl_monte_plain_integrate): replaced myMAX by GSL_MAX

	* utils.c: move macros around to avoid double definition

Fri Aug 14 10:12:06 1998  Brian Gough  <bjg@vvv.lanl.gov>

	* Makefile.am: I needed to add utils.h to libgslmonte_a_SOURCES to
 	get it to work with my automake

Thu Jul 30 17:31:29 1998  booth  <booth@planck.pha.jhu.edu>

	* gsl_monte_miser.h, miser.c:
	Turn off the annoying warning in miser unless the user requests it.

Wed Jul 29 20:24:54 1998  bjg  <bjg@vvv.lanl.gov>

	* Makefile.am, Makefile.in: some fixes to pass make distcheck

	* Makefile.am, Makefile.in:
	experimenting with new top level makefile.am

Tue Jul 28 17:05:20 1998  booth  <booth@planck.pha.jhu.edu>

	* plain.c, vegas.c, miser.c:
	make all the _free functions check their argument.  Also, the init functions
	now throw EFAULT if given a null pointer.

	* gsl_monte_vegas.h, vegas.c:
	vegas1, vegas2 and vegas3 all go away.  Get them by setting the "stage"
	variabe appropriately.  Also, make _free check its argument.

	* vegas.c, gsl_monte_vegas.h: minor cleanup prior to be change.

	* vegas.c: minor changes, commiting by accident.

Mon Jul 27 22:52:49 1998  bjg  <bjg@vvv.lanl.gov>

	* Makefile.in, Makefile.am:
	fixed some of the include requirements for make dist

Mon Jul 27 15:19:54 1998  booth  <booth@planck.pha.jhu.edu>

	* vegas_print.h, vegas_test.c, miser_test.c, vegas-print.c, vegas.c, Attic/gsl_vegas.h, Attic/gsl_vegas_print.h, gsl_monte_vegas.h, miser.c, Attic/gsl_miser.h, Makefile.am, Makefile.in, gsl_monte_miser.h:
	Renamed public header files to follow convention correctly.

	* vegas.c, vegas_test.c, miser.c, miser_test.c, plain.c, plain_test.c, Attic/gsl_miser.h, Attic/gsl_vegas.h, gsl_monte_plain.h:
	All the integration functions now end with _integrate (except for
	vegas1, vegas2 and vegas3 which are going away RSN).

Tue Jul 21 21:54:33 1998  booth  <booth@planck.pha.jhu.edu>

	* vegas.c, vegas-print.c, Attic/gsl_vegas_print.h, Attic/gsl_vegas.h:
	trivial stuff: eliminate compiler warnings, eliminate some unneeded variables,
	change some types to make consistent with plain and miser.

	* gsl_monte_plain.h, plain.c, plain_test.c:
	Make "plain" conform to same style as miser and vegas.

Fri Jul 17 02:23:40 1998  jungman  <jungman@nnn.lanl.gov>

	* Makefile.in: we're gonna make it...

Thu Jul 16 16:23:45 1998  booth  <booth@planck.pha.jhu.edu>

	* vegas-print.c, vegas.c, Attic/gsl_vegas_print.h:
	Have now completely eliminated all static variables.

	* vegas_test.c, vegas.c, Attic/gsl_vegas.h, Attic/gsl_vegas_print.h, vegas-print.c:
	Continuing to remove all static variables from vegas.

Wed Jul 15 19:10:24 1998  booth  <booth@planck.pha.jhu.edu>

	* vegas.c, vegas_test.c, Attic/gsl_vegas.h:
	Do the state-structure thing for vegas.  Not finished, so far the only
	real content is the rng structure.

