Generate the docstrings in _wcs.so using character arrays rather than
string literals.  This is (reportedly) more portable and avoid the
copying nonsense we did before.
Change how jquery.js and jquery.dataTables.js dependencies are handled.
Includes the original source, rather than minified source.  Provides
a configuration option to select where file is loaded from.
Changing FITS table write function to have default value of Nan for float type cols
Changing default value for float columns from 1e20 to Nan in fits table write function
Changing the float comparison for filled value to np.allclose to enable Nan masking for float32 as well. Also added test cases for float64, and float32
Removing unnecessary comment
Use superclass read/write functions if possible
Add minimal tests of read/write with a subclass
Fixing io docs links for #1221
Change initialization of NDData arithmetic result to include keywords in constructor
Initialize result with keywords in constructor call
Add note to docstring indicating that flags are set to None

This is not a change in behavior in convert_unit_to, just indicating in the doctoring what is being done.
Add CHANGES.rst entry

Closes #2300
Use `\overset{\circ}A` for Angstrom LaTeX.
Minor docs modifications
FITS_rec objects can be pickled with this patch
Small modifications to FITS_rec pickling, and tests added
Changing tests and adding changelog entry
As pointed out by @nden here
<https://github.com/astropy/astropy/pull/2149/files#r10402422> that
different classes of models had different mechanisms for storing their
parameter values, creating a fair amount of unncessary complexity.

This change attempts to smooth out some of the differences by merging
the old ParametricModel class into the base Model class, so that all
models more or less operate on the same basis.  An added advantage to
this is that it adds full support for parameter constraints on *all*
models, which can be useful even outside the context of fitting.

This standardizes on the way ParametricModel stored parameters, where
all the parameter values are stored in a single flat array along with a
simple _param_metrics data structure providing information how to
extract individual parameter values from that array.  As @nden points
out this may not be the *best* way.  In fact, it might be difficult to
really make this work with parameters as Quantities.  But this was the
path of least resistance for the first iteration.

For now I've kept around a class named ParametricModel and its
subclasses ParametricModel1D and ParametricModel2D and the subclasses
thereof--the only thing that really distinguishes them at the moment is
the fact that they have the `fittable=True` flag.

This does *not* fully resolve the issue addressed in #2149, but it will
make the implementation for #2149 simpler.  This also adds a few
inefficiences, particularly in any models that have angular parameter
values that need to be converted to radians for compuations.  I have a
separate branch running parallel to this one that will attempt to
address that issue.
Somewhat clarified how constraints are stored on a model, and how their
initial values are set:

* Constraints are treated in two separate categories: 'parameter
  constraints' which are constraints on specific parameters, and
  'model constraints' which are general constraints on the model
  (specifically the 'eqcons' and 'ineqcons' constraints).
* All constraints are stored in the ._constraints dict.
* Setting of initial values of constraints is simplified so that only
  Model._initialize_constraints is responsible for this (though it still
  queries the individual parameters for any default constraints they may
  have).