Skip to main content
`Ctrl`+`K`

# Reference/API

## Capabilities

### astropy.modeling Package

This subpackage provides a framework for representing models and performing model evaluation and fitting. It supports 1D and 2D models and fitting with parameter constraints. It has some predefined models and fitting routines.

#### Functions

`bind_bounding_box`(modelinstance, bounding_box) | Set a validated bounding box to a model instance.
`bind_compound_bounding_box`(modelinstance, ...) | Add a validated compound bounding box to a model instance.
`custom_model`(*args[, fit_deriv]) | Create a model from a user defined function.
`fix_inputs`(modelinstance, values[, ...]) | This function creates a compound model with one or more of the input values of the input model assigned fixed values (scalar or array).
`is_separable`(transform) | A separability test for the outputs of a transform.
`separability_matrix`(transform) | Compute the correlation between outputs and inputs.

#### Classes

`CompoundModel`(op, left, right[, name]) | Base class for compound models.
`Fittable1DModel`(*args[, meta, name]) | Base class for one-dimensional fittable models.
`Fittable2DModel`(*args[, meta, name]) | Base class for two-dimensional fittable models.
`FittableModel`(*args[, meta, name]) | Base class for models that can be fitted using the built-in fitting algorithms.
`InputParameterError` | Used for incorrect input parameter values and definitions.
`Model`(*args[, meta, name]) | Base class for all models.
`ModelDefinitionError` | Used for incorrect models definitions.
`Parameter`([name, description, default, ...]) | Wraps individual parameters.
`ParameterError` | Generic exception class for all exceptions pertaining to Parameters.

#### Class Inheritance Diagram

### astropy.modeling.bounding_box Module

This module is to contain an improved bounding box.

#### Classes

`CompoundBoundingBox`(bounding_boxes, model, ...) | A model's compound bounding box.
`ModelBoundingBox`(intervals, model[, ...]) | A model's bounding box.

#### Class Inheritance Diagram

### astropy.modeling.mappings Module

Special models useful for complex compound models where control is needed over which outputs from a source model are mapped to which inputs of a target model.

#### Classes

`Identity`(n_inputs[, name, meta]) | Returns inputs unchanged.
`Mapping`(mapping[, n_inputs, name, meta]) | Allows inputs to be reordered, duplicated or dropped.
`UnitsMapping`(mapping[, ...]) | Mapper that operates on the units of the input, first converting to canonical units, then assigning new units without further conversion.

#### Class Inheritance Diagram

### astropy.modeling.fitting Module

This module implements classes (called Fitters) which combine optimization algorithms (typically from `scipy.optimize`) with statistic functions to perform fitting. Fitters are implemented as callable classes. In addition to the data to fit, the `__call__` method takes an instance of `FittableModel` as input, and returns a copy of the model with its parameters determined by the optimizer.

Optimization algorithms, called “optimizers” are implemented in `optimizers` and statistic functions are in `statistic`. The goal is to provide an easy to extend framework and allow users to easily create new fitters by combining statistics with optimizers.

There are two exceptions to the above scheme. `LinearLSQFitter` uses Numpy’s `lstsq` function. `LevMarLSQFitter` uses `leastsq` which combines optimization and statistic in one implementation.

#### Functions

`parallel_fit_dask`(*, model, fitter, data[, ...]) | Fit a model in parallel to an N-dimensional dataset.

#### Classes

`DogBoxLSQFitter`([calc_uncertainties, ...]) | DogBox algorithm and least squares statistic.
`FitInfoArrayContainer`(fit_info_array) | This class is intended to contain the object array of all fit_info values and provide a convenience method to access specific items from fit_info as arrays.
`Fitter`(optimizer, statistic) | Base class for all fitters.
`FittingWithOutlierRemoval`(fitter, outlier_func) | This class combines an outlier removal technique with a fitting procedure.
`JointFitter`(models, jointparameters, initvals) | Fit models which share a parameter.
`LMLSQFitter`([calc_uncertainties]) | `scipy.optimize.least_squares` Levenberg-Marquardt algorithm and least squares statistic.
`LevMarLSQFitter`([calc_uncertainties]) | Levenberg-Marquardt algorithm and least squares statistic.
`LinearLSQFitter`([calc_uncertainties]) | A class performing a linear least square fitting.
`ModelLinearityError` | Raised when a non-linear model is passed to a linear fitter.
`ModelsError` | Base class for model exceptions.
`SLSQPLSQFitter`() | Sequential Least Squares Programming (SLSQP) optimization algorithm and least squares statistic.
`SimplexLSQFitter`() | Simplex algorithm and least squares statistic.
`TRFLSQFitter`([calc_uncertainties, ...]) | Trust Region Reflective algorithm and least squares statistic.

#### Class Inheritance Diagram

### astropy.modeling.optimizers Module

Optimization algorithms used in `fitting`.

#### Classes

`SLSQP`() | Sequential Least Squares Programming optimization algorithm.
`Optimization`(opt_method) | Base class for optimizers.
`Simplex`() | Neald-Mead (downhill simplex) algorithm.

#### Class Inheritance Diagram

### astropy.modeling.statistic Module

Statistic functions used in `fitting`.

#### Functions

`leastsquare`(measured_vals, updated_model, ...) | Least square statistic, with optional weights, in N-dimensions.
`leastsquare_1d`(measured_vals, updated_model, ...) | Least square statistic with optional weights.
`leastsquare_2d`(measured_vals, updated_model, ...) | Least square statistic with optional weights.
`leastsquare_3d`(measured_vals, updated_model, ...) | Least square statistic with optional weights.

### astropy.modeling.separable Module

Functions to determine if a model is separable, i.e. if the model outputs are independent.

It analyzes `n_inputs`, `n_outputs` and the operators in a compound model by stepping through the transforms and creating a `coord_matrix` of shape (`n_outputs`, `n_inputs`).

Each modeling operator is represented by a function which takes two simple models (or two `coord_matrix` arrays) and returns an array of shape (`n_outputs`, `n_inputs`).

#### Functions

`is_separable`(transform) | A separability test for the outputs of a transform.
`separability_matrix`(transform) | Compute the correlation between outputs and inputs.

## Pre-Defined Models

### astropy.modeling.functional_models Module

Mathematical models.

#### Classes

`AiryDisk2D`([amplitude, x_0, y_0, radius]) | Two dimensional Airy disk model.
`ArcCosine1D`(*args[, meta, name]) | One dimensional ArcCosine returning values between 0 and pi only.
`ArcSine1D`(*args[, meta, name]) | One dimensional ArcSine model returning values between -pi/2 and pi/2 only.
`ArcTangent1D`(*args[, meta, name]) | One dimensional ArcTangent model returning values between -pi/2 and pi/2 only.
`Box1D`([amplitude, x_0, width]) | One dimensional Box model.
`Box2D`([amplitude, x_0, y_0, x_width, y_width]) | Two dimensional Box model.
`Const1D`([amplitude]) | One dimensional Constant model.
`Const2D`([amplitude]) | Two dimensional Constant model.
`Cosine1D`(*args[, meta, name]) | One dimensional Cosine model.
`Disk2D`([amplitude, x_0, y_0, R_0]) | Two dimensional radial symmetric Disk model.
`Ellipse2D`([amplitude, x_0, y_0, a, b, theta]) | A 2D Ellipse model.
`Exponential1D`([amplitude, tau]) | One dimensional exponential model.
`Gaussian1D`([amplitude, mean, stddev]) | One dimensional Gaussian model.
`Gaussian2D`([amplitude, x_mean, y_mean, ...]) | Two dimensional Gaussian model.
`GeneralSersic2D`([amplitude, r_eff, n, x_0, ...]) | Generalized two dimensional Sersic surface brightness profile that allows for "boxy" or "disky" (kite-like) isophote shapes.
`KingProjectedAnalytic1D`([amplitude, r_core, ...]) | Projected (surface density) analytic King Model.
`Linear1D`([slope, intercept]) | One dimensional Line model.
`Logarithmic1D`([amplitude, tau]) | One dimensional logarithmic model.
`Lorentz1D`([amplitude, x_0, fwhm]) | One dimensional Lorentzian model.
`Lorentz2D`([amplitude, x_0, y_0, fwhm]) | Two-dimensional Lorentzian model.
`Moffat1D`([amplitude, x_0, gamma, alpha]) | One dimensional Moffat model.
`Moffat2D`([amplitude, x_0, y_0, gamma, alpha]) | Two dimensional Moffat model.
`Multiply`([factor]) | Multiply a model by a quantity or number.
`Planar2D`([slope_x, slope_y, intercept]) | Two dimensional Plane model.
`RedshiftScaleFactor`([z]) | One dimensional redshift scale factor model.
`RickerWavelet1D`([amplitude, x_0, sigma]) | One dimensional Ricker Wavelet model (sometimes known as a "Mexican Hat" model).
`RickerWavelet2D`([amplitude, x_0, y_0, sigma]) | Two dimensional Ricker Wavelet model (sometimes known as a "Mexican Hat" model).
`Ring2D`([amplitude, x_0, y_0, r_in, width, r_out]) | Two dimensional radial symmetric Ring model.
`Scale`([factor]) | Multiply a model by a dimensionless factor.
`Sersic1D`([amplitude, r_eff, n]) | One dimensional Sersic surface brightness profile.
`Sersic2D`([amplitude, r_eff, n, x_0, y_0, ...]) | Two dimensional Sersic surface brightness profile.
`Shift`([offset]) | Shift a coordinate.
`Sine1D`(*args[, meta, name]) | One dimensional Sine model.
`Tangent1D`(*args[, meta, name]) | One dimensional Tangent model.
`Trapezoid1D`([amplitude, x_0, width, slope]) | One dimensional Trapezoid model.
`TrapezoidDisk2D`([amplitude, x_0, y_0, R_0, ...]) | Two dimensional circular Trapezoid model.
`Voigt1D`([x_0, amplitude_L, fwhm_L, fwhm_G, ...]) | One dimensional model for the Voigt profile.

#### Class Inheritance Diagram

### astropy.modeling.physical_models Module

Models that have physical origins.

#### Classes

`NFW`([mass, concentration, redshift, ...]) | Navarro–Frenk–White (NFW) profile - model for radial distribution of dark matter.
`BlackBody`(*args, **kwargs) | Blackbody model using the Planck function.
`Drude1D`([amplitude, x_0, fwhm]) | Drude model based one the behavior of electons in materials (esp.
`Plummer1D`([mass, r_plum]) | One dimensional Plummer density profile model.

#### Class Inheritance Diagram

### astropy.modeling.powerlaws Module

Power law model variants.

#### Classes

`BrokenPowerLaw1D`([amplitude, x_break, ...]) | One dimensional power law model with a break.
`ExponentialCutoffPowerLaw1D`([amplitude, ...]) | One dimensional power law model with an exponential cutoff.
`LogParabola1D`([amplitude, x_0, alpha, beta]) | One dimensional log parabola model (sometimes called curved power law).
`PowerLaw1D`([amplitude, x_0, alpha]) | One dimensional power law model.
`Schechter1D`([phi_star, m_star, alpha]) | Schechter luminosity function (Schechter 1976), parameterized in terms of magnitudes.
`SmoothlyBrokenPowerLaw1D`([amplitude, ...]) | One dimensional smoothly broken power law model.

#### Class Inheritance Diagram

### astropy.modeling.polynomial Module

This module contains models representing polynomials and polynomial series.

#### Classes

`SIP`(crpix, a_order, b_order[, a_coeff, ...]) | Simple Imaging Polynomial (SIP) model.
`Chebyshev1D`(degree[, domain, window, ...]) | Univariate Chebyshev series.
`Chebyshev2D`(x_degree, y_degree[, x_domain, ...]) | Bivariate Chebyshev series..
`Hermite1D`(degree[, domain, window, ...]) | Univariate Hermite series.
`Hermite2D`(x_degree, y_degree[, x_domain, ...]) | Bivariate Hermite series.
`InverseSIP`(ap_order, bp_order[, ap_coeff, ...]) | Inverse Simple Imaging Polynomial.
`Legendre1D`(degree[, domain, window, ...]) | Univariate Legendre series.
`Legendre2D`(x_degree, y_degree[, x_domain, ...]) | Bivariate Legendre series.
`OrthoPolynomialBase`(x_degree, y_degree[, ...]) | This is a base class for the 2D Chebyshev and Legendre models.
`Polynomial1D`(degree[, domain, window, ...]) | 1D Polynomial model.
`Polynomial2D`(degree[, x_domain, y_domain, ...]) | 2D Polynomial model.
`PolynomialModel`(degree[, n_models, ...]) | Base class for polynomial models.

#### Class Inheritance Diagram

### astropy.modeling.projections Module

Implements projections–particularly sky projections defined in WCS Paper II [1].

All angles are set and and displayed in degrees but internally computations are performed in radians. All functions expect inputs and outputs degrees.

#### References

[1]

Calabretta, M.R., Greisen, E.W., 2002, A&A, 395, 1077 (Paper II)

#### Classes

`AffineTransformation2D`([matrix, translation]) | Perform an affine transformation in 2 dimensions.
`Conic`(*args, **kwargs) | Base class for conic projections.
`Cylindrical`(*args, **kwargs) | Base class for Cylindrical projections.
`HEALPix`(*args, **kwargs) | Base class for HEALPix projections.
`Pix2SkyProjection`(*args, **kwargs) | Base class for all Pix2Sky projections.
`Projection`(*args, **kwargs) | Base class for all sky projections.
`PseudoConic`(*args, **kwargs) | Base class for pseudoconic projections.
`PseudoCylindrical`(*args, **kwargs) | Base class for pseudocylindrical projections.
`QuadCube`(*args, **kwargs) | Base class for quad cube projections.
`Sky2PixProjection`(*args, **kwargs) | Base class for all Sky2Pix projections.
`Zenithal`(*args, **kwargs) | Base class for all Zenithal projections.
`Pix2Sky_ZenithalPerspective`(*args, **kwargs) | Zenithal perspective projection - pixel to sky.
`Pix2Sky_AZP` | alias of `Pix2Sky_ZenithalPerspective`
`Pix2Sky_SlantZenithalPerspective`(*args, **kwargs) | Slant zenithal perspective projection - pixel to sky.
`Pix2Sky_SZP` | alias of `Pix2Sky_SlantZenithalPerspective`
`Pix2Sky_Gnomonic`(*args, **kwargs) | Gnomonic projection - pixel to sky.
`Pix2Sky_TAN` | alias of `Pix2Sky_Gnomonic`
`Pix2Sky_Stereographic`(*args, **kwargs) | Stereographic Projection - pixel to sky.
`Pix2Sky_STG` | alias of `Pix2Sky_Stereographic`
`Pix2Sky_SlantOrthographic`(*args, **kwargs) | Slant orthographic projection - pixel to sky.
`Pix2Sky_SIN` | alias of `Pix2Sky_SlantOrthographic`
`Pix2Sky_ZenithalEquidistant`(*args, **kwargs) | Zenithal equidistant projection - pixel to sky.
`Pix2Sky_ARC` | alias of `Pix2Sky_ZenithalEquidistant`
`Pix2Sky_ZenithalEqualArea`(*args, **kwargs) | Zenithal equidistant projection - pixel to sky.
`Pix2Sky_ZEA` | alias of `Pix2Sky_ZenithalEqualArea`
`Pix2Sky_Airy`(*args, **kwargs) | Airy projection - pixel to sky.
`Pix2Sky_AIR` | alias of `Pix2Sky_Airy`
`Pix2Sky_CylindricalPerspective`(*args, **kwargs) | Cylindrical perspective - pixel to sky.
`Pix2Sky_CYP` | alias of `Pix2Sky_CylindricalPerspective`
`Pix2Sky_CylindricalEqualArea`(*args, **kwargs) | Cylindrical equal area projection - pixel to sky.
`Pix2Sky_CEA` | alias of `Pix2Sky_CylindricalEqualArea`
`Pix2Sky_PlateCarree`(*args, **kwargs) | Plate carrée projection - pixel to sky.
`Pix2Sky_CAR` | alias of `Pix2Sky_PlateCarree`
`Pix2Sky_Mercator`(*args, **kwargs) | Mercator - pixel to sky.
`Pix2Sky_MER` | alias of `Pix2Sky_Mercator`
`Pix2Sky_SansonFlamsteed`(*args, **kwargs) | Sanson-Flamsteed projection - pixel to sky.
`Pix2Sky_SFL` | alias of `Pix2Sky_SansonFlamsteed`
`Pix2Sky_Parabolic`(*args, **kwargs) | Parabolic projection - pixel to sky.
`Pix2Sky_PAR` | alias of `Pix2Sky_Parabolic`
`Pix2Sky_Molleweide`(*args, **kwargs) | Molleweide's projection - pixel to sky.
`Pix2Sky_MOL` | alias of `Pix2Sky_Molleweide`
`Pix2Sky_HammerAitoff`(*args, **kwargs) | Hammer-Aitoff projection - pixel to sky.
`Pix2Sky_AIT` | alias of `Pix2Sky_HammerAitoff`
`Pix2Sky_ConicPerspective`(*args, **kwargs) | Colles' conic perspective projection - pixel to sky.
`Pix2Sky_COP` | alias of `Pix2Sky_ConicPerspective`
`Pix2Sky_ConicEqualArea`(*args, **kwargs) | Alber's conic equal area projection - pixel to sky.
`Pix2Sky_COE` | alias of `Pix2Sky_ConicEqualArea`
`Pix2Sky_ConicEquidistant`(*args, **kwargs) | Conic equidistant projection - pixel to sky.
`Pix2Sky_COD` | alias of `Pix2Sky_ConicEquidistant`
`Pix2Sky_ConicOrthomorphic`(*args, **kwargs) | Conic orthomorphic projection - pixel to sky.
`Pix2Sky_COO` | alias of `Pix2Sky_ConicOrthomorphic`
`Pix2Sky_BonneEqualArea`(*args, **kwargs) | Bonne's equal area pseudoconic projection - pixel to sky.
`Pix2Sky_BON` | alias of `Pix2Sky_BonneEqualArea`
`Pix2Sky_Polyconic`(*args, **kwargs) | Polyconic projection - pixel to sky.
`Pix2Sky_PCO` | alias of `Pix2Sky_Polyconic`
`Pix2Sky_TangentialSphericalCube`(*args, **kwargs) | Tangential spherical cube projection - pixel to sky.
`Pix2Sky_TSC` | alias of `Pix2Sky_TangentialSphericalCube`
`Pix2Sky_COBEQuadSphericalCube`(*args, **kwargs) | COBE quadrilateralized spherical cube projection - pixel to sky.
`Pix2Sky_CSC` | alias of `Pix2Sky_COBEQuadSphericalCube`
`Pix2Sky_QuadSphericalCube`(*args, **kwargs) | Quadrilateralized spherical cube projection - pixel to sky.
`Pix2Sky_QSC` | alias of `Pix2Sky_QuadSphericalCube`
`Pix2Sky_HEALPix`(*args, **kwargs) | HEALPix - pixel to sky.
`Pix2Sky_HPX` | alias of `Pix2Sky_HEALPix`
`Pix2Sky_HEALPixPolar`(*args, **kwargs) | HEALPix polar, aka "butterfly" projection - pixel to sky.
`Pix2Sky_XPH` | alias of `Pix2Sky_HEALPixPolar`
`Sky2Pix_ZenithalPerspective`(*args, **kwargs) | Zenithal perspective projection - sky to pixel.
`Sky2Pix_AZP` | alias of `Sky2Pix_ZenithalPerspective`
`Sky2Pix_SlantZenithalPerspective`(*args, **kwargs) | Zenithal perspective projection - sky to pixel.
`Sky2Pix_SZP` | alias of `Sky2Pix_SlantZenithalPerspective`
`Sky2Pix_Gnomonic`(*args, **kwargs) | Gnomonic Projection - sky to pixel.
`Sky2Pix_TAN` | alias of `Sky2Pix_Gnomonic`
`Sky2Pix_Stereographic`(*args, **kwargs) | Stereographic Projection - sky to pixel.
`Sky2Pix_STG` | alias of `Sky2Pix_Stereographic`
`Sky2Pix_SlantOrthographic`(*args, **kwargs) | Slant orthographic projection - sky to pixel.
`Sky2Pix_SIN` | alias of `Sky2Pix_SlantOrthographic`
`Sky2Pix_ZenithalEquidistant`(*args, **kwargs) | Zenithal equidistant projection - sky to pixel.
`Sky2Pix_ARC` | alias of `Sky2Pix_ZenithalEquidistant`
`Sky2Pix_ZenithalEqualArea`(*args, **kwargs) | Zenithal equidistant projection - sky to pixel.
`Sky2Pix_ZEA` | alias of `Sky2Pix_ZenithalEqualArea`
`Sky2Pix_Airy`(*args, **kwargs) | Airy - sky to pixel.
`Sky2Pix_AIR` | alias of `Sky2Pix_Airy`
`Sky2Pix_CylindricalPerspective`(*args, **kwargs) | Cylindrical Perspective - sky to pixel.
`Sky2Pix_CYP` | alias of `Sky2Pix_CylindricalPerspective`
`Sky2Pix_CylindricalEqualArea`(*args, **kwargs) | Cylindrical equal area projection - sky to pixel.
`Sky2Pix_CEA` | alias of `Sky2Pix_CylindricalEqualArea`
`Sky2Pix_PlateCarree`(*args, **kwargs) | Plate carrée projection - sky to pixel.
`Sky2Pix_CAR` | alias of `Sky2Pix_PlateCarree`
`Sky2Pix_Mercator`(*args, **kwargs) | Mercator - sky to pixel.
`Sky2Pix_MER` | alias of `Sky2Pix_Mercator`
`Sky2Pix_SansonFlamsteed`(*args, **kwargs) | Sanson-Flamsteed projection - sky to pixel.
`Sky2Pix_SFL` | alias of `Sky2Pix_SansonFlamsteed`
`Sky2Pix_Parabolic`(*args, **kwargs) | Parabolic projection - sky to pixel.
`Sky2Pix_PAR` | alias of `Sky2Pix_Parabolic`
`Sky2Pix_Molleweide`(*args, **kwargs) | Molleweide's projection - sky to pixel.
`Sky2Pix_MOL` | alias of `Sky2Pix_Molleweide`
`Sky2Pix_HammerAitoff`(*args, **kwargs) | Hammer-Aitoff projection - sky to pixel.
`Sky2Pix_AIT` | alias of `Sky2Pix_HammerAitoff`
`Sky2Pix_ConicPerspective`(*args, **kwargs) | Colles' conic perspective projection - sky to pixel.
`Sky2Pix_COP` | alias of `Sky2Pix_ConicPerspective`
`Sky2Pix_ConicEqualArea`(*args, **kwargs) | Alber's conic equal area projection - sky to pixel.
`Sky2Pix_COE` | alias of `Sky2Pix_ConicEqualArea`
`Sky2Pix_ConicEquidistant`(*args, **kwargs) | Conic equidistant projection - sky to pixel.
`Sky2Pix_COD` | alias of `Sky2Pix_ConicEquidistant`
`Sky2Pix_ConicOrthomorphic`(*args, **kwargs) | Conic orthomorphic projection - sky to pixel.
`Sky2Pix_COO` | alias of `Sky2Pix_ConicOrthomorphic`
`Sky2Pix_BonneEqualArea`(*args, **kwargs) | Bonne's equal area pseudoconic projection - sky to pixel.
`Sky2Pix_BON` | alias of `Sky2Pix_BonneEqualArea`
`Sky2Pix_Polyconic`(*args, **kwargs) | Polyconic projection - sky to pixel.
`Sky2Pix_PCO` | alias of `Sky2Pix_Polyconic`
`Sky2Pix_TangentialSphericalCube`(*args, **kwargs) | Tangential spherical cube projection - sky to pixel.
`Sky2Pix_TSC` | alias of `Sky2Pix_TangentialSphericalCube`
`Sky2Pix_COBEQuadSphericalCube`(*args, **kwargs) | COBE quadrilateralized spherical cube projection - sky to pixel.
`Sky2Pix_CSC` | alias of `Sky2Pix_COBEQuadSphericalCube`
`Sky2Pix_QuadSphericalCube`(*args, **kwargs) | Quadrilateralized spherical cube projection - sky to pixel.
`Sky2Pix_QSC` | alias of `Sky2Pix_QuadSphericalCube`
`Sky2Pix_HEALPix`(*args, **kwargs) | HEALPix projection - sky to pixel.
`Sky2Pix_HPX` | alias of `Sky2Pix_HEALPix`
`Sky2Pix_HEALPixPolar`(*args, **kwargs) | HEALPix polar, aka "butterfly" projection - pixel to sky.
`Sky2Pix_XPH` | alias of `Sky2Pix_HEALPixPolar`

#### Class Inheritance Diagram

### astropy.modeling.rotations Module

Implements rotations, including spherical rotations as defined in WCS Paper II [1].

`RotateNative2Celestial` and `RotateCelestial2Native` follow the convention in WCS Paper II to rotate to/from a native sphere and the celestial sphere.

The implementation uses `EulerAngleRotation`. The model parameters are three angles: the longitude (`lon`) and latitude (`lat`) of the fiducial point in the celestial system (`CRVAL` keywords in FITS), and the longitude of the celestial pole in the native system (`lon_pole`). The Euler angles are `lon+90`, `90-lat` and `-(lon_pole-90)`.

#### References

[1]

Calabretta, M.R., Greisen, E.W., 2002, A&A, 395, 1077 (Paper II)

#### Classes

`EulerAngleRotation`(phi, theta, psi, ...) | Implements Euler angle intrinsic rotations.
`RotateCelestial2Native`(lon, lat, lon_pole, ...) | Transform from Celestial to Native Spherical Coordinates.
`RotateNative2Celestial`(lon, lat, lon_pole, ...) | Transform from Native to Celestial Spherical Coordinates.
`Rotation2D`([angle]) | Perform a 2D rotation given an angle.
`RotationSequence3D`(angles, axes_order[, name]) | Perform a series of rotations about different axis in 3D space.
`SphericalRotationSequence`(angles, axes_order) | Perform a sequence of rotations about arbitrary number of axes in spherical coordinates.

#### Class Inheritance Diagram

### astropy.modeling.spline Module

Spline models and fitters.

#### Classes

`Spline1D`([knots, coeffs, degree, bounds, ...]) | One dimensional Spline Model.
`SplineExactKnotsFitter`() | Fit a spline using least-squares regression.
`SplineInterpolateFitter`() | Fit an interpolating spline.
`SplineSmoothingFitter`() | Fit a smoothing spline.
`SplineSplrepFitter`() | Fit a spline using the `scipy.interpolate.splrep` function interface.

#### Class Inheritance Diagram

### astropy.modeling.tabular Module

Tabular models.

Tabular models of any dimension can be created using `tabular_model`. For convenience `Tabular1D` and `Tabular2D` are provided.

#### Examples

    >>> table = np.array([[ 3.,  0.,  0.],
    ...                  [ 0.,  2.,  0.],
    ...                  [ 0.,  0.,  0.]])
    >>> points = ([1, 2, 3], [1, 2, 3])
    >>> t2 = Tabular2D(points, lookup_table=table, bounds_error=False,
    ...                fill_value=None, method='nearest')

#### Functions

`tabular_model`(dim[, name]) | Make a `Tabular` model where `n_inputs` is based on the dimension of the lookup_table.

#### Classes

`Tabular1D`([points, lookup_table, method, ...]) | Tabular model in 1D.
`Tabular2D`([points, lookup_table, method, ...]) | Tabular model in 2D.

#### Class Inheritance Diagram