These demonstations are C extensions which perform 1D or 2D
convolution of arrays of Float64.  Technically speaking, the
functions do correlation and not convolution.  Convolution is achieved
by reversing the order of the kernel which is expressed easily in
python as kernel[::-1] (for 1D) or kernel[::-1,::-1] (for 2D).  

To set it up, go up to the Examples/ directory and follow the install
instructions.

If that works and you have doctest.py, you can test it using:
,----
| python convtest.py
`----
Some benchmarks can be run with
,----
| python benchmark.py
`----


There are different C modules, implemented using the various
abstraction layers:

- The high-level extension demonstrates the use of "wrapper helper
  functions" which make it easier to write Python wrappers for
  Numarray C functions.  The helpers create temporaries when needed to
  handle the "extras" supplied by Numarray: byteswapping, alignment,
  discontiguous arrays, type conversion.  For perfectly matched
  arrays, the helpers do very little; Where arrays are not directly
  useable by C (due to type mismatch, byteswapping, etc.), a temporary
  is created which is useable.

  Since part of the point of Numarray is to avoid the creation of
  temporaries, these helpers represent a compromise which trades some
  efficiency for the ability to easily bolt on new extension functions
  which can use Numarrays as inputs.

- The element-wise (in-place) API enables access to byteswapped or
  misaligned arrays on an element by element basis without making an
  accessible copy of the entire array at once.  This trades execution
  time for space efficiency.  This API is also fairly intrusive, since
  it requires replacement of array subscripts by NA_get and NA_set
  calls.

  The "in-place" API operates on arrays by getting and setting
  elements based on the array's info, type and 1, 2, or 3 indices.

- The Numarray one-dimensional (in-place) API.  In theory, this API
  can give better performance for functions which need to handle
  byteswapped and misaligned arrays but cannot afford to make
  temporaries.  This API gives better performance compared to the
  other "in-place" functions by factoring type, byteswap, and
  misalignment tests out of the inner loop.  This API is the
  most difficult to use, but has the potential for the best
  performance.

- The Numeric-compatibility layer.  This interface is provided for
  ease of porting existing Numeric projects to numarray.  It should
  probabaly not used for new projects, as it will always remain an
  emulation layer.  Be aware that it is not a 100% compatible
  emulation of Numeric (but it is close).
