------------------------------------------------------------------------------
CHANGES-0.8

1. Ported MA to numarray.  Added some additional functions to
numarray.numeric.

2. Merged example and addon setups into top-level setup so there is now
a single unified numarray package which includes everything.

3. Re-worked selftests so that all tests are now in doctest format
driven off a single function, numarray.testall.test().

4. Redefined searchsorted (in an numarray-backward-incompatible way) for
better Numeric compatibility.

5. Modified the put()/take() interfaces for multiple index operations.

The axis parameter is now used as a discriminator between
Numeric-compatible (NC) and multiple-index (MI) modes.  When the axis
is specified as a single integer value, NC mode is implied.  Since the
default value for axis is 0, NC mode is the default.  When the axis is
specified as a tuple of integer values, MI mode is implied.

MI mode returns a structurally different result from NC mode.  NC mode
replaces the axis of the take with a subset, effectively truncating it
to the length of the single index array.  So:

take(array_with_shape=(a,b,c,d), index_of_len_n, axis=1)

returns:

array_with_shape=(a,n,c,d)

The shape of the MI mode result is determined by the shape of the
index arrays concatenated with the shape of the source array with the
indexed axes removed. So:

take(array_with_shape=(a,b,c,d), (index_of_len_n, index_of_len_n), 
	axis=(1,2,0,3))

returns:

array_with_shape(n,a,d)

Note that in particular, the MI mode call:

take(array_with_shape=(a,b,c,d), (index_of_len_n,), axis=(1,0,2,3))

returns:

array_with_shape(n,a,c,d)

which is different than the NC mode result for axis=1.

Multiple indices are now all specified in a single index parameter,
which is conceptually a tuple of index arrays.

6. Modified default put()/take() index clipmode

The put()/take() index clipmode now has now been changed to RAISE.  In
addition to raising an exception for "really bad" indices,  RAISE mode 
supports normal Python sequence behavior for indices in the interval
-N+1 to N-1 where len(sequence) is N.  Since array based indexing uses
the default clip mode, the clip mode for array based indexing is now 
RAISE as well.

------------------------------------------------------------------------------
CHANGES-0.7:   

1. Added support for object arrays.

2. Deprecated use of PyArray_INCREF/XDECREF as part of the numarray native
C-API.  Use ordinary Py_INCREF/XDECREF instead.  PyArray_INCREF/XDECREF has
a different incompatible meaning for Numeric which numarray will eventually
adopt as much as possible.

------------------------------------------------------------------------------
CHANGES-0.6.1:   

0. Fixed a problem with building under Mac-OS.

------------------------------------------------------------------------------
CHANGES-0.6:   

0. Reorganized numarray as a Python package.  See Doc/Repackaging.

1. Fixed NA_typeObjectToTypeNo() by adding deferred_libnumarray_init()
to it.  Thanks to Peter Verveer for spotting this.

2. Added pushMode(...) and popMode() to IEEE-754 Error object:
numarray.Error.  Error.pushMode(...) has the same parameter list as
Error.setMode(...), but saves the old mode on a stack before changing
it.  Error.popMode() restores an old mode from the top of the stack.
Like 95% of numarray, this idea comes from Perry Greenfield.

3. Redefined Bool as signed char rather than just char.  Thanks to
Peter Verveer for noticing this.

4. Added/fixed nested timing cycle counting in the teacup timing module.
Thanks to Francesc Alted for our discussions about timing numarray stuff.

5. Modified around() to relax the "needs Python-2.2.2 requirement" for
the (default) case where digits=0.  Thanks to Phil Hodge for this suggestion.

6. Factored NA_NewAllFromBuffer out of NA_NewAll to support creation
of arrays in C from buffer objects as in Python rather than just C
arrays.  Thanks to Sebastian Haase for this suggestion.

6. Fixed arange(5,3,2) (negative size memory region) bug and added an
exception for negative size regions to the memory.new_memory().  Now
arange(5,3,2) --> array([]).  Thanks to Paul Dubois for this.

7. Modified NewArray() parameter order to exactly match NumArray and
ComplexArray order.  keywords remain the same.

8. Fixed bug in multi-dimensional chararray copy with irregular (recarray
generated) strides.  Thanks to JC Hsu for this.

9. Added a median filter function: numarray.image.combine.median().
(import numarray.image.combine)

10. Improved threading support with modifications to ufunc caching and
ieee error handling configuration which are designed to make them both
thread safe.  Numarray remains largely thread unaware.

11. Fixed a bug in memory.new_memory() parameter passing for 64-bit
systems.

12. Fixed several (presumably small) reference counting errors/memory
leaks.

------------------------------------------------------------------------------
CHANGES-0.5:   

1. Fixed coercions of "exotic" type combinations: (Int8, UInt16) -->
Int32, (Int16, UInt32) --> Int64, (Float64, Complex32) --> Complex64.
Thanks to Peter Verveer.  Also fixed (Int64, Float32) --> Float64 and
(UInt64, Float32) --> Float64 thanks to Edward Jones.

2. Added QR decomposition contributed by Uwe Schmitt to LinearAlgebra2.

3. Fixed NDArray.copy() for 0-size arrays by short circuiting the C-code
in python.

4. Added NA_typeObjectToTypeNo to C-API.

5. Ported MLab.py from Numeric-22.0 as a module of LinearAlgebra2.

6. Modified Convolve.convolve2d to support IRAF boundary modes.  The
existing "pass-thru" boundary mode was dropped.  Added Image.py to the
Convolve package, with the function translate() which shifts 2d arrays
by floating point pixel shifts using bilinear interpolation.

7. Fixed a bug in PyArray_CopyFromObject by which the "copy" could
retain a "_shadows" reference to the original array.  In the case
where the original object was a mis-behaved array, the bug would cause
a nasty side effect during the deallocation of the copy: the "copy"
would copy itself back onto the original array object.  This bug
affected the FFT2 package.

8. Fixed a bug in Convolve.boxcar near array boundary.  The approaches
to boxcar area division used by the incremental and boundary code were
incompatible.

9. Hacked setup.py to support 2 step build/install process.
Generation of code is now driven by specifying "--gencode" or
"--check-dates".  The latter is useful for re-building libnumarray w/o
constantly recompiling all of the ufunc modules.  The former
regenerates all generated c-code, regardless of the file dates.  A
critical "one-time" hack is: if Include/numarray/numconfig.h does not
exist, gencode=1.  This forces code generation when it has never been
done.

10. Deprecated the "round()" function since it collides with the
builtin function.  Added an output parameter to the full featured
array rounding function "around()".  

11. Refined type equality testing to return False when a type is
compared against a non-type.  Also added IsType(rep), a function
returning True iff rep is a NumericType or a string alias for one.
Suggested by Edward Jones.

12. Simplified the string converter for NumericTypes to only return
the type's name,  omitting the "numarray type:" prefix.

13. Modified memmap to support true readonly files after we discovered
that copy-on-write mappings require system swap space.  Also added the
capability to "flush" a Memmap onto a new file, and the ability to
insert new slices into readonly and copy-on-write maps.  It is still
an error to add slices and flush onto the original file (assuming it
was readonly or copy-on-write).

14. Modified policy for reduction operators:
a. areduce( rank-1 ) --> rank-1-len-1  rather than rank-0
  e.g.  add.areduce( range(10 ) --> array([45]) not array(45)
b. reduce(rank-1) --> scalar                       (no change)
c. rank-0 arrays are still supported internally.

15. Added function array_equal() which accepts any two Python objects
and either returns True or False.  array_equal() is only True if the
array shapes and all elements are equal.  Added function array_equiv()
which is like array_equal(), but considers array shapes which are 
consistent (mutually broadcastable) to be equivalent.  array_equiv()
returns True iff both arrays have equal elements and equivalent shapes.

16. Added a ".real" property to all numarrays (i.e. non-complex arrays).
.real can be fetched for any numeric array, and can be set for any floating
point array.

17. Fixed several bugs in chararray regarding readonly arrays.
Comparison and concatenation used to try to mutate readonly chararrays
in order to apply the chararray stripping and padding rules.
RawCharArray._setitem was incompatible with memmap'ed buffers.  Fixed
this by teaching memory.writeable_buffer() to call __buffer__() on an
object which fails PyBuffer_FromReadWriteObject.

18.  Added NA_copyArray(to, from) which is a thin wrapper around
Python to._copyFrom(from).

19. Eliminated complex comparison ufuncs (>,>=,<,<=).  Modified ComplexArray
to raise an exception for invalid complex comparisons.

20. Renamed the PYTHON_ARRAY_UNIQUE_SYMBOL API variable override to
the Numeric name:  PY_ARRAY_UNIQUE_SYMBOL.  Added a warning for uses of the
old name.

21. Applied a patch (by Francesc Alted) to add support for Numeric typecodes
to the C-API in NA_NewAll.

22. Changed definition of byteswap() method to exclude call to
togglebyteorder() so that byteswap() would again be compatible with
Numeric.  This breaks code.  byteswap is now equivalent to _byteswap(),
and togglebyteorder() must be called explicitly.

23. Added macro PyArray_isArray(o) and example convolve/testlite.c to
demonstrate the possibility of supporting numarray as an option within
a python extension.  PyArray_isArray always returns 0 when numarray is 
not present.  When numarray is present, PyArray_isArray(o) returns the
result of NA_NumArrayCheck(o).

23. Added C-API functions NA_NewAllStrides, NA_vNewArray, NA_NewArray,
and NA_copy based on comments by Edward C. Jones.  NA_NewArray
replaces NA_New.  NA_vNewArray(NULL, ...) replaces NA_Empty.

24. Added is_fortran_contiguous() method to _ndarray.  Added is_f_array()
method to NumArray.

25. Added ufunc setup caching to reduce numarray's constant time overhead.
This is a massive change, re-implementing several classes from ufunc.py in
C and adding modules _operatormodule.c, _convertermodule.c, and 
_ufuncmodule.c.  _ufunc.py was renamed to _ufuncall.py.  A key new function:
flush_caches() is used to clear out the setup caches;  it is also executed
whenever numarray is reloaded.

26. Added a strawman timing module called "teacup".  This is for
instrumenting numarray C-functions to determine where time is being
spent.  Currently this is Linux only and not really useable yet even
there.

------------------------------------------------------------------------------
CHANGES-0.4:   (C-basetypes,   requires Python-2.2 or later)

0. Implemented C-basetypes for NDArray and NumArray.  This is a big
change, with far reaching consequences for numarray.

First the bad news:

   a. Numarray now requires at least Python-2.2.

   b. Most of the "native" C-API calls have changed in backwards
   incompatible ways.  They do retain the same "spirit" and naming,
   but if you used them, you'll have to change your code a little.  

   c. Old pickles will not easily un-pickle as a result of the change
   in numarray's base class.

Now the good news:

   a. Numarray is now much faster for simple indexing, attribute 
      access, and list conversion operations.  

   b. Numarray is now more Numeric compatible because the underlying
      object better matches the struct layout of the Numeric object.

   c. Numarray's Numeric compatability is now simpler.  Compatability
      objects are now "real" numarray's and can be used as such.  The
      numpy_compat module and type are no longer needed.

   d. The "native" C-API is now simpler, since the NDInfo struct is no
      longer needed at all.  Calls which formerly had to pass both an
      object and an NDInfo struct now pass only an object.  The spirit
      of the API remains very much the same.

1. Fixed a performance bug in numerictypes.NumericType.__cmp__ which
had to do with re-computing and iterating through the typeDict keys.
Also redefined type comparison to include type rank, so Int32 < Int64
is True.

2. Added a boxcar function to the Convolve package with modes based on
the IRAF boxcar function.  See Convolve.boxcar.__doc__.

3. Moved ArrayType from RandomArray2.py to numarray.py.  (Backwards
compatability with Numeric).

4. Generalized ufunc._fbroadcast to enable it to broadcast functions
requiring parameters.  Also re-organized _fbroadcast interface,
possibly breaking code which made the mistake of calling a private
function.

5. Added IEEE-754 special value handling by creating ufunc ieeemask
and by adding module ieeespecial which defines constants and helper
functions.  This means that it is now possible to scan arrays for
different varieties of NANs and INFs.

6. Fixed a bug involving concatenation of discontiguous arrays using
array().

7. Fixed a bug in ufunc buffer alignment checking which short
circuited the alignment test for any itemsize >= sizeof(int) rather
than sizeof(Float64).

8. Fixed a bug in "reduce" alias functions (sum, product, alltrue,
sometrue) by making them strict aliases of the ufuncs.  Fixed a bug
specifying last axis of array as axis of reduction in reduce and
areduce.

9. Implemented rank-0 policy:
    a. rank0[()] --> scalar
    b. rank0[0]  raises IndexError exception
    c. len(rank0) --> None
    d. <ufunc>.reduce(rank1)  --> scalar
    e. <ufunc>.areduce(rank1) --> rank0

10. Modified NumArray.byteswap() to update the _byteorder attribute in
addition to byteswapping the array elements.  i.e.  Byteswapping a
"little" endian NumArray makes it "big" endian.  Renamed
_togglebyteorder() to togglebyteorder() to make it public so you can
undo this effect if you need to.

11. Modified the signature of numarray.array() to make it a strict
superset of Numeric.array(), whatever that means.  For a Numeric user,
it should mean that numarray.array() will now work wherever
Numeric.array() did, no matter how it is called.  For a numarray user,
it means that specification of the "extra" parameter shape can only be
done using a keyword.  Review your calls to numarray.array() if you
have any doubts.

12. Renamed the public but hopefully unknown method "NDArray.array" to
"NDArray.factory" since it was causing trouble for Boost Python.
"a.factory()" is generally more capable than "a.__class__()" in the
same way that numarray.array() is more capable than
numarray.NumArray().

13. Added the UInt32 type and broadened support for Int64 and UInt64
to include Solaris and i386-Linux.  Win32 is close, but MSVC can't
completely handle UInt64 so it's not here yet.  Even where Int64 is
available, it may not be the default integer size, which remains Int32
on 32-bit platforms.

14. Fixed a bug in ndarray.NDArray.tofile() which caused it to fail
for extremely large items (> 1M).

------------------------------------------------------------------------------
CHANGES-0.3.6: 

1. Modified the array2string function to summarize output for large
arrays.  Currently, this affects both str and repr for arrays > 1000
elements.  The new repr function also lines up columns correctly.
Since this change modifies the whitespace and linebreaking of array
reprs, it requires updates to doctests.

2. Added 2 functions to arrayprint.py which support summarized output:
	set_summary(threshhold=1000, edge_items=3) and summary_off().
Array repr summaries consist of edge_items leading and edge_items
trailing elements, with all intermediate values replaced by a single
"...".  sumarray_off() sets threshold to a large value, effectively
disabling summaries altogether.

3. Modified the C implementation of sort and argsort to better handle
pathological cases.  Added random qsort pivot and code to exclude
adjacent values equal to pivot from recursion.  These changes enable
numarray to execute a slightly modified version of python's
sortperf.py.  Prior to these changes, sortperf's pathological cases
could cause sort to recurse excessively and exhaust the stack, dumping
core.

4. Fixed bug in NDArray.tofile() for large multidimensional arrays
which resulted in an error with no exception set.  Also fixed error
handling related bugs in bytes.copyToString().

------------------------------------------------------------------------------
CHANGES-0.3.5: 

1. Fixed bug in numarray.NumArray._copyFrom which broke array copies within an 
array. Basically, an array copying part of itself onto another part of itself
produced incorrect results.

2. Cleaned up setup.py to avoid generating code unless actually
installing.  Now you can ask setup.py for help ("python setup.py
--help") without feeling like its running wild.

3. Modified LinearAlgebra2.MLab to avoid use of properties,
potentially making it work with Python versions < 2.2.  Since there's
still no regression test for MLab, this is iffy, but "mean", at least,
appeared to work.  E-mail jmiller@stsci.edu if you find numarray MLab
problems.

------------------------------------------------------------------------------
CHANGES-0.3.4: 

1. Removed duplicate implementation of "choose" in codegenerator by
enabling the choose template to generate an "N" byte size.  Enabled the use
of the generated code "choose16bytes" by modifying the ufunc setup.

2. Changed numarray.array's parameter order to match Numeric's parameter
order for better compatability.  Added typecode, copy, savespace parameters,
with savespace being totally ignored.  Fixed the concatenation behavior of
numarray.array to add an exta dimension prior to concatenation, as in Numeric.

3. Improved numarray's handling of rank-0 arrays by making it possible to
create an array from a scalar: "array(1)" returns rank-0 array: array(1).
Modified the repr of a rank-0 array containing 1 from "1" to "array(1)" where
the absence of [] indicates rank-0;  the new format is safer and can be
eval'ed to construct a new rank-0 array.

4. Added asarray as an alias for array(..., copy=0).  asarray is deprecated.

5. Incorporated "hand-coded" versions of _fillarrayXX, mxmultiplyXX, and 
nonzeroCoordsBool into codegenerator as type specific code.  These are 
generated to _sortmodule.c which is now a misnomer.

6. Added a __setitem__ method to memmap.MemmapSlice so that CharArray's based
on a slice of a memmap can do slice assigments to the MemmapSlice.

7. Added a Packages directory tree with a number of packages, most ported from
Numeric using the numpy_compat Numeric-C-API-compatability module:

FFT2                 - port of Numeric's FFT
RandomArray2         - port of Numeric's RandomArray
LinearAlgebra2       - port of LinearAlgebra2
Convolve             new Numeric-compatible convolution and correlation.
                     Convolve supports 2D arrays but not complex numbers.
                                                       
These pass their Numeric self-tests.  I regard them as pre-alpha.

8. Added a new class of CFuncs (CFUNC_NSTRIDING) which are implemented
in terms of a C-function which is called for each element of an array
(or set of arrays).  Used these to fix the bugs in chararray striding
for multi-dimensional arrays.

9. Re-implemented numarray.around.  Added support for digits parameter.
Added numarray.round ufunc w/o digits paramter.

10. Moved NDArray.__del__ to NumArray.__del__ to minimize it's impact on
garbage collection, making it a non-issue for chararray and recarray.  This
needs more work;  I just discovered that merely having a "__del__" makes
problems for the garbage collector.

11. _byteswap has been changed to a similar attribute: _byteorder.
Where _byteswap was a relative value indicating that an array needs to
be swapped before its data can be used on the current processor,
_byteorder is an absolute value indicating the endian-ness of the data
in an array.  _byteswap can be computed from _byteorder and
sys.byteorder at runtime using isbyteswapped().  This change was made
at all levels of the system, including the C-API.  The byteswap
parameter to NumArray and NA_NewAll has been changed to byteorder,
breaking calls to those two functions which used non-default values
for byteswap.  The byteorder parameter is passed into NumArray as
"big" or "little", which are the Python names for big endian and
little endian respectively.  In C, byteorder is represented as an
enumeration with values NUM_BIG_ENDIAN and NUM_LITTLE_ENDIAN.  Because
_byteorder is absolute and a string it helps make an array picklable.

12. Streamlined NDArray._copyFrom's API and stopped calling it directly from 
_concat.

13. Simplified the reduce and accumulate code.  Added areduce which returns
rank-0 arrays rather than scalars.

14. Fixed a bug in memmap.Memmap which broke __init__ for POSIX
systems for python versions < 2.2.  Fixed an inconsistency in the return
value of MemmapSlice.__getitem__, sometimes a string, sometimes a bufer,
now always a string.

15. Added support for pickling to numarray.  During this modification,
I also cleaned up the data buffering, eliminating widespread use of
memory.memory_buffer (returns writable buffer referring to a new
memory object) in favor of memory.new_memory (just returns the memory
object).  MemmapSlices are converted to MemoryType before pickling and
therefore unpickled as MemoryType.

16. Fixed bugs in allclose, alltrue for the non-default dimension.

17. Added basic support for the python 2.3 boolean type by adding calls
to int() to the doctests to ensure that they still work with 2.3.

18. Added support for type Int64 on Tru64 and re-worked ufunc code to
eliminate explict absolute type Int32 used as index arrays in favor of
new relative type Long.  Modified array creation and repr defaults to
use relative types Long, Float, Complex.  Currently, Long, Float, and
Complex are aliases for platform specific absolute types.

------------------------------------------------------------------------------
CHANGES-0.3.3: 

1. Re-implemented ComplexArray functions in c using the codegenerator.
Added Complex64, Complex128 to the type system.  Added most operators
and functions available on Float64 including comparison operators 
(compares real parts first, then complex if real parts are equal), sort
functions.  Byteswapping *has* been implemented for the complex types
to byteswap the real and imaginary parts of each complex number independently.

2. Added more complex functions (remainder, arcsin, arccos, arctan,
arcsinh, arccosh, arctanh, ceil, floor, logical_and, logical_or, logical_xor,
logical_not, minimum, maximum).

3. Renamed Complex128 --> Complex64,  Complex64 --> Complex32.  This was an
accidental incompatability between Numeric and numarray which is now gone.

4. Modified the code generation process to not import the
codegenerator module but rather to run it directly in-place as a
script using os.system.  This should make code generation more
reliable by eliminating the need to install the codegenerator at all.
Thus, the new codegenerator is always *explicitly* run w/o any
intervening module paths which often made the old version to run by
mistake.

5. Modifed NA_NewAll to initialize the buffer of a newly allocated array
to zero when the buffer contents are unspecified.

6. Added acosh, asinh, and atanh to all types based on Numeric's definitions
of these functions.

------------------------------------------------------------------------------
CHANGES-0.3.2:

1. Fixed a fatal bug with take/put buffer checking on Tru64.  The buffer 
checking code assumed sizeof(long) == sizeof(Int32), rendering take/put
inoperable.

2. This release follows 0.31 by hours.  If you're not using Tru64 or a
64-bit processor, you're OK with 0.31.  0.31 is AKA 0.3.1.  Since
0.3.2 is essentially 0.3.1 + 1 bugfix, there is no manual update
for version 0.3.2.

------------------------------------------------------------------------------
CHANGES-0.31:

1. Imported "e" from math into numarray.py.

2. Added a "manual" directory to the Doc tree where Jochen Kupper's TeX
conversion of the Numarray manual now lives.

3. Excluded the generated c files from MANIFEST.in.  This seems to
work correctly with Python-2.3a0 on Linux, but not with python-2.2.1c2
on Windows.  For this reason, I added MANIFEST to CVS, even though in
theory distutils can regenerate MANIFEST from MANIFEST.in.

4. Improved the NA_ConvertInput function to handle lists as inputs in 
addition to arrays.  This function is now deprecated. see below.

5. Added array element access macros to the C-API.  

6. Fixed bug in ufunc return values.  Specifying an output array now
suppresses the return value (None is returned) for all unary and binary
ufuncs.

7. Added NA_ShapeEqual, NA_ShapeLessThan API functions.  Deprecated
NA_ShapeMisMatch to macro status.

8. Fixed bug in put/take buffer limit checking.   

9. Replaced ndarray.trace and diagonal with python code from Numeric-21.0.
This change restricts trace and diagonal to numarrays.

10. Totally re-vamped the C-API.  The real functions are now:

NA_InputArray    converts an array for input,  defined contents on input, 
		 may lose side-effects
NA_OutputArray   converts an array for output, undefined contents on input, 
	   	 won't loose side effects.
NA_IoArray       defined contents on input and won't loose side effects.
		 slowest with temporaries and large arrays.
NA_ReturnOutput  returns a new output array or None (when caller specified).

Mis-behaved output and i/o arrays are shadowed by temporaries which have
a new "_shadows" attribute referring to the original array.  When the temp
is deallocated, it is copied back onto the original array.

The revised functions are very flexible in terms of the policy they
enforce for creating temporaries (shadows).  They can be asked to
create temps for misalignment, byteswapping, discontiguity, or type
mismatch, in combinations.  I used this in the numpy_compat to create
temps *only* for byteswapping and mis-alignment.  With 4 parameters
each, they won't win any beauty contest...

The old API functions are now mostly (depcrecated) wrapper macros in
numdeprecated.h.  I haven't fixed the examples yet, so the macros work!

11. Added a minimal Numeric C-API compatability layer.  This layer features
a syntactically equivalent PyArrayObject c-type and a few of the Numeric 
Array C-API functions which I need now.  To see which functions are *tested*,
look in Doc/numpy_compat for my example & test case.  The PyArrayObject is
fairly useable now, but it's PyArray_Descr field is incomplete.  The overall
goal of the emulation layer is to support simple Numeric extensions at the
cost of writing a new setup.py and re-compiling with numarray.

12. Added a 1D in-place API.  NA_get_offset, NA_get1D_Float64,
NA_set1D_Float64.  These functions get/set consequtive elements of any
array.  Harder to use than element-wise API, but faster.

13. Implemented Bool array indexing.  Arrays indexed by boolean arrays
effectively do a "compress" when getting and an "inverse compress" when
setting.

14. Added putmask.

15. Modified numarray.array to do concatenation when called with a 
sequence of arrays.

16. Added argmin, argmax and fixed bugs with multi-D argsort.  argmin, argmax,
and argsort results are *not* identical to Numeric due to different sort
algorithms;  equal elements are not treated the same way.

17.  Copied allclose from Numeric.

18.  Fixed a bug in multi-D repeat.

19. Renamed ufunc keyword "index" to "axis".

20. Fixed a bug with Complex itemsize().

21. Fixed bug in _bytesmodule::copyToString which was mishandling zero-length
arrays;  they now return the empty string without any buffer checking.

22. Added checks to copyToString and callStrideConvCFunc which verify that
shape and strides are sequences of python Ints or Longs.

------------------------------------------------------------------------------
CHANGES-0.3:

1. Fixed multiple bugs in sort and argsort:
a. sort *function* returned None.  sort *method* worked for 1D arrays.
b. multi-dimensional sort broken and untested.  Fixed and added example from
the numarray manual to numtest.
c. axis keyword default values were inconsistent between sort/argsort 
*function* and numarray method.

2. Fixed a bug in testdata.py used by chararray.py.  testdata.py
encoded the file 'tb.fits' as a python string to make it easy locate
for use in selftesting chararray.  'tb.fits' was mercilessly unpacked
with each testdata.py import.  Since chararray.py imported testdata.py
regardless of whether it was running the selftest, chararray.py
effectively required permission to re-write the file 'tb.fits'.

3. Worked with distutils stuff to enable automatic building of source
distributions.  Updated version, author, author_email, description,
and url in setup.py.  Author == Perry.  Added MANIFEST.in to enable automatic
generation of MANIFEST for building sdists.  Also added top-level README.txt
since sdist wants to see one.

4. Added alignment and size checking for non-striding c functions.  Extended
the callUFunc signature to include a return status;  non-zero return status
signals function exception for which the error string should already be set.
Cleaned up the code generator and included <>-sugared templates.  Moved most
of the structural functions from _ndarraymodule.c to the codegenerator and
added a new "_bytesmodule" to hold the output.   Cleaned up some of the ufuncs
which required multiple scalar parameters by modifying _pseudoArrayFromScalar
into _pseudoArrayFromScalars.

5. Added generic checking functions to the C-API:
	NA_checkIo          verifies input/output parameter counts.
	NA_checkOneContig   verifies size, alignment of 1 contiguous buffer.
	NA_checkNContigs    verifies size, alignment of N contiguous buffers.
	NA_checkOneStriding verifies buffer size, aligment, shape, stride
	                       compatibility for one buffer.
	NA_getBufferAndSize gets a read or write buffer pointer and its size
	NA_add_cfunc        Creates a cfunc object from a CFUNC_DESCRIPTOR and
                            adds it to the module dictionary.

6. Added a minimal "memory object" which is used to created buffers
with guaranteed double aligned storage across all python versions.
This works around a limitation present in the python-2.2 and earlier
buffer object.  The call _ndarray.Buffer has become
memory.memory_buffer which creates a buffer object which references a
memory object.  There is also memory.new_memory which creates a memory
object alone.  The memory object meets the buffer C-API but provides
only the len method of the sequence protocol.  Operations which would
like to "slice" a memory object as an array of bytes need to create a
ReadWrite buffer object referring to the memory_object (or any
bufferable object) using memory.writeable_buffer.  The remaining functions
of _ndarraymodule were inherited by memorymodule;  _ndarraymodule is gone.
Unlike _ndarraymodule, memorymodule knows nothing whatsoever about numarray
arrays.  See Src/memorymodule.c

7. Added the Cfunc c-type to eliminate the possiblity of mismatches
between C-objs and the generic python-c-wrapper used to call it.
Cfuncs bind a simple c function to a descriptor describing its
required parameters and wrapper type.  Unlike Cobjs, Cfuncs are
directly callable in python and automatically dispatch through the
correct wrapper (callCUfunc, callStrideConvCFunc, NumTypeFromPyValue,
NumTypeAsPyValue).  See Src/cfunc.ch.  

8. Partitioned the ufuncmodule by type of first ufunc parameter.  This
is a work around for the huge size of the ufuncmodule and its ability
to choke GCC like a python swallowing an elephant.  Partitioning was
accompished by adding a default parameter "Type" to the bodygenerator
functions and __call__ methods of codegenerators.  When "Type"
defaults to None, the old behavior is retained, which is essentially
multi-type.  When Type is specified to a codegenerator, it means to
generate only the Type specific module where the first parameter of
each ufunc is of type Type.

9. Modified the intentional floating point divide by zero exception
generation code by adding the public global "numarray_zero".  This is
intended to prevent the compiler from optimizing away intentional FP
divide by zeros.  Removed the status catching from NA_add_cfunc calls
since it wasn't being acted on, isn't likely to fail, and was
generating a warning for only one of 9 numarray types; NA_add_cfunc
still returns status though.  These changes were motivated by
gcc-2.95.2 on sparc-sun-solaris2.8 which can actually compile and run
numarray (with optimization turned on) now that the ufuncmodule has
been partitioned.

10. Modified transpose, swapaxes, reshape functions to return views rather
than copies.

11. Modified ndarray.NDArray._stridesFromShape to handle the shape () 
specially with strides of (0,).  Also changed _simpleIndexing to handle
this case so that rank 0 arrays can be printed.  Modified ufunc.innerproduct
to handle the case innerproduct([1,2,3],[4,5,6]) --> 32 which follows mostly
from supporting rank 0 arrays.

12. Added c-accelerated Eval method to chararray for converting to NumArray
from CharArray.  Accessible as method fasteval().   Experimental.

13. Added c-accelerated Format method to chararray for converting NumArrays to
CharArrays.  Accessible as function num2char.  Experimental.

14. Added code to generate the string "version = '0.3'" to setup.py.  The
string is added to numinclude.py at setup time.

15. Moved the file "doctest.py" from the numarray root directory to the Doc
directory to avoid its accidental use by pythons which already have a doctest.py.
Doctest.py was upgraded with python2.2 to handle new style classes;  running the
old doctest.py resulted in missing test cases but an overall pass.

-------------------------------------------------------------------------------
CHANGES-0.2:

1. Added support for python-2.2 properties, specifically:

.shape, getshape(), setshape()
.flat, getflat()
.real, getreal(), setreal()
.imag, getimag(), setimag()
.imaginary, getimaginary(), setimaginary()   # aliases for imag

numarray-0.2 is not 100% compatible with numarray-0.11.  To port 
numarray-0.11 code to numarray-0.2:

a. Instances of array.reshape(x) must be changed to array.setshape(x) 
or array.shape = x.  Users with python versions prior to 2.2 must use
array.setshape(x).

b. Instances of array.real() must be replaced with array.real or 
array.getreal().  Users with python versions prior to 2.2 must use
array.getreal().

c. Instances of array.imag() must be replaced with array.imag or
array.getimag().  Users with python versions prior to 2.2 must use
array.getimag().

2. Fixed bugs in some of the numarray functions related to:

a. Making copies of the input arrays when required to do so.

b. Supporting nested sequences of python numbers in lieu of arrays.

affected functions: reshape, transpose, resize, diagonal, trace,
sort, argsort, ravel, ...

3. Fixed a bug in Complex arrays related to handling of type
Complex64.  This bug manifested as incorrect results for many
operations with Complex64 arrays.  "ones" in particular, returned
obviously incorrect results for type=Complex64.

4. Fixed a bug in type conversion in "where" with
    y = where (equal (x, 0.), 1., x) 
on single precision array 'x' resulting in a double precision 'y'.
This fix also affects "choose".

5. Added getrank() method and associated property "rank" for python2.2
and on.

6. Fixed a bug in nonzero where the "input screening" code was 
truncating small floating point values to 0.

7. Fixed a bug in all unary/binary ufuncs where output buffer offset
was hard-coded to 0 for "fast" mode.  This caused the following failure:

>>> a=arange(10)
>>> a[5:8] += 3
>>> a
array([3, 4, 5, ... ])

8. Fixed bug / added support for array([], type=ZZZ).

9. Added pi to the numarray namespace by importing it from math.

10. Added arrayrange alias for arange.

11. Improved numarray (in)equality testing by adding handling for None
and re-implementing __nonzero__ as the bitwise-or of the element-wise
comparison of the array with 0.

12. Fixed bug in iscontiguous() which assumed that _bytestride ==
_itemsize for contiguous arrays.  This is not true when slicing occurs,
but perhaps should be.

13. Added typecodes which are compatible with NumPy typecodes:
	"d":Float64,"f":Float32,"l":Int32,"D":Complex128,"F":Complex64,
	"b":UInt8, "c":Int8
  Modified NumericType.__cmp__ to support comparisons against aliases.
  Modified NumericType.__repr__ to return the type name.

14. Modified the doctest for recarray so that it works correctly on win32.

