Release notes for v1.05.0

[Preliminary release.  The current standard version (linked to from the
fits.jar and fits_src.jar entries in this directory, currently points to
v1.04.0. 2010-12-21.]

Many changes are included.

The following were suggested (and example code provided) by Laurent Bourges

   1. Adding methods to allow finer control of the placement of
      metadata records for columns of FITS tables.  This could previously 
      be done using Cursors, but the TableHDU.setTableMeta() methods now
      allow these to be specified more directly.

      This involves changes only to TableHDU.  Usage is illustrated in the test
      method BinaryTableTest.columnMetaTest.

   2. Adding more rigor to the transformation between bytes and strings and
      fixing a bug in the handling of strings with embedded nuls.  According
      to the standard an embedded null should terminate an string in a 
      binary table.
      
      The standard also precludes other non-printing characters from strings.
      This has been ignored previously, but there is now a method
      FitsFactory.setCheckAsciiString(boolean flag) which can be called
      to turn on checking.  A warning will be issued and non-printing
      characters will be converted to spaces if this flag is set.  Only a single
      warning will be issued regardless of the number of invalid characters are
      seen.
      
      There are changes in a number of classes where the conversions occur
      to ensure that the ASCII charset is used.

      How these changes work is illustrated in BinaryTableTest.specialStringsTest.

   3. Handling fixed and variable length, single and double precision
      complex data.  The library uses a float[2] or double[2]
      for a complex scalar.

      This is mostly bug fixes to existing code and changes are only
      in BinaryTable and BinaryTableHDU. 

      The method BinaryTableHDU.setComplexColumn() allows the user to
      tell the FITS writer that a field which otherwise would be treated
      as a float or double array (with most rapidly varying
      dimensionality of 2) should be treated as complex.  The internal
      data representations are identical.
 
      Variable length complex data will be found automatically if
      number of elements actually varies.  A variable length complex 
      column is a 3-D float or double array
      where the last dimension (for Java) is always 2, the first
      dimension is the number of rows in the table and the middle
      dimension is the number of complex numbers in the row and may
      vary from row to row.  Other variable length columns are
      represented as 2-D arrays, where the first index points to the
      row, and the second index enumerates the elements in the row.

      Use of complex columns is illustrated in BinaryTableTest in the routines
      testSimpleComplex (fixed columns), testVar (variable length
      columns), and buildByColumn and buildByRow where columns
      and rows containing complex numbers are added to existing
      tables.
      
   4. Changing the null HDU created when a table is to be written without
      a prior image to use a vector with dimensionality 0 rather than 
      a one-dimensional vector with a dimension of 0.  I.e, use
      NAXIS=0 rather than NAXIS=1, NAXIS1=0.
      
Other changes include:

   1. Consolidating the writing of padding at the end of FITS elements into
      the FitsUtil.pad methods.
   2. Adding the reset() method to the FitsElement interface.  This attempts
      to reset the Fits input stream pointer to the beginning of the element.
      It does not throw exceptions but will return false if not successful.
      This is intended to make it easier for user who wish to use low-level
      I/O to read FITS data, by allowing them to position the stream to the
      beginning of the data they are interested in.
   3. Changed FitsUtil.HDUFactory(Object x) to accept a Header object as well
      as the various kinds of data inputs.
   4. Provided a method in BinaryTable to get back the ModelRow array.
      This makes is easier for users to do low level I/O in binary tables.
      An ArrayDataInput object will read a row of the table, given the
      result of getModelRow().
   5. Added a getColumns() method to TableHDU.  This returns an Object[] array
      where each entry is the result of getColumn(n)