/*
*class++
*  Name:
*     Mapping

*  Purpose:
*     Inter-relate two coordinate systems.

*  Constructor Function:
*     None.

*  Description:
*     This class provides the basic facilities for transforming a set
*     of coordinates (representing "input" points) to give a new set
*     of coordinates (representing "output" points).  It is used to
*     describe the relationship which exists between two different
*     coordinate systems and to implement operations which make use of
*     this (such as transforming coordinates and resampling grids of
*     data).  However, the Mapping class does not have a constructor
*     function of its own, as it is simply a container class for a
*     family of specialised Mappings which implement particular types
*     of coordinate transformation.

*  Inheritance:
*     The Mapping class inherits from the Object class.

*  Attributes:
*     In addition to those attributes common to all Objects, every
*     Mapping also has the following attributes:
*
*     - Invert: Mapping inversion flag
*     - IsLinear: Is the Mapping linear?
*     - IsSimple: Has the Mapping been simplified?
*     - Nin: Number of input coordinates for a Mapping
*     - Nout: Number of output coordinates for a Mapping
*     - Report: Report transformed coordinates?
*     - TranForward: Forward transformation defined?
*     - TranInverse: Inverse transformation defined?

*  Functions:
c     In addition to those functions applicable to all Objects, the
c     following functions may also be applied to all Mappings:
f     In addition to those routines applicable to all Objects, the
f     following routines may also be applied to all Mappings:
*
c     - astDecompose: Decompose a Mapping into two component Mappings
c     - astTranGrid: Transform a grid of positions
c     - astInvert: Invert a Mapping
c     - astLinearApprox: Calculate a linear approximation to a Mapping
c     - astMapBox: Find a bounding box for a Mapping
c     - astMapSplit: Split a Mapping up into parallel component Mappings
c     - astQuadApprox: Calculate a quadratic approximation to a 2D Mapping
c     - astRate: Calculate the rate of change of a Mapping output
c     - astRebin<X>: Rebin a region of a data grid
c     - astRebinSeq<X>: Rebin a region of a sequence of data grids
c     - astResample<X>: Resample a region of a data grid
c     - astRemoveRegions: Remove any Regions from a Mapping
c     - astSimplify: Simplify a Mapping
c     - astTran1: Transform 1-dimensional coordinates
c     - astTran2: Transform 2-dimensional coordinates
c     - astTranN: Transform N-dimensional coordinates
c     - astTranP: Transform N-dimensional coordinates held in separate arrays
f     - AST_DECOMPOSE: Decompose a Mapping into two component Mappings
f     - AST_TRANGRID: Transform a grid of positions
f     - AST_INVERT: Invert a Mapping
f     - AST_LINEARAPPROX: Calculate a linear approximation to a Mapping
f     - AST_QUADAPPROX: Calculate a quadratic approximation to a 2D Mapping
f     - AST_MAPBOX: Find a bounding box for a Mapping
f     - AST_MAPSPLIT: Split a Mapping up into parallel component Mappings
f     - AST_RATE: Calculate the rate of change of a Mapping output
f     - AST_REBIN<X>: Rebin a region of a data grid
f     - AST_REBINSEQ<X>: Rebin a region of a sequence of data grids
f     - AST_REMOVEREGIONS: Remove any Regions from a Mapping
f     - AST_RESAMPLE<X>: Resample a region of a data grid
f     - AST_SIMPLIFY: Simplify a Mapping
f     - AST_TRAN1: Transform 1-dimensional coordinates
f     - AST_TRAN2: Transform 2-dimensional coordinates
f     - AST_TRANN: Transform N-dimensional coordinates

*  Copyright:
*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
*     Research Councils

*  Licence:
*     This program is free software: you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation, either
*     version 3 of the License, or (at your option) any later
*     version.
*
*     This program is distributed in the hope that it will be useful,
*     but WITHOUT ANY WARRANTY; without even the implied warranty of
*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*     GNU Lesser General Public License for more details.
*
*     You should have received a copy of the GNU Lesser General
*     License along with this program.  If not, see
*     <http://www.gnu.org/licenses/>.

*  Authors:
*     RFWS: R.F. Warren-Smith (Starlink)
*     MBT: Mark Taylor (Starlink)
*     DSB: David S. Berry (Starlink)

*  History:
*     1-FEB-1996 (RFWS):
*        Original version.
*     29-FEB-1996 (RFWS):
*        Minor improvements to error messages.
*     15-JUL-1996 (RFWS):
*        Support external interface.
*     13-DEC-1996 (RFWS):
*        Added the astMapMerge method.
*     13-DEC-1996 (RFWS):
*        Added the astSimplify method.
*     27-MAY-1997 (RFWS):
*        Improved the astSimplify method to use astMapMerge to
*        simplify a single Mapping where possible.
*     29-MAY-1998 (RFWS):
*        Added the MapBox method.
*     13-NOV-1998 (RFWS):
*        Made default MapBox convergence accuracy larger (i.e. less
*        accurate).
*     10-DEC-1998 (RFWS):
*        First useful implementation of astResample<X>.
*     16-AUG-1999 (RFWS):
*        Fixed bug in SpecialBounds - wrong number of coordinates being used
*        when checking for bad output coordinate values.
*     17-AUG-1999 (RFWS):
*        Improved the convergence security of MapBox (return to older but
*        less efficient setting).
*     24-NOV-2000 (MBT):
*        Fixed bug (function being invoked as wrong type) in AST__UINTERP
*        scheme, and added new AST__BLOCKAVE scheme, in astResample<X>.
*     9-JAN-2001 (DSB):
*        Changed in and out arguments for TranN from type "double (*)[]"
*        to "double *".
*     8-JAN-2003 (DSB):
*        Changed private InitVtab method to protected astInitMappingVtab
*        method.
*     10-JUL-2003 (DSB):
*        Added method astRate.
*     2-SEP-2004 (DSB):
*        Free resources before leaving astRate.
*     31-AUG-2004 (DSB):
*        Make the LinearApprox function protected rather than private,
*        rename it to astLinearApprox, and make the bounds parameters of
*        type double rather than int. Also, correct the size of the fit
*        coefficient array (was "(nin+1)*nout", now is "(nout+1)*nin").
*        Also correct the index of the first gradient coefficient from
*        "fit+nout" to "fit+nin". These errors have probably never been
*        noticed because they make no difference if nin=nout, which is
*        usually the case.
*     6-SEP-2004 (DSB):
*        Make astRate more robust by adding checks for unusal conditions.
*     20-SEP-2004 (DSB):
*        Make the LinearApprox function public and change its interface
*        to be more appropriate for public use. This involved swapping the
*        direction of the fit (the original astLinearApprox fitted the
*        inverse transformation, but the public version now fits the forwrd
*        transformation).
*     4-OCT-2004 (DSB):
*        Modify astMapList to return flag indicating presence of inverted
*        CmpMaps in supplied Mapping.
*     9-NOV-2004 (DSB):
*        Override astEqual method.
*     6-DEC-2004 (DSB):
*        Remove the second derivative estimate from the astRate function
*        since CmpMap has trouble calculating it.
*     17-DEC-2004 (DSB):
*        Added astMapSplit
*     22-APR-2005 (DSB):
*        Modified SpecialBounds to handle cases where some irrelevant
*        output always produces bad values (e.g. a PermMap may do this).
*     30-JUN-2005 (DSB):
*        Added astRebin.
*     7-JUL-2005 (DSB):
*        Make MapSplit public rather than protected.
*     11-AUG-2005 (DSB):
*        Added the AST__CONSERVEFLUX flag (used by astResampleX).
*     17-AUG-2005 (DSB):
*        Added the AST__SOMBCOS kernel.
*     31-AUG-2005 (DSB):
*        Added astRebinSeq.
*     9-SEP-2005 (DSB):
*        Corrected axis indices returned by public interface for astMapSplit.
*     31-JAN-2006 (DSB):
*        Added IsSimple attribute.
*     2-FEB-2006 (DSB):
*        Corrections to prologue of astLinearApprox.
*     16-FEB-2006 (DSB):
*        Some speed optimisations to rebinning code.
*     2-MAR-2006 (DSB):
*        Use HAVE_LONG_DOUBLE in place of AST_LONG_DOUBLE
*     7-MAR-2006 (DSB):
*        Added astTranGrid.
*     14-MAR-2006 (DSB):
*        - The constructor no longer reports an error if the resulting
*	 Mapping cannot transform points in either direction. This is
*	 because it may be possible to simplify such a Mapping and the
*	 simplified Mapping may have defined transformations. E.g. if a
*	 Mapping which has only a forward transformation is combined in
*	 series with its own inverse, the combination CmpMap will simplify
*        to a UnitMap (usually).
*        - Reset the "issimple" flag when the Invert flag is changed.
*     9-MAY-2006 (DSB):
*        Correct upper bounds for idim in RebinWithblocking. Also, remove
*        the single precision "F" instantiation of the MAKE_REBINSEQ macro.
*        Also correct the "nout = astGetNin" line in the MAKE_REBINSEQ
*        macro to "nout = astGetNout".
*     12-MAY-2006 (DSB):
*        Modify SpecialBounds to include points slightly inside the
*        corners. This is because some Mappings may have singularies at
*        the the edges.
*     17-MAY-2006 (DSB):
*        Correct the "nout = astGetNin" line in the MAKE_RESAMPLE
*        and MAKE_REBIN macros to "nout = astGetNout".
*     7-JUL-2006 (DSB):
*        Change -CHAR_MAX value (used as a "not set" value for boolean
*        attributes) to +CHAR_MAX, since some compilers do not allow
*        chars to have negative values.
*     23-AUG-2006 (DSB):
*        Change the Equal function so that it reports an error when
*        called, rather than using astSimplify to determine if two Mappings
*        are equal. All concrete Mapping classes should now provide
*        their own implementation of astEqual, avoiding the use of
*        astSimplify. This is so that astSimplify can use astEqual safely
*        (i.e. without danger of entering an infinite loop).
*     24-NOV-2006 (DSB):
*        Allow astRebinSeq to be called with a NULL pointer for the input
*        data array.
*     14-MAR-2007 (DSB):
*        Modify astRebinSeq to allow input variances to be used as weights.
*     19-MAR-2007 (DSB):
*        Fix bug in LINEAR_2D macro that caused bad input pixel values to be
*        treated as good.
*     16-APR-2007 (DSB):
*        Account for reduction in number of degrees of freedom when
*        calculating output variances on the basis of spread of input values in
*        astReinSeq.
*     28-APR-2007 (DSB):
*        Correct code within Rebin... and Resample... functions that provides
*        optimal handling for 1- and 2- dimensional mappings. Previously, the
*        check for whether or not to use these optimisations was based only on
*        the dimensionality of either input (Rebin) or output (Resample). This
*        could cause the optimised code to be used at inappropriate times,
*        leading to an incorrect effective Mapping between input and output. The
*        checks now check both input and output dimensionality in all cases.
*     3-MAY-2007 (DSB):
*        An extra parameter ("nused") has been added to astRebinSeq, and
*        all the rebinning stuff has been modified to keep "nused" up to date.
*        This is needed to correct a fault in the generation of GENVAR
*        variances.
*     12-DEC-2007 (DSB):
*        Some rebinning kernels (e.g. SINCSINC) have negative values and
*        can result in overall negative output weights. Therefore do not
*        set output pixels with negative weights bad.
*     6-MAR-2008 (DSB):
*        Add an option for astResample to leave unchanged any output pixels
*        for which an interpolated value cannot be obtained. This is
*        controlled by the new AST__NOBAD flag.
*     7-MAY-2008 (DSB):
*        Clarified meaning of AST__GENVAR, AST__USEVAR and AST__VARWGT flags
*        in astRebinSeq.
*     9-MAY-2008 (DSB):
*        Prevent memory over-run in RebinSeq<X>.
*     5-MAY-2009 (DSB):
*        Added astRemoveRegions.
*     11-NOV-2009 (DSB):
*        In astRebinSeq initialise "*nused" to zero (as documented) if the
*        AST__REBININIT flag is supplied.
*     17-NOV-2009 (DSB):
*        Added AST_DISVAR flag for use with astRebinSeq.
*     15-DEC-2009 (DSB):
*        Ensure that all axes span at least one pixel when calling
*        astLinearApprox.
*     18-DEC-2009 (DSB):
*        When using a 1D spreading kernel (in astRebin(Seq)), if the kernel
*        is not contained completely within the output array, reflect the
*        section of the kernel that falls outside the output array back into
*        the output array so that no flux is lost. Also discovered that the
*        n-D code (i.e. the KERNEL_ND macro) incorrectly uses the first
*        user-supplied parameter as the full kernel width rather than the
*        half-width. This has been fixed.
*     26-FEB-2010 (DSB):
*        Add astQuadApprox.
*     27-FEB-2010 (DSB):
*        - Make astQuadApprox faster, and fix a bug in the calculation of
*        the matrix.
*     7-JUN-2010 (DSB):
*        In the KERNEL_<x>D rebinning macros, correct the test for the
*        central point being outside the bounds of the output image.
*     13-AUG-2010 (DSB):
*        In astRebinSeq<X>, scale WLIM to take account of weighting by
*        input variances.
*     13-DEC-2010 (DSB):
*        Ensure that astMapSplit returns a Mapping that is independent of
*        the supplied Mapping (i.e. return a deep copy). This means that
*        subsequent changes to the supplied Mapping cannot affect the returned
*        Mapping.
*     10-FEB-2011 (DSB):
*        When rebinning (in macros NEAR_1/2/ND, KERNEL_1/2/ND, LINEAR_1/2/ND),
*        do not treat a zero variance as bad unless the reciprocals of the
*        variances are being used as weights.
*     16-JUN-2011 (DSB):
*        Allow a check for NaNs to be performed as a debugging tool after
*        every invocation of astTransform. This is controlled by the
*        AST_REPLACE_NAN environment variable: if unset, no check is
*        performed, if set to "1" NaNs are changed to AST__BAD but no
*        error is reported, if set to anything else NaNs are changed to
*        AST__BAD and an error is reported.
*     6-JUL-2012 (DSB):
*        The astRebinSeq<X> family was normalising the returned data and
*        variances values incorrectly, when the AST__REBINEND flag was
*        supplied. The exact size of the error depended on the nature of
*        the Mapping and the spreading method, and so is hard to predict.
*     20-JUL-2012 (DSB):
*        Major re-structuring of astRebinSeq<X> to add further
*        corrections to the normalisation. The model is now that each
*        input array is first rebinned and then scaled to preserve the
*        total data sum, and then each final output pixel is the weighed
*        mean of all the aligned rebinned  pixels.
*     13-AUG-2012 (DSB):
*        Added AST__NONORM flag for asstRebuinSeq<X>.
*     30-AUG_2012 (DSB):
*        Added AST__CONSERVEFLUX flag for astRebinSeq<X>.
*     10-SEP-2012 (DSB):
*        Cater for Mappings that have different numbers of inputs and
*        outputs when finding the flux conservation factor within
*        astRebinSeq and astResample.
*     1-OCT-2012 (DSB):
*        Ensure astRebinSeq<X> does not create any negative output
*        variances.
*     2-OCT-2012 (DSB):
*        - Check for Infs as well as NaNs.
*        - In Rate, break out of the loop if the RMS is very small, not
*          just if it is exactly zero.
*     5-OCT-2012 (DSB):
*        Complete re-write of Rate. It's now much simpler, faster and
*        more reliable.
*     16-OCT-2012 (DSB):
*        In MatrixDet, ignore rows/columns filled with AST_BAD as well as
*        rows/columns filled with zeros.
*     26-APR-2013 (DSB):
*        Change the "nused" parameter of astRebinSeq<X> from "int *" to
*        "size_t *" to allow greater amounts of data to be pasted into
*        the output array.
*     29-APR-2013 (DSB):
*        Do not simplify Mappings that have a set value for their Ident
*        attribute. If an Ident value has been set then it means that we
*        should be trying to preserve the identify of the Mapping. This
*        is implemented via a new protected method (astDoNotSimplify) which
*        is overridden by the Frame class so that this restriction applies
*        only to genuine Mappings, not Frames.
*     9-MAY-2013 (DSB):
*        Change the "nused" parameter of astRebinSeq<X> from "size_t *" to
*        "int64_t *" to cater for systems where "size_t" is only 32 bits long.
*     20-MAY-2013 (DSB):
*        Always perform a linear fit in RebinAdaptively if flux
*        conservation is requested.
*     18-JUL-2013 (DSB):
*        Correct logic for determining whether to divide or not in
*        RebinAdaptively. The old logic could lead to infinite recursion.
*     1-SEP-2014 (DSB):
*        Modify astLinearApprox to avoid using regularly placed
*        test points, as such regular placement may result in
*        non-representative behaviour.
*     25-SEP-2014 (DSB):
*        Add support for B and UB data types to astRebin and astRebinSeq.
*     23-OCT-2014 (DSB):
*        Report an error if arrays have too many pixels to count in a 32
*        bit int (astTranGrid, astResample, astRebin and astRebinSeq).
*     23-APR-2015 (DSB):
*        Use one bit of this->flags to store the "IsSimple" attribute
*        rather using a whole char (this->issimple).
*     16-JUN-2017 (DSB):
*        If a simplification fails because the simplification process makes
*        an inappropriate assumption about the supplied Mapping (e.g. that
*        it has a defined inverse transformation) - thus causing an error to
*        be reported, then clear the error status and return a clone of the
*        unmodified supplied Mapping. Putting this check in the astSimplify_
*        wrapper function in the base Mapping class is much simpler and less
*        error prone than performing tests on the appropriateness of the
*        mapping in teh astMapMerge method of each and every mapping class.
*     9-JAN-2018 (DSB):
*        Modify astLinearApprox so that a linear mapping in parallel with a
*        mapping that generates bad values is considered linear. The returned
*        coeffs for the bad outputs are set bad.
*     9-MAR-2018 (DSB):
*        Added the AST__PARWGT flag in astRebinSeq.
*
*class--
*/

/* Module Macros. */
/* ============== */
/* Set the name of the class we are implementing. This indicates to the header
   files that define class interfaces that they should make "protected"
   symbols available. */
#define astCLASS Mapping

/* Define numerical constants for use in thie module. */
#define GETATTRIB_BUFF_LEN 50
#define RATEFUN_MAX_CACHE  5
#define RATE_ORDER 8

/* Include files. */
/* ============== */

/* Configuration results  */
/* ---------------------- */
#if HAVE_CONFIG_H
#include <config.h>
#endif

/* Interface definitions. */
/* ---------------------- */

#include "globals.h"             /* Thread-safe global data access */
#include "error.h"               /* Error reporting facilities */
#include "memory.h"              /* Memory allocation facilities */
#include "object.h"              /* Base Object class */
#include "pointset.h"            /* Sets of points/coordinates */
#include "channel.h"             /* I/O channels */
#include "mapping.h"             /* Interface definition for this class */
#include "cmpmap.h"              /* Compund Mappings */
#include "unitmap.h"             /* Unit Mappings */
#include "permmap.h"             /* Axis permutations */
#include "winmap.h"              /* Window scalings */
#include "pal.h"                 /* SLALIB interface */
#include "globals.h"             /* Thread-safe global data access */

/* Error code definitions. */
/* ----------------------- */
#include "ast_err.h"             /* AST error codes */

/* C header files. */
/* --------------- */
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

/* Module type definitions. */
/* ======================== */
/* Enum to represent the data type when resampling a grid of data. */
typedef enum DataType {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
   TYPE_LD,
#endif
   TYPE_D,
   TYPE_F,
   TYPE_L,
   TYPE_UL,
   TYPE_K,
   TYPE_UK,
   TYPE_I,
   TYPE_UI,
   TYPE_S,
   TYPE_US,
   TYPE_B,
   TYPE_UB
} DataType;

/* Data structure to hold information about a Mapping for use by
   optimisation algorithms. */
typedef struct MapData {
   AstMapping *mapping;          /* Pointer to the Mapping */
   AstPointSet *pset_in;         /* Pointer to input PointSet */
   AstPointSet *pset_out;        /* Pointer to output PointSet */
   double *lbnd;                 /* Pointer to lower constraints on input */
   double *ubnd;                 /* Pointer to upper constraints on input */
   double **ptr_in;              /* Pointer to input PointSet coordinates */
   double **ptr_out;             /* Pointer to output PointSet coordinates */
   int coord;                    /* Index of output coordinate to optimise */
   int forward;                  /* Use forward transformation? */
   int negate;                   /* Negate the output value? */
   int nin;                      /* Number of input coordinates per point */
   int nout;                     /* Number of output coordinates per point */
} MapData;

/* Convert from floating point to floating point or integer */
#define CONV(IntType,val) ( ( IntType ) ? (int) ( (val) + (((val)>0)?0.5:-0.5) ) : (val) )

/* Module Variables. */
/* ================= */

/* Address of this static variable is used as a unique identifier for
   member of this class. */
static int class_check;

/* Pointers to parent class methods which are extended by this class. */
static const char *(* parent_getattrib)( AstObject *, const char *, int * );
static int (* parent_testattrib)( AstObject *, const char *, int * );
static void (* parent_clearattrib)( AstObject *, const char *, int * );
static void (* parent_setattrib)( AstObject *, const char *, int * );
static int (* parent_equal)( AstObject *, AstObject *, int * );


/* Define macros for accessing each item of thread specific global data. */
#ifdef THREAD_SAFE

/* Define how to initialise thread-specific globals. */
#define GLOBAL_inits \
   globals->Class_Init = 0; \
   globals->GetAttrib_Buff[ 0 ] = 0; \
   globals->Unsimplified_Mapping = NULL; \
   globals->Rate_Disabled = 0;


/* Create the function that initialises global data for this module. */
astMAKE_INITGLOBALS(Mapping)

/* Define macros for accessing each item of thread specific global data. */
#define class_init astGLOBAL(Mapping,Class_Init)
#define class_vtab astGLOBAL(Mapping,Class_Vtab)
#define getattrib_buff astGLOBAL(Mapping,GetAttrib_Buff)
#define unsimplified_mapping astGLOBAL(Mapping,Unsimplified_Mapping)
#define rate_disabled astGLOBAL(Mapping,Rate_Disabled)
#define ratefun_pset1_cache astGLOBAL(Mapping,RateFun_Pset1_Cache)
#define ratefun_pset2_cache astGLOBAL(Mapping,RateFun_Pset2_Cache)
#define ratefun_next_slot astGLOBAL(Mapping,RateFun_Next_Slot)
#define ratefun_pset_size astGLOBAL(Mapping,RateFun_Pset_Size)



/* If thread safety is not needed, declare and initialise globals at static
   variables. */
#else

/* Buffer returned by GetAttrib. */
static char getattrib_buff[ GETATTRIB_BUFF_LEN + 1 ];

/* Pointer to origin (unsimplified) Mapping, only used for reporting
   error messages. */
static AstMapping *unsimplified_mapping = NULL;

/* A flag which indicates if the astRate method should be disabled in
   order to improve algorithm speed in cases where the rate value is not
   significant. If astRate is disabled then it always returns a constant
   value of 1.0. */
static int rate_disabled = 0;

/* static values used in function "RateFun". */
static AstPointSet *ratefun_pset1_cache[ RATEFUN_MAX_CACHE ];
static AstPointSet *ratefun_pset2_cache[ RATEFUN_MAX_CACHE ];
static int ratefun_next_slot;
static int ratefun_pset_size[ RATEFUN_MAX_CACHE ];


/* Define the class virtual function table and its initialisation flag
   as static variables. */
static AstMappingVtab class_vtab;   /* Virtual function table */
static int class_init = 0;       /* Virtual function table initialised? */

#endif

/* Prototypes for private member functions. */
/* ======================================== */

#define DECLARE_GENERIC(X,Xtype) \
static int InterpolateKernel1##X( AstMapping *, int, const int *, const int *, \
                                  const Xtype *, const Xtype *, int, \
                                  const int *, const double *const *, \
                                  void (*)( double, const double *, int, \
                                            double *, int * ), \
                                  void (*)( double, const double *, int, \
                                            double * ), \
                                  int, const double *, int, Xtype, \
                                  Xtype *, Xtype *, int * );\
\
static int InterpolateLinear##X( int, const int *, const int *, const Xtype *, \
                                 const Xtype *, int, const int *, \
                                 const double *const *, int, Xtype, Xtype *, \
                                 Xtype *, int * ); \
\
static int InterpolateNearest##X( int, const int *, const int *, const Xtype *, \
                                  const Xtype *, int, const int *, \
                                  const double *const *, int, Xtype, Xtype *, \
                                  Xtype *, int * ); \
\
static int Resample##X( AstMapping *, int, const int [], const int [], \
                        const Xtype [], const Xtype [], int, \
                        void (*)( void ), const double [], int, double, int, \
                        Xtype, int, const int [], const int [], \
                        const int [], const int [], Xtype [], Xtype [], int * ); \
\
static void ConserveFlux##X( double, int, const int *, Xtype, Xtype *, Xtype *, \
                             int * ); \
\
static void InterpolateBlockAverage##X( int, const int[], const int[], \
                             const Xtype [], const Xtype [], int, const int[], \
                             const double *const[], const double[], int, \
                             Xtype, Xtype *, Xtype *, int * );

DECLARE_GENERIC(B,signed char)
DECLARE_GENERIC(D,double)
DECLARE_GENERIC(F,float)
DECLARE_GENERIC(I,int)
DECLARE_GENERIC(K,INT_BIG)
DECLARE_GENERIC(L,long int)
DECLARE_GENERIC(S,short int)
DECLARE_GENERIC(UB,unsigned char)
DECLARE_GENERIC(UI,unsigned int)
DECLARE_GENERIC(UK,UINT_BIG)
DECLARE_GENERIC(UL,unsigned long int)
DECLARE_GENERIC(US,unsigned short int)

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
DECLARE_GENERIC(LD,long double)
#endif

#undef DECLARE_GENERIC

#define DECLARE_GENERIC(X,Xtype) \
static void Rebin##X( AstMapping *, double, int, const int [], const int [], \
                      const Xtype [], const Xtype [], int, const double [], int, \
                      double, int, Xtype, int, const int [], const int [], \
                      const int [], const int [], Xtype [], Xtype [], int * ); \
\
static void RebinSeq##X( AstMapping *, double, int, const int [], const int [], \
                         const Xtype [], const Xtype [], int, const double [], \
                         int, double, int, Xtype, int, const int [], \
                         const int [], const int [], const int [], Xtype [], \
                         Xtype [], double [], int64_t *, int * ); \
\
static void SpreadKernel1##X( AstMapping *, int, const int *, const int *, \
                         const Xtype *, const Xtype *, double, int, const int *, \
                         const double *const *, \
                         void (*)( double, const double *, int, double *, int * ), \
                         int, const double *, double, int, Xtype, int, Xtype *, \
                         Xtype *, double *, int64_t *, int * ); \
\
static void SpreadLinear##X( int, const int *, const int *, const Xtype *, \
                             const Xtype *, double, int, const int *, const double *const *, \
                             double, int, Xtype, int, Xtype *, Xtype *, double *, int64_t *, \
                             int * ); \
\
static void SpreadNearest##X( int, const int *, const int *, const Xtype *, \
                              const Xtype *, double, int, const int *, const double *const *, \
                              double, int, Xtype, int, Xtype *, Xtype *, double *, \
                              int64_t *, int * );

DECLARE_GENERIC(D,double)
DECLARE_GENERIC(F,float)
DECLARE_GENERIC(I,int)
DECLARE_GENERIC(UB,unsigned char)
DECLARE_GENERIC(B,signed char)

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
DECLARE_GENERIC(LD,long double)
#endif

#undef DECLARE_GENERIC






static AstMapping *RemoveRegions( AstMapping *, int * );
static AstMapping *Simplify( AstMapping *, int * );
static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
static const char *GetAttrib( AstObject *, const char *, int * );
static double FindGradient( AstMapping *, double *, int, int, double, double, double *, int * );
static double J1Bessel( double, int * );
static double LocalMaximum( const MapData *, double, double, double [], int * );
static double MapFunction( const MapData *, const double [], int *, int * );
static double MatrixDet( int, int, const double *, int * );
static double MaxD( double, double, int * );
static double NewVertex( const MapData *, int, double, double [], double [], int *, double [], int * );
static double Random( long int *, int * );
static double Rate( AstMapping *, double *, int, int, int * );
static double UphillSimplex( const MapData *, double, int, const double [], double [], double *, int *, int * );
static int *MapSplit( AstMapping *, int, const int *, AstMapping **, int * );
static int Equal( AstObject *, AstObject *, int * );
static int GetInvert( AstMapping *, int * );
static int GetIsLinear( AstMapping *, int * );
static int GetIsSimple( AstMapping *, int * );
static int GetNin( AstMapping *, int * );
static int GetNout( AstMapping *, int * );
static int GetReport( AstMapping *, int * );
static int GetTranForward( AstMapping *, int * );
static int GetTranInverse( AstMapping *, int * );
static int LinearApprox( AstMapping *, const double *, const double *, double, double *, int * );
static int MapList( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
static int MapMerge( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
static int MaxI( int, int, int * );
static int MinI( int, int, int * );
static int DoNotSimplify( AstMapping *, int * );
static int QuadApprox( AstMapping *, const double[2], const double[2], int, int, double *, double *, int * );
static int RebinAdaptively( AstMapping *, int, const int *, const int *, const void *, const void *, DataType, int, const double *, int, double, int, const void *, int, const int *, const int *, const int *, const int *, int, void *, void *, double *, int64_t *, int * );
static int RebinWithBlocking( AstMapping *, const double *, int, const int *, const int *, const void *, const void *, DataType, int, const double *, int, const void *, int, const int *, const int *, const int *, const int *, int, void *, void *, double *, int64_t *, int * );
static int ResampleAdaptively( AstMapping *, int, const int *, const int *, const void *, const void *, DataType, int, void (*)( void ), const double *, int, double, int, const void *, int, const int *, const int *, const int *, const int *, void *, void *, int * );
static int ResampleSection( AstMapping *, const double *, int, const int *, const int *, const void *, const void *, DataType, int, void (*)( void ), const double *, double, int, const void *, int, const int *, const int *, const int *, const int *, void *, void *, int * );
static int ResampleWithBlocking( AstMapping *, const double *, int, const int *, const int *, const void *, const void *, DataType, int, void (*)( void ), const double *, int, const void *, int, const int *, const int *, const int *, const int *, void *, void *, int * );
static int SpecialBounds( const MapData *, double *, double *, double [], double [], int * );
static int TestAttrib( AstObject *, const char *, int * );
static int TestInvert( AstMapping *, int * );
static int TestReport( AstMapping *, int * );
static void ClearAttrib( AstObject *, const char *, int * );
static void ClearInvert( AstMapping *, int * );
static void ClearReport( AstMapping *, int * );
static void Copy( const AstObject *, AstObject *, int * );
static void Decompose( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
static void Delete( AstObject *, int * );
static void Dump( AstObject *, AstChannel *, int * );
static void Gauss( double, const double [], int, double *, int * );
static void GlobalBounds( MapData *, double *, double *, double [], double [], int * );
static void Invert( AstMapping *, int * );
static void MapBox( AstMapping *, const double [], const double [], int, int, double *, double *, double [], double [], int * );
static void RateFun( AstMapping *, double *, int, int, int, double *, double *, int * );
static void RebinSection( AstMapping *, const double *, int, const int *, const int *, const void *, const void *, double, DataType, int, const double *, int, const void *, int, const int *, const int *, const int *, const int *, int, void *, void *, double *, int64_t *, int * );
static void ReportPoints( AstMapping *, int, AstPointSet *, AstPointSet *, int * );
static void SetAttrib( AstObject *, const char *, int * );
static void SetInvert( AstMapping *, int, int * );
static void SetReport( AstMapping *, int, int * );
static void Sinc( double, const double [], int, double *, int * );
static void SincCos( double, const double [], int, double *, int * );
static void SincGauss( double, const double [], int, double *, int * );
static void SincSinc( double, const double [], int, double *, int * );
static void Somb( double, const double [], int, double *, int * );
static void SombCos( double, const double [], int, double *, int * );
static void Tran1( AstMapping *, int, const double [], int, double [], int * );
static void Tran2( AstMapping *, int, const double [], const double [], int, double [], double [], int * );
static void TranGrid( AstMapping *, int, const int[], const int[], double, int, int, int, int, double *, int * );
static void TranGridAdaptively( AstMapping *, int, const int[], const int[], const int[], const int[], double, int, int, double *[], int * );
static void TranGridSection( AstMapping *, const double *, int, const int *, const int *, const int *, const int *, int, double *[], int * );
static void TranGridWithBlocking( AstMapping *, const double *, int, const int *, const int *, const int *, const int *, int, double *[], int * );
static void TranN( AstMapping *, int, int, int, const double *, int, int, int, double *, int * );
static void TranP( AstMapping *, int, int, const double *[], int, int, double *[], int * );
static void ValidateMapping( AstMapping *, int, int, int, int, const char *, int * );



/* Member functions. */
/* ================= */
static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     ClearAttrib

*  Purpose:
*     Clear an attribute value for a Mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void ClearAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Mapping member function (over-rides the astClearAttrib protected
*     method inherited from the Object class).

*  Description:
*     This function clears the value of a specified attribute for a
*     Mapping, so that the default value will subsequently be used.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     attrib
*        Pointer to a null terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstMapping *this;             /* Pointer to the Mapping structure */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Mapping structure. */
   this = (AstMapping *) this_object;

/* Check the attribute name and clear the appropriate attribute. */

/* Invert. */
/* ------- */
   if ( !strcmp( attrib, "invert" ) ) {
      astClearInvert( this );

/* Report. */
/* ------- */
   } else if ( !strcmp( attrib, "report" ) ) {
      astClearReport( this );

/* If the name was not recognised, test if it matches any of the
   read-only attributes of this class. If it does, then report an
   error. */
   } else if ( !strcmp( attrib, "nin" ) ||
               !strcmp( attrib, "nout" ) ||
               !strcmp( attrib, "issimple" ) ||
               !strcmp( attrib, "islinear" ) ||
               !strcmp( attrib, "tranforward" ) ||
               !strcmp( attrib, "traninverse" ) ) {
      astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" "
                "value for a %s.", status, attrib, astGetClass( this ) );
      astError( AST__NOWRT, "This is a read-only attribute." , status);

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_clearattrib)( this_object, attrib, status );
   }
}

/*
*  Name:
*     ConserveFlux<X>

*  Purpose:
*     Scale the output data and variance values produced by ResampleSection
*     by the given flux conservation factor.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void ConserveFlux<X>( double factor, int npoint, const int *offset,
*                           <Xtype> badval, <Xtype> *out,
*                           <Xtype> *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which scale the supplied resampled data
*     values by the given flux conservation factor. It also scales any
*     variances by the square of the factor.

*  Parameters:
*     factor
*        The flux conservation factor. This should be the ratio of the
*        output pixel size to the input pixel size, in the locality of
*        the supplied data values.
*     npoint
*        The number of points at which the input grid was resampled.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each output point, this array should contain the zero-based
*        offset in the output array(s) (i.e. the "out" and,
*        optionally, the "out_var" arrays) at which the resampled
*        output value(s) is stored.
*     badval
*        This parameter specifies the value which is used to identify
*        bad data and/or variance values in the output array(s).
*     out
*        Pointer to an array in which the resampled data is supplied. Note
*        that details of how the output grid maps on to this array
*        (e.g. the storage order, number of dimensions, etc.) is
*        arbitrary and is specified entirely by means of the "offset"
*        array. The "out" array should therefore contain sufficient
*        elements to accommodate the "offset" values supplied.  There
*        is no requirement that all elements of the "out" array should
*        be assigned values, and any which are not addressed by the
*        contents of the "offset" array will be left unchanged.
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, in which variance estimates for
*        the resampled values are supplied. If no output variance estimates
*        are available, a NULL pointer should be given.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_CONSERVEFLUX(X,Xtype) \
static void ConserveFlux##X( double factor, int npoint, const int *offset, \
                             Xtype badval, Xtype *out, Xtype *out_var, int *status ) { \
\
/* Local Variables: */ \
   int off_out;                  /* Pixel offset into output array */ \
   int point;                    /* Loop counter for output points */ \
\
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
   for ( point = 0; point < npoint; point++ ) { \
      off_out = offset[ point ]; \
      if( out[ off_out ] != badval ) out[ off_out ] *= factor; \
   } \
\
   if( out_var ) { \
      factor *= factor; \
      for ( point = 0; point < npoint; point++ ) { \
         off_out = offset[ point ]; \
         if( out_var[ off_out ] != badval ) out_var[ off_out ] *= factor; \
      } \
   } \
}


/* Expand the macro above to generate a function for each required
   data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_CONSERVEFLUX(LD,long double)
#endif
MAKE_CONSERVEFLUX(D,double)
MAKE_CONSERVEFLUX(F,float)
MAKE_CONSERVEFLUX(K,INT_BIG)
MAKE_CONSERVEFLUX(L,long int)
MAKE_CONSERVEFLUX(I,int)
MAKE_CONSERVEFLUX(S,short int)
MAKE_CONSERVEFLUX(B,signed char)
MAKE_CONSERVEFLUX(UL,unsigned long int)
MAKE_CONSERVEFLUX(UI,unsigned int)
MAKE_CONSERVEFLUX(UK,UINT_BIG)
MAKE_CONSERVEFLUX(US,unsigned short int)
MAKE_CONSERVEFLUX(UB,unsigned char)

/* Undefine the macros used above. */
#undef MAKE_CONSERVEFLUX

static void Decompose( AstMapping *this, AstMapping **map1, AstMapping **map2,
                       int *series, int *invert1, int *invert2, int *status ) {
/*
*+
*  Name:
*     astDecompose

*  Purpose:
*     Decompose a Mapping into two component Mappings.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     void astDecompose( AstMapping *this, AstMapping **map1,
*                        AstMapping **map2, int *series, int *invert1,
*                        int *invert2  )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns pointers to two Mappings which, when applied
*     either in series or parallel, are equivalent to the supplied Mapping.
*
*     Since the Frame class inherits from the Mapping class, Frames can
*     be considered as special types of Mappings and so this method can
*     be used to decompose CmpMaps, CmpFrames, CmpRegions or Prisms.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     map1
*        Address of a location to receive a pointer to first component
*        Mapping.
*     map2
*        Address of a location to receive a pointer to second component
*        Mapping.
*     series
*        Address of a location to receive a value indicating if the
*        component Mappings are applied in series or parallel. A non-zero
*        value means that the supplied Mapping is equivalent to applying map1
*        followed by map2 in series. A zero value means that the supplied
*        Mapping is equivalent to applying map1 to the lower numbered axes
*        and map2 to the higher numbered axes, in parallel.
*     invert1
*        The value of the Invert attribute to be used with map1.
*     invert2
*        The value of the Invert attribute to be used with map2.

*  Applicability:
*     CmpMap
*        If the supplied Mapping is a CmpMap, then map1 and map2 will be
*        returned holding pointers to the component Mappings used to
*        create the CmpMap, either in series or parallel.
*     Mapping
*        For any class of Mapping other than a CmpMap, map1 will be
*        returned holding a clone of the supplied Mapping pointer, and map2
*        will be returned holding a NULL pointer.
*     CmpFrame
*        If the supplied Mapping is a CmpFrame, then map1 and map2 will be
*        returned holding pointers to the component Frames used to
*        create the CmpFrame. The component Frames are considered to be in
*        applied in parallel.
*     Frame
*        For any class of Frame other than a CmpFrame, map1 will be
*        returned holding a clone of the supplied Frame pointer, and map2
*        will be returned holding a NULL pointer.

*  Notes:
*     - Any changes made to the component Mappings using the returned
*     pointers will be reflected in the supplied Mapping.
*     - The returned Invert values should be used in preference to the
*     current values of the Invert attribute in map1 and map2. This is
*     because the attributes may have changed value since the Mappings
*     were combined.

*  Implementation Notes:
*     - This function implements the basic astDecompose method
*     available via the protected interface to the Frame class. The
*     public interface to this method is provided by the
*     astDecomposeId_ function.

*-
*/

/* Check the global error status. */
   if ( !astOK ) return;

/* The basic Mapping class returns a clone of the supplied Mapping as
   map1 and a NULL pointer as map2. */
   if( map1 ) *map1 = astClone( this );
   if( map2 ) *map2 = NULL;
   if( series ) *series = 1;
   if( invert1 ) *invert1 = astGetInvert( this );
   if( invert2 ) *invert2 = 0;
}

static int DoNotSimplify( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astMapMerge

*  Purpose:
*     Check if a Mapping is appropriate for simplification.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astDoNotSImplify( AstMapping *this );

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns a flag indivating if the supplied Mapping is
*     appropriate for simplification.

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     Non-zero if the supplied Mapping is not appropriate for
*     simplification, and zero otherwise.

*  Notes:
*     - A value of 0 will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Check inherited status. */
   if( !astOK ) return 0;

/* Mappings that have a set value for the Ident attribute should not be
   simplified since we want to preserve their individual identify (otherwise
   why would the user have given them an Ident value?). */
   return astTestIdent( this );
}

int astRateState_( int disabled, int *status ) {
/*
*+
*  Name:
*     astRateState

*  Purpose:
*     Control whether the astRate method is disabled or not.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "mapping.h"
*     int astRateState( int disabled )

*  Class Membership:
*     Mapping member function

*  Description:
*     Some algorithms which use use the astRate method do not actually need
*     to know what the Rate value is. For instance, when the Plot class draws
*     a border it evaluates the GRAPHICS->Current Mapping hundreds of time.
*     If the Mapping includes a RateMap then this can be very very slow
*     (depending on how the astRate method is implemented). In fact the
*     border drawing algorithm onlyneeds to know if the result is bad or
*     not - the actual value produced by the Mappign does not matter.
*
*     Such algorithms can be speeded up by forcing the astRate method to
*     return a constant value rather than actually doing the numerical
*     differentiation. This can be accomplised by calling this method prior
*     to implementing the algorithm. It should be called at the end in
*     order to re-instate the original disabled flag.

*  Parameters:
*     disabled
*        The new value for the astRate disabled flag.

*  Returned Value:
*     The original value of the astRate disabled flag.

*-
*/
   astDECLARE_GLOBALS
   int result;
   astGET_GLOBALS(NULL);

   result = rate_disabled;
   rate_disabled = disabled;
   return result;
}

static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
/*
*  Name:
*     Equal

*  Purpose:
*     Test if two Mappings are equivalent.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int Equal( AstObject *this, AstObject *that, int *status )

*  Class Membership:
*     Mapping member function (over-rides the astEqual protected
*     method inherited from the Object class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     two Mappings are equivalent.
*
*     The implementation provided by this class (the base Mapping class)
*     simply reports an error when called, since all concrete Mapping
*     subclasses should provide their own implementation.
*
*     Note, sub-class implementations should not use astSimplify (e.g.
*     combining the two Mapping and then simplifying it), since the
*     astSimplify method for certain classes (e.g. CmpMap) may use
*     astEqual. Consequently, if astEqual called astSimplify, there would
*     be possibilities for infinite loops.

*  Parameters:
*     this
*        Pointer to the first Object (a Mapping).
*     that
*        Pointer to the second Object.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if the Frames are equivalent, zero otherwise.

*  Notes:
*     - The two Mappings are considered equivalent if the combination of
*     the first in series with the inverse of the second simplifies to a
*     UnitMap.
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   int result;                /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Invoke the Equal method inherited from the parent Object class. This checks
   that the Objects are both of the same class (amongst other things). */
   if( (*parent_equal)( this_object, that_object, status ) ) {

/* Report an error since the concrete sub-class should have over-riden
   this method. */
      astError( AST__INTER, "astEqual(Mapping): The %s class does "
                "not override the abstract astEqual method inherited "
                "from the base Mapping class (internal AST programming "
                "error).", status, astGetClass( this_object ) );
   }

/* If an error occurred, clear the result value. */
   if ( !astOK ) result = 0;

/* Return the result, */
   return result;
}

static double FindGradient( AstMapping *map, double *at, int ax1, int ax2,
                            double x0, double h, double *range, int *status ){
/*
*  Name:
*     FindGradient

*  Purpose:
*     Find the mean gradient in an interval, and the range of gradients
*     within the interval.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double FindGradient( AstMapping *map, double *at, int ax1, int ax2,
*                          double x0, double h, double *range, int *status )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function finds the mean gradient in an interval, and the range
*     of gradients within the interval.

*  Parameters:
*     map
*        Pointer to a Mapping which yields the value of the function at x.
*        The Mapping may have any number of inputs and outputs; the specific
*        output representing the function value, f, is specified by ax1 and
*        the specific input representing the argument, x, is specified by ax2.
*     at
*        A pointer to an array holding axis values at the position at which
*        the function is to be evaluated. The number of values supplied
*        must equal the number of inputs to the Mapping. The value supplied
*        for axis "ax2" is ignored (the value of "x" is used for axis "ax2").
*     ax1
*        The zero-based index of the Mapping output which is to be
*        differentiated. Set this to -1 to allocate, or -2 to release,
*        the static resources used by this function.
*     ax2
*        The zero-based index of the Mapping input which is to be varied.
*     x0
*        The central axis value at which the function is to be evaluated.
*     h
*        The interval over which the fitting is to be performed.
*     range
*        A pointer to a location at which to return the range of
*        gradients found within the interval.
*     status
*        Pointer to the inherited status variable.

*  Returns:
*     The mean gradient, or AST__BAD if the mean gradient cannot be
*     calculated.
*/

/* Local Variables: */
   double dh;
   double g;
   double gmax;
   double gmin;
   double ret;
   double x1;
   double x2;
   double x[ RATE_ORDER + 2 ];
   double y1;
   double y2;
   double y[ RATE_ORDER + 2 ];
   int i0;
   int i;
   int ngood;

/* Initialise */
   ret = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return ret;

/* Store the x values at (RATE_ORDER+1) evenly spaced points over the interval
   "h" centred on "x0". */
   i0 = RATE_ORDER/2;
   dh = h/RATE_ORDER;

   for( i = 0; i <= RATE_ORDER; i++ ) {
      x[ i ] = x0 + ( i - i0 )*dh;
   }

/* Get the function values at these positions. */
   RateFun( map, at, ax1, ax2, RATE_ORDER + 1, x, y, status );

/* Find the maximum and minimum mean gradient within any sub-interval, and
   note the (x,y) values at the first and last good point within the
   interval. */
   y1 = AST__BAD;
   y2 = AST__BAD;
   gmax = AST__BAD;
   gmin = AST__BAD;
   ngood = 0;

   for( i = 0; i < RATE_ORDER; i++ ) {
      if( y[ i + 1 ] !=AST__BAD && y[ i ] != AST__BAD &&
          x[ i + 1 ] != x[ i ] ) {
         ngood++;

         g = ( y[ i + 1 ] - y[ i ] )/( x[ i + 1 ] - x[ i ] );

         if( ngood == 1 ) {
            gmax = gmin = g;
         } else if( g < gmin ) {
            gmin = g;
         } else if( g > gmax) {
            gmax = g;
         }
         if( y1 == AST__BAD ) {
            y1 = y[ i ];
            x1 = x[ i ];
         }
         y2 = y[ i + 1 ];
         x2 = x[ i + 1 ];
      }
   }

/* If two or more sub-intervals were usable, return the range of
   gradients found, and the mean gradient. */
   if( ngood > 1 ) {
      ret = ( y2 - y1 )/( x2 - x1 );
      if( range ) *range = ( gmax - gmin );
   }

   return ret;
}

static void Gauss( double offset, const double params[], int flags,
                   double *value, int *status ) {
/*
*  Name:
*     Gauss

*  Purpose:
*     1-dimensional Gaussian spreading kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void Gauss( double offset, const double params[], int flags,
*                 double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     spreading kernel. The function used is exp(-k*x*x).

*  Parameters:
*     offset
*        The offset of a pixel from the central output point, measured
*        in pixels.
*     params
*        The first element of this array should give a value for "k"
*        in the exp(-k*x*x) term.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Calculate the result. */
   *value = exp( -params[ 0 ] * offset * offset );
}

static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     GetAttrib

*  Purpose:
*     Get the value of a specified attribute for a Mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Mapping member function (over-rides the protected astGetAttrib
*     method inherited from the Object class).

*  Description:
*     This function returns a pointer to the value of a specified
*     attribute for a Mapping, formatted as a character string.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     attrib
*        Pointer to a null terminated string containing the name of
*        the attribute whose value is required. This name should be in
*        lower case, with all white space removed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to a null terminated string containing the attribute
*     value.

*  Notes:
*     - The returned string pointer may point at memory allocated
*     within the Mapping, or at static memory. The contents of the
*     string may be over-written or the pointer may become invalid
*     following a further invocation of the same function or any
*     modification of the Mapping. A copy of the string should
*     therefore be made if necessary.
*     - A NULL pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstMapping *this;             /* Pointer to the Mapping structure */
   const char *result;           /* Pointer value to return */
   int invert;                   /* Invert attribute value */
   int islinear;                 /* IsLinear attribute value */
   int issimple;                 /* IsSimple attribute value */
   int nin;                      /* Nin attribute value */
   int nout;                     /* Nout attribute value */
   int report;                   /* Report attribute value */
   int tran_forward;             /* TranForward attribute value */
   int tran_inverse;             /* TranInverse attribute value */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this_object);

/* Obtain a pointer to the Mapping structure. */
   this = (AstMapping *) this_object;

/* Compare "attrib" with each recognised attribute name in turn,
   obtaining the value of the required attribute. If necessary, write
   the value into "getattrib_buff" as a null terminated string in an appropriate
   format.  Set "result" to point at the result string. */

/* Invert. */
/* ------- */
   if ( !strcmp( attrib, "invert" ) ) {
      invert = astGetInvert( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", invert );
         result = getattrib_buff;
      }

/* IsLinear. */
/* --------- */
   } else if ( !strcmp( attrib, "islinear" ) ) {
      islinear = astGetIsLinear( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", islinear );
         result = getattrib_buff;
      }

/* IsSimple. */
/* --------- */
   } else if ( !strcmp( attrib, "issimple" ) ) {
      issimple = astGetIsSimple( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", issimple );
         result = getattrib_buff;
      }

/* Nin. */
/* ---- */
   } else if ( !strcmp( attrib, "nin" ) ) {
      nin = astGetNin( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", nin );
         result = getattrib_buff;
      }

/* Nout. */
/* ----- */
   } else if ( !strcmp( attrib, "nout" ) ) {
      nout = astGetNout( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", nout );
         result = getattrib_buff;
      }

/* Report. */
/* ------- */
   } else if ( !strcmp( attrib, "report" ) ) {
      report = astGetReport( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", report );
         result = getattrib_buff;
      }

/* TranForward. */
/* ------------ */
   } else if ( !strcmp( attrib, "tranforward" ) ) {
      tran_forward = astGetTranForward( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", tran_forward );
         result = getattrib_buff;
      }

/* TranInverse. */
/* ------------ */
   } else if ( !strcmp( attrib, "traninverse" ) ) {
      tran_inverse = astGetTranInverse( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", tran_inverse );
         result = getattrib_buff;
      }

/* If the attribute name was not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_getattrib)( this_object, attrib, status );
   }

/* Return the result. */
   return result;
}

static int GetIsLinear( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astGetIsLinear

*  Purpose:
*     Determine if a Mapping is an instance of a linear Mapping class.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astGetIsLinear( AstMapping *this )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns a value indicating whether a Mapping is
*     a member of a class of linear Mappings. The base Mapping class
*     returns a value of zero. Linear Mapping classes should over-ride
*     this function to return a non-zero value.

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     One if the Mapping is a member of a linear Mapping class. Zero
*     otherwise.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/
   return 0;
}

static int GetNin( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astGetNin

*  Purpose:
*     Get the number of input coordinates for a Mapping.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astGetNin( AstMapping *this )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns the number of input coordinate values
*     required per point by a Mapping (i.e. the number of dimensions
*     of the space in which input points reside).

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     Number of coordinate values required.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   int invert;                   /* Invert attribute value */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Determine if the Mapping has been inverted. */
   invert = astGetInvert( this );

/* Obtain the Nin value. */
   if ( astOK ) result = invert ? this->nout : this->nin;

/* Return the result. */
   return result;
}

static int GetNout( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astGetNout

*  Purpose:
*     Get the number of output coordinates for a Mapping.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astGetNout( AstMapping *this )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns the number of output coordinate values
*     generated per point by a Mapping (i.e. the number of dimensions
*     of the space in which output points reside).

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     Number of coordinate values generated.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   int invert;                   /* Invert attribute value */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Determine if the Mapping has been inverted. */
   invert = astGetInvert( this );

/* Obtain the Nout value. */
   if ( astOK ) result = invert ? this->nin : this->nout;

/* Return the result. */
   return result;
}

static int GetTranForward( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astGetTranForward

*  Purpose:
*     Determine if a Mapping defines a forward coordinate transformation.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astGetTranForward( AstMapping *this )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns a value indicating whether a Mapping is
*     able to perform a coordinate transformation in the "forward"
*     direction.

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     Zero if the forward coordinate transformation is not defined, or
*     1 if it is.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   int invert;                   /* Mapping inverted? */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Determine if the Mapping has been inverted. */
   invert = astGetInvert( this );

/* If OK, obtain the result. */
   if ( astOK ) result = invert ? this->tran_inverse : this->tran_forward;

/* Return the result. */
   return result;
}

static int GetTranInverse( AstMapping *this, int *status ) {
/*
*+
*  Name:
*     astGetTranInverse

*  Purpose:
*     Determine if a Mapping defines an inverse coordinate transformation.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astGetTranInverse( AstMapping *this )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function returns a value indicating whether a Mapping is
*     able to perform a coordinate transformation in the "inverse"
*     direction.

*  Parameters:
*     this
*        Pointer to the Mapping.

*  Returned Value:
*     Zero if the inverse coordinate transformation is not defined, or
*     1 if it is.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   int invert;                   /* Mapping inverted? */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Determine if the Mapping has been inverted. */
   invert = astGetInvert( this );

/* If OK, obtain the result. */
   if ( astOK ) result = invert ? this->tran_forward : this->tran_inverse;

/* Return the result. */
   return result;
}

static void GlobalBounds( MapData *mapdata, double *lbnd, double *ubnd,
                          double xl[], double xu[], int *status ) {
/*
*  Name:
*     GlobalBounds

*  Purpose:
*     Estimate global coordinate bounds for a Mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void GlobalBounds( MapData *mapdata, double *lbnd, double *ubnd,
*                        double xl[], double xu[], int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function estimates the global lower and upper bounds of a
*     Mapping function within a constrained region of its input
*     coordinate space. It uses a robust global optimisation algorithm
*     based on the selection of pseudo-random starting positions,
*     followed by the location of local minima and maxima using the
*     downhill (or uphill) simplex method. The algorithm will cope
*     with the case where there are several competing minima (or
*     maxima) with nearly equal values. It attempts to locate the
*     global bounds to full machine precision when possible.

*  Parameters:
*     mapdata
*        Pointer to a MapData structure describing the Mapping
*        function, its coordinate constraints, etc.
*     lbnd
*        Pointer to a double.  On entry, this should contain a
*        previously-obtained upper limit on the global lower bound, or
*        AST__BAD if no such limit is available. On exit, it will be
*        updated with a new estimate of the global lower bound, if a
*        better one has been found.
*     ubnd
*        Pointer to a double.  On entry, this should contain a
*        previously-obtained lower limit on the global upper bound, or
*        AST__BAD if no such limit is available. On exit, it will be
*        updated with a new estimate of the global upper bound, if a
*        better one has been found.
*     xl
*        Pointer to an array of double, with one element for each
*        input coordinate. On entry, if *lbnd is not equal to AST__OK,
*        this should contain the input coordinates of a point at which
*        the Mapping function takes the value *lbnd. On exit, this
*        function returns the position of a (not necessarily unique)
*        input point at which the Mapping function takes the value of
*        the new global lower bound.  This array is not altered if an
*        improved estimate of the global lower bound cannot be found.
*     xu
*        Pointer to an array of double, with one element for each
*        input coordinate. On entry, if *ubnd is not equal to AST__OK,
*        this should contain the input coordinates of a point at which
*        the Mapping function takes the value *ubnd. On exit, this
*        function returns the position of a (not necessarily unique)
*        input point at which the Mapping function takes the value of
*        the new global upper bound.  This array is not altered if an
*        improved estimate of the global upper bound cannot be found.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - The efficiency of this function will usually be improved if
*     previously-obtained estimates of the extrema and their locations
*     are provided.
*     - The values returned via "lbnd", "ubnd", "xl" and "xu" will be
*     set to the value AST__BAD if this function should fail for any
*     reason. Their initial values on entry will not be altered if the
*     function is invoked with the global error status set.
*/

/* Local Constants: */
   const double default_acc = 3.0e-5; /* Default convergence accuracy */
   const int maxiter = 10000;    /* Maximum number of iterations */
   const int minsame = 5;        /* Minimum no. consistent extrema required */
   const int nbatch = 32;        /* No. function samples obtained per batch */

/* Local Variables: */
   AstPointSet *pset_in;         /* Input PointSet for batch transformation */
   AstPointSet *pset_out;        /* Output PointSet for batch transformation */
   double **ptr_in;              /* Pointer to batch input coordinates */
   double **ptr_out;             /* Pointer to batch output coordinates */
   double *active_hi;            /* Estimated upper limits of active region */
   double *active_lo;            /* Estimated lower limits of active region */
   double *sample_hi;            /* Upper limits of sampled region */
   double *sample_lo;            /* Lower limits of sampled region */
   double *sample_width;         /* Nominal widths of sampled region */
   double *x;                    /* Pointer to array of coordinates */
   double acc;                   /* Convergence accuracy for finding maximum */
   double active_width;          /* Estimated width of active region */
   double new_max;               /* Value of new local maximum */
   double new_min;               /* Value of new local minimum */
   double oversize;              /* Over-size factor for sampled region */
   double random;                /* Pseudo-random number */
   int bad;                      /* Transformed position is bad? */
   int batch;                    /* Next element to use in position batch */
   int coord;                    /* Loop counter for coordinates */
   int done_max;                 /* Satisfactory global maximum found? */
   int done_min;                 /* Satisfactory global minimum found? */
   int iter;                     /* Loop counter for iterations */
   int ncoord;                   /* Number of coordinates in search space */
   int nmax;                     /* Number of local maxima found */
   int nmin;                     /* Number of local minima found */
   int nsame_max;                /* Number of equivalent local maxima found */
   int nsame_min;                /* Number of equivalent local minima found */
   long int seed = 1776655449;   /* Arbitrary pseudo-random number seed */

/* Check the global error status */
   if ( !astOK ) return;

/* Initialise. */
   done_max = 0;
   done_min = 0;
   nmax = 0;
   nmin = 0;
   nsame_max = 0;
   nsame_min = 0;
   pset_in = NULL;
   pset_out = NULL;
   ptr_in = NULL;
   ptr_out = NULL;
   oversize = 0;
   bad = 0;

/* Extract the number of input coordinates for the Mapping function
   and allocate workspace. */
   ncoord = mapdata->nin;
   active_hi = astMalloc( sizeof( double ) * (size_t) ncoord );
   active_lo = astMalloc( sizeof( double ) * (size_t) ncoord );
   sample_hi = astMalloc( sizeof( double ) * (size_t) ncoord );
   sample_lo = astMalloc( sizeof( double ) * (size_t) ncoord );
   sample_width = astMalloc( sizeof( double ) * (size_t) ncoord );
   x = astMalloc( sizeof( double ) * (size_t) ncoord );
   if ( astOK ) {

/* Calculate the factor by which the size of the region we sample will
   exceed the size of the Mapping function's active region (the region
   where the transformed coordinates are non-bad) in each
   dimension. This is chosen so that the volume ratio will be 2. */
      oversize = pow( 2.0, 1.0 / (double) ncoord );

/* Initialise the limits of the active region to unknown. */
      for ( coord = 0; coord < ncoord; coord++ ) {
         active_lo[ coord ] = DBL_MAX;;
         active_hi[ coord ] = -DBL_MAX;

/* Initialise the nominal widths of the sampled region to be the
   actual widths of the search region times the over-size factor. */
         sample_width[ coord ] = ( mapdata->ubnd[ coord ] -
                                   mapdata->lbnd[ coord ] ) * oversize;

/* Initialise the sampled region to match the search region. */
         sample_lo[ coord ] = mapdata->lbnd[ coord ];
         sample_hi[ coord ] = mapdata->ubnd[ coord ];
      }

/* Set up position buffer. */
/* ======================= */
/* Create two PointSets to act as buffers to hold a complete batch of
   input and output coordinates. Obtain pointers to their coordinate
   arrays. */
      pset_in = astPointSet( nbatch, ncoord, "", status );
      pset_out = astPointSet( nbatch, mapdata->nout, "", status );
      ptr_in = astGetPoints( pset_in );
      ptr_out = astGetPoints( pset_out );

/* Initialise the next element to be used in the position buffer to
   indicate that the buffer is initially empty. */
      batch = nbatch;
   }

/* Define a macro to fill the position buffer with a set of
   pseudo-random positions and to transform them. */
#define FILL_POSITION_BUFFER {\
\
/* We first generate a suitable volume over which to distribute the\
   batch of pseudo-random positions. Initially, this will be the\
   entire search volume, but if we find that the only non-bad\
   transformed coordinates we obtain are restricted to a small\
   sub-region of this input volume, then we reduce the sampled volume\
   so as to concentrate more on the active region. */\
\
/* Loop through each input coordinate, checking that at least one\
   non-bad transformed point has been obtained. If not, we do not\
   adjust the sampled volume, as we do not yet know where the active\
   region lies. */\
   for ( coord = 0; coord < ncoord; coord++ ) {\
      if ( active_hi[ coord ] >= active_lo[ coord ] ) {\
\
/* Estimate the width of the active region from the range of input\
   coordinates that have so far produced non-bad transformed\
   coordinates. */\
         active_width = active_hi[ coord ] - active_lo[ coord ];\
\
/* If the current width of the sampled volume exceeds this estimate by\
   more than the required factor, then reduce the width of the sampled\
   volume. The rate of reduction is set so that the volume of the\
   sampled region can halve with every fourth batch of positions. */\
         if ( ( active_width * oversize ) < sample_width[ coord ] ) {\
            sample_width[ coord ] /= pow( oversize, 0.25 );\
\
/* If the width of the sampled volume does not exceed that of the\
   known active region by the required factor, then adjust it so that\
   it does. Note that we must continue to sample some points outside\
   the known active region in case we have missed any (in which case\
   the sampled region will expand again to include them). */\
         } else if ( ( active_width * oversize ) > sample_width[ coord ] ) {\
            sample_width[ coord ] = active_width * oversize;\
         }\
\
/* Calculate the lower and upper bounds on the sampled volume, using\
   the new width calculated above and centring it on the active\
   region, as currently known. */\
         sample_lo[ coord ] = ( active_lo[ coord ] + active_hi[ coord ] -\
                                sample_width[ coord ] ) * 0.5;\
         sample_hi[ coord ] = ( active_lo[ coord ] + active_hi[ coord ] +\
                                sample_width[ coord ] ) * 0.5;\
\
/* Ensure that the sampled region does not extend beyond the original\
   search region. */\
         if ( sample_lo[ coord ] < mapdata->lbnd[ coord ] ) {\
            sample_lo[ coord ] = mapdata->lbnd[ coord ];\
         }\
         if ( sample_hi[ coord ] > mapdata->ubnd[ coord ] ) {\
            sample_hi[ coord ] = mapdata->ubnd[ coord ];\
         }\
      }\
   }\
\
/* Having determined the size of the sampled volume, create a batch of\
   pseudo-random positions uniformly distributed within it. */\
   for ( batch = 0; batch < nbatch; batch++ ) {\
      for ( coord = 0; coord < ncoord; coord++ ) {\
         random = Random( &seed, status );\
         ptr_in[ coord ][ batch ] = sample_lo[ coord ] * random +\
                                    sample_hi[ coord ] * ( 1.0 - random );\
      }\
   }\
\
/* Transform these positions. We process them in a single batch in\
   order to minimise the overheads in doing this. */\
   (void) astTransform( mapdata->mapping, pset_in, mapdata->forward,\
                        pset_out );\
\
/* Indicate that the position buffer is now full. */\
   batch = 0;\
}

/* Fill the position buffer using the above macro. (Note that because
   we do not yet have an estimate of the size of the active region,
   this does not change the sampled region size from our earlier
   initialised values. */
   FILL_POSITION_BUFFER;

/* Iterate. */
/* ======== */
/* Loop to perform up to "maxiter" iterations to estimate the global
   minimum and maximum. */
   for ( iter = 0; astOK && ( iter < maxiter ); iter++ ) {

/* Determine the search accuracy. */
/* ============================== */
/* Decide the accuracy to which local extrema should be found. The
   intention here is to optimise performance, especially where one
   extremum lies near zero and so could potentially be found to
   unnecessarily high precision. If we make a mis-assumption (the code
   below is not fool-proof), we will slow things down for this
   iteration, but the error will be corrected in future iterations
   once better estimates are available. */

/* If we have no current estimate of either global extremum, we assume
   the values we eventually obtain will be of order unity and required
   to the default accuracy. */
      acc = default_acc;

/* If we already have an estimate of both global extrema, we set the
   accuracy level so that the difference between them will be known to
   the default accuracy. */
      if ( ( *lbnd != AST__BAD ) && ( *ubnd != AST__BAD ) ) {
         acc = fabs( *ubnd - *lbnd ) * default_acc;

/* If we have an estimate of only one global extremum, we assume that
   the difference between the two global extrema will eventually be of
   the same order as the estimate we currently have, so long as this
   is not less than unity. */
      } else if ( *lbnd != AST__BAD ) {
         if ( fabs( *lbnd ) > 1.0 ) acc = fabs( *lbnd) * default_acc;
      } else if ( *ubnd != AST__BAD ) {
         if ( fabs( *ubnd ) > 1.0 ) acc = fabs( *ubnd) * default_acc;
      }

/* Search for a new local minimum. */
/* =============================== */
/* If we are still searching for the global minimum, then obtain a set
   of starting coordinates from which to find a new local minimum. */
      if ( !done_min ) {

/* On the first iteration, start searching at the position where the
   best estimate of the global minimum (if any) has previously been
   found. We know that this produces non-bad transformed
   coordinates. */
         bad = 0;
         if ( !iter && ( *lbnd != AST__BAD ) ) {
            for ( coord = 0; coord < ncoord; coord++ ) {
               x[ coord ] = xl[ coord ];
            }

/* Otherwise, if no estimate of the global minimum is available, then
   start searching at the position where the best estimate of the
   global maximum (if any) has been found. This may be a long way from
   a local minimum, but at least it will yield a non-bad value for the
   Mapping function, so some sort of estimate of the global minimum
   will be obtained. This is important in cases where finding the
   active region of the function is the main problem. Note that this
   condition can only occur once, since the global minimum will have
   an estimate on the next iteration. */
         } else if ( ( *lbnd == AST__BAD ) && ( *ubnd != AST__BAD ) ) {
            for ( coord = 0; coord < ncoord; coord++ ) {
               x[ coord ] = xu[ coord ];
            }

/* Having exhausted the above possibilities, we use pseudo-random
   starting positions which are uniformly distributed throughout the
   search volume. First check to see if the buffer containing such
   positions is empty and refill it if necessary. */
         } else {
            if ( batch >= nbatch ) FILL_POSITION_BUFFER;

/* Test the next available set of output (transformed) coordinates in
   the position buffer to see if they are bad. */
            if ( astOK ) {
               for ( coord = 0; coord < mapdata->nout; coord++ ) {
                  bad = ( ptr_out[ coord ][ batch ] == AST__BAD );
                  if ( bad ) break;
               }

/* If not, we have a good starting position for finding a local
   minimum, so extract the corresponding input coordinates. */
               if ( !bad ) {
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     x[ coord ] = ptr_in[ coord ][ batch ];
                  }
               }

/* Increment the position buffer location. */
               batch++;
            }
         }

/* If we do not have a good starting position, we can't do anything
   more on this iteration. A new position will be obtained and tested
   on the next iteration and this (we hope) will eventually identify a
   suitable starting point. */
         if ( astOK && !bad ) {

/* Form estimates of the lower and upper limits of the active region
   from the starting positions used. */
            for ( coord = 0; coord < ncoord; coord++ ) {
               if ( x[ coord ] < active_lo[ coord ] ) {
                  active_lo[ coord ] = x[ coord ];
               }
               if ( x[ coord ] > active_hi[ coord ] ) {
                  active_hi[ coord ] = x[ coord ];
               }
            }

/* Indicate that the Mapping function should be negated (because we
   want a local minimum) and then search for a local maximum in this
   negated function. If the result is non-bad (as it should always be,
   barring an error), then negate it to obtain the value of the local
   minimum found. */
            mapdata->negate = 1;
            new_min = LocalMaximum( mapdata, acc, 0.01, x, status );
            if ( new_min != AST__BAD ) {
               new_min = -new_min;

/* Update the estimates of the lower and upper bounds of the active
   region to take account of where the minimum was found. */
               for ( coord = 0; coord < ncoord; coord++ ) {
                  if ( x[ coord ] < active_lo[ coord ] ) {
                     active_lo[ coord ] = x[ coord ];
                  }
                  if ( x[ coord ] > active_hi[ coord ] ) {
                     active_hi[ coord ] = x[ coord ];
                  }
               }

/* Count the number of times we successfully locate a local minimum
   (ignoring the fact they might all be the same one). */
               nmin++;

/* Update the global minimum. */
/* ========================== */
/* If this is the first estimate of the global minimum, then set to
   one the count of the number of consecutive iterations where this
   estimate remains unchanged. Store the minimum value and its
   position. */
               if ( *lbnd == AST__BAD ) {
                  nsame_min = 1;
                  *lbnd = new_min;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xl[ coord ] = x[ coord ];
                  }

/* Otherwise, test if this local minimum is lower than the previous
   estimate of the global minimum. If so, then reset the count of
   unchanged estimates of the global mimimum to one if the difference
   exceeds the accuracy with which the minimum was found (i.e. if we
   have found a significantly different minimum). Otherwise, just
   increment this count (because we have found the same minimum but by
   chance with slightly improved accuracy). Store the new minimum and
   its position. */
               } else if ( new_min < *lbnd ) {
                  nsame_min = ( ( *lbnd - new_min ) > acc ) ? 1 :
                                                              nsame_min + 1;
                  *lbnd = new_min;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xl[ coord ] = x[ coord ];
                  }

/* If the latest local minimum is no improvement on previous estimates
   of the global minimum, then increment the count of unchanged
   estimates of the global mimimum, but do not save the new one. */
               } else {
                  nsame_min++;
               }

/* Determine if a satisfactory estimate of the global minimum has been
   obtained.  It has if the number of consecutive local minima which
   have not significantly improved the estimate is at least equal to
   "minsame", and at least 30% of the total number of local minima
   found. */
               if ( ( nsame_min >= minsame ) &&
                    ( nsame_min >= (int) ( 0.3f * (float) nmin + 0.5f ) ) ) {
                  done_min = 1;
               }
            }
         }
      }

/* Search for a new local maximum. */
/* =============================== */
/* Now repeat all of the above to find a new local maximum which
   estimates the global maximum. */
      if ( !done_max ) {

/* Choose a suitable starting position, based on one already available
   if appropriate. */
         if ( !iter && ( *ubnd != AST__BAD ) ) {
            for ( coord = 0; coord < ncoord; coord++ ) {
               x[ coord ] = xu[ coord ];
            }

         } else if ( ( *ubnd == AST__BAD ) && ( *lbnd != AST__BAD ) ) {
            for ( coord = 0; coord < ncoord; coord++ ) {
               x[ coord ] = xl[ coord ];
            }

/* Otherwise use a pseudo-random position, refilling the position
   buffer if necessary. Check if the transformed coordinates are
   bad. */
         } else {
            if ( batch >= nbatch ) FILL_POSITION_BUFFER;
            if ( astOK ) {
               for ( coord = 0; coord < mapdata->nout; coord++ ) {
                  bad = ( ptr_out[ coord ][ batch ] == AST__BAD );
                  if ( bad ) break;
               }
               if ( !bad ) {
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     x[ coord ] = ptr_in[ coord ][ batch ];
                  }
               }
               batch++;
            }
         }

/* If the coordinates are OK, update the active region limits. */
         if ( astOK && !bad ) {
            for ( coord = 0; coord < ncoord; coord++ ) {
               if ( x[ coord ] < active_lo[ coord ] ) {
                  active_lo[ coord ] = x[ coord ];
               }
               if ( x[ coord ] > active_hi[ coord ] ) {
                  active_hi[ coord ] = x[ coord ];
               }
            }

/* Find a local maximum in the Mapping function. */
            mapdata->negate = 0;
            new_max = LocalMaximum( mapdata, acc, 0.01, x, status );
            if ( new_max != AST__BAD ) {

/* Use the result to further update the active region limits. */
               for ( coord = 0; coord < ncoord; coord++ ) {
                  if ( x[ coord ] < active_lo[ coord ] ) {
                     active_lo[ coord ] = x[ coord ];
                  }
                  if ( x[ coord ] > active_hi[ coord ] ) {
                     active_hi[ coord ] = x[ coord ];
                  }
               }

/* Count the number of local maxima found. */
               nmax++;

/* Update the estimate of the global maximum. */
               if ( *ubnd == AST__BAD ) {
                  nsame_max = 1;
                  *ubnd = new_max;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xu[ coord ] = x[ coord ];
                  }

               } else if ( new_max > *ubnd ) {
                  nsame_max = ( ( new_max - *ubnd ) > acc ) ? 1 :
                                                              nsame_max + 1;
                  *ubnd = new_max;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xu[ coord ] = x[ coord ];
                  }

               } else {
                  nsame_max++;
               }

/* Test for a satisfactory global maximum estimate. */
               if ( ( nsame_max >= minsame ) &&
                    ( nsame_max >= (int) ( 0.3f * (float) nmax + 0.5 ) ) ) {
                  done_max = 1;
               }
            }
         }
      }

/* Quit iterating once both the global minimum and the global maximum
   have been found. */
      if ( done_min && done_max ) break;
   }

/* Free workspace. */
   active_hi = astFree( active_hi );
   active_lo = astFree( active_lo );
   sample_hi = astFree( sample_hi );
   sample_lo = astFree( sample_lo );
   sample_width = astFree( sample_width );
   x = astFree( x );

/* Annul temporary PointSets. */
   pset_in = astAnnul( pset_in );
   pset_out = astAnnul( pset_out );

/* If the global minimum has been found, attempt to polish the result
   to machine precision by requesting that it be found with an
   accuracy tolerance of zero (subject to the maximum number of
   iterations that LocalMaximum will perform,). */
   if ( astOK ) {
      if ( *lbnd != AST__BAD ) {
         mapdata->negate = 1;
         *lbnd = LocalMaximum( mapdata, 0.0, sqrt( DBL_EPSILON ), xl, status );
         if ( *lbnd != AST__BAD ) *lbnd = - *lbnd;
      }

/* Similarly polish the estimate of the global maximum. */
      if ( *ubnd != AST__BAD ) {
         mapdata->negate = 0;
         *ubnd = LocalMaximum( mapdata, 0.0, sqrt( DBL_EPSILON ), xu, status );
      }

/* If either extremum could not be found, then report an error. */
      if ( ( *lbnd == AST__BAD ) || ( *ubnd == AST__BAD ) ) {
         astError( AST__MBBNF, "astMapBox(%s): No valid output coordinates "
                   "(after %d test points).", status, astGetClass( mapdata->mapping ),
                   2 * maxiter );
      }

/* If an error occurred, then return bad extremum values and
   coordinates. */
      if ( !astOK ) {
         *lbnd = AST__BAD;
         *ubnd = AST__BAD;
         for ( coord = 0; coord < ncoord; coord++ ) {
            xl[ coord ] = AST__BAD;
            xu[ coord ] = AST__BAD;
         }
      }
   }

/* Undefine macros local to this function. */
#undef FILL_POSITION_BUFFER
}

void astInitMappingVtab_(  AstMappingVtab *vtab, const char *name, int *status ) {
/*
*+
*  Name:
*     astInitMappingVtab

*  Purpose:
*     Initialise a virtual function table for a Mapping.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "mapping.h"
*     void astInitMappingVtab( AstMappingVtab *vtab, const char *name )

*  Class Membership:
*     Mapping vtab initialiser.

*  Description:
*     This function initialises the component of a virtual function
*     table which is used by the Mapping class.

*  Parameters:
*     vtab
*        Pointer to the virtual function table. The components used by
*        all ancestral classes will be initialised if they have not already
*        been initialised.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the virtual function table belongs (it
*        is this pointer value that will subsequently be returned by the Object
*        astClass function).
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstObjectVtab *object;        /* Pointer to Object component of Vtab */

/* Check the local error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Initialize the component of the virtual function table used by the
   parent class. */
   astInitObjectVtab( (AstObjectVtab *) vtab, name );

/* Store a unique "magic" value in the virtual function table. This
   will be used (by astIsAMapping) to determine if an object belongs
   to this class.  We can conveniently use the address of the (static)
   class_check variable to generate this unique value. */
   vtab->id.check = &class_check;
   vtab->id.parent = &(((AstObjectVtab *) vtab)->id);

/* Initialise member function pointers. */
/* ------------------------------------ */
/* Store pointers to the member functions (implemented here) that provide
   virtual methods for this class. */
#define VTAB_GENERIC(X) \
   vtab->Resample##X = Resample##X;

VTAB_GENERIC(B)
VTAB_GENERIC(D)
VTAB_GENERIC(F)
VTAB_GENERIC(I)
VTAB_GENERIC(K)
VTAB_GENERIC(L)
VTAB_GENERIC(S)
VTAB_GENERIC(UB)
VTAB_GENERIC(UI)
VTAB_GENERIC(UK)
VTAB_GENERIC(UL)
VTAB_GENERIC(US)

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
VTAB_GENERIC(LD)
#endif

#undef VTAB_GENERIC

#define VTAB_GENERIC(X) \
   vtab->Rebin##X = Rebin##X; \
   vtab->RebinSeq##X = RebinSeq##X;

VTAB_GENERIC(D)
VTAB_GENERIC(F)
VTAB_GENERIC(I)
VTAB_GENERIC(B)
VTAB_GENERIC(UB)

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
VTAB_GENERIC(LD)
#endif

#undef VTAB_GENERIC


   vtab->ClearInvert = ClearInvert;
   vtab->ClearReport = ClearReport;
   vtab->Decompose = Decompose;
   vtab->DoNotSimplify = DoNotSimplify;
   vtab->GetInvert = GetInvert;
   vtab->GetIsLinear = GetIsLinear;
   vtab->GetIsSimple = GetIsSimple;
   vtab->GetNin = GetNin;
   vtab->GetNout = GetNout;
   vtab->GetReport = GetReport;
   vtab->GetTranForward = GetTranForward;
   vtab->GetTranInverse = GetTranInverse;
   vtab->Invert = Invert;
   vtab->LinearApprox = LinearApprox;
   vtab->MapBox = MapBox;
   vtab->MapList = MapList;
   vtab->MapMerge = MapMerge;
   vtab->MapSplit = MapSplit;
   vtab->QuadApprox = QuadApprox;
   vtab->Rate = Rate;
   vtab->ReportPoints = ReportPoints;
   vtab->RemoveRegions = RemoveRegions;
   vtab->SetInvert = SetInvert;
   vtab->SetReport = SetReport;
   vtab->Simplify = Simplify;
   vtab->TestInvert = TestInvert;
   vtab->TestReport = TestReport;
   vtab->Tran1 = Tran1;
   vtab->Tran2 = Tran2;
   vtab->TranGrid = TranGrid;
   vtab->TranN = TranN;
   vtab->TranP = TranP;
   vtab->Transform = Transform;

/* Save the inherited pointers to methods that will be extended, and
   replace them with pointers to the new member functions. */
   object = (AstObjectVtab *) vtab;

   parent_clearattrib = object->ClearAttrib;
   object->ClearAttrib = ClearAttrib;
   parent_getattrib = object->GetAttrib;
   object->GetAttrib = GetAttrib;
   parent_setattrib = object->SetAttrib;
   object->SetAttrib = SetAttrib;
   parent_testattrib = object->TestAttrib;
   object->TestAttrib = TestAttrib;
   parent_equal = object->Equal;
   object->Equal = Equal;

/* Declare the destructor, copy constructor and dump function. */
   astSetDelete( vtab, Delete );
   astSetCopy( vtab, Copy );
   astSetDump( vtab, Dump, "Mapping", "Mapping between coordinate systems" );

/* If we have just initialised the vtab for the current class, indicate
   that the vtab is now initialised, and store a pointer to the class
   identifier in the base "object" level of the vtab. */
   if( vtab == &class_vtab ) {
      class_init = 1;
      astSetVtabClassIdentifier( vtab, &(vtab->id) );
   }
}

/*
*  Name:
*     InterpolateKernel1<X>

*  Purpose:
*     Resample a data grid, using a 1-d interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int InterpolateKernel1<X>( AstMapping *this, int ndim_in,
*                                const int *lbnd_in, const int *ubnd_in,
*                                const <Xtype> *in, const <Xtype> *in_var,
*                                int npoint, const int *offset,
*                                const double *const *coords,
*                                void (* kernel)( double, const double [], int,
*                                                 double *, int * ),
*                                void (* fkernel)( double, const double [], int,
*                                                  double * ),
*                                int neighb, const double *params, int flags,
*                                <Xtype> badval,
*                                <Xtype> *out, <Xtype> *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which resample a rectangular input
*     grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each output
*     grid point may be mapped on to a position in the input grid in
*     an arbitrary way. The input and output grids may have any number
*     of dimensions, not necessarily equal.
*
*     Where the positions given do not correspond with a pixel centre
*     in the input grid, interpolation is performed using a weighted
*     sum of the surrounding pixel values. The weights are determined
*     by a separable kernel which is the product of a 1-dimensional
*     kernel function evaluated along each input dimension. A pointer
*     should be supplied to the 1-dimensional kernel function to be
*     used.

*  Parameters:
*     this
*        Pointer to the Mapping being used in the resampling operation
*        (this is only used for constructing error messages).
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input grid, its extent along a particular
*        (i'th) dimension being ubnd_in[i]-lbnd_in[i]+1 (assuming "i"
*        is zero-based). They also define the input grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be resampled (with an element
*        for each pixel in the input grid). The numerical type of
*        these data should match the function used, as given by the
*        suffix on the function name. The storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
*        (i.e. Fortran array storage order).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     npoint
*        The number of points at which the input grid is to be
*        resampled.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each output point, this array should contain the zero-based
*        offset in the output array(s) (i.e. the "out" and,
*        optionally, the "out_var" arrays) at which the resampled
*        output value(s) should be stored.
*     coords
*        An array of pointers to double, with "ndim_in"
*        elements. Element "coords[coord]" should point at the first
*        element of an array of double (with "npoint" elements) which
*        contains the values of coordinate number "coord" for each
*        interpolation point. The value of coordinate number "coord"
*        for interpolation point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices to be
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding output data (and
*        variance) will be set to the value given by "badval" (unles the
*        AST__NOBAD flag is specified).
*     kernel
*        Pointer to the 1-dimensional kernel function to be used.
*     fkernel
*        Pointer to the 1-dimensional kernel function to be used with no
*        trailing status argument. This is only used if "kernel" is NULL.
*     neighb
*        The number of neighbouring pixels in each dimension (on each
*        side of the interpolation position) which are to contribute
*        to the interpolated value. This value should be at least 1.
*     params
*        Pointer to an optional array of parameter values to be passed
*        to the interpolation kernel function. If no parameters are
*        required by this function, then a NULL pointer may be
*        supplied.
*     flags
*        The bitwise OR of a set of flag values which provide
*        additional control over the resampling operation.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. Unles the AST__NOBAD flag is specified in "flags", the
*        same value will also be used to flag any output array elements
*        for which resampled values could not be obtained.  The output
*        arrays(s) may be flagged with this value whether or not the
*        AST__USEBAD flag is set (the function return value indicates
*        whether any such values have been produced).
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned. Note
*        that details of how the output grid maps on to this array
*        (e.g. the storage order, number of dimensions, etc.) is
*        arbitrary and is specified entirely by means of the "offset"
*        array. The "out" array should therefore contain sufficient
*        elements to accommodate the "offset" values supplied.  There
*        is no requirement that all elements of the "out" array should
*        be assigned values, and any which are not addressed by the
*        contents of the "offset" array will be left unchanged.
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given. It is addressed in
*        exactly the same way (via the "offset" array) as the "out"
*        array. The values returned are estimates of the statistical
*        variance of the corresponding values in the "out" array, on
*        the assumption that all errors in input grid values (in the
*        "in" array) are statistically independent and that their
*        variance estimates (in the "in_var" array) may simply be
*        summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.

*  Returned Value:
*     The number of output grid points for which no valid output value
*     could be obtained.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*     - A value of zero will be returned if any of these functions is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*/
/* Define macros to implement the function for a specific data
   type. */
#define MAKE_INTERPOLATE_KERNEL1(X,Xtype,Xfloating,Xfloattype,Xsigned) \
static int InterpolateKernel1##X( AstMapping *this, int ndim_in, \
                                  const int *lbnd_in, const int *ubnd_in, \
                                  const Xtype *in, const Xtype *in_var, \
                                  int npoint, const int *offset, \
                                  const double *const *coords, \
                                  void (* kernel)( double, const double [], \
                                                   int, double *, int * ), \
                                  void (* fkernel)( double, const double [], \
                                                    int, double * ), \
                                  int neighb, const double *params, \
                                  int flags, Xtype badval, \
                                  Xtype *out, Xtype *out_var, int *status ) { \
\
/* Local Variables: */ \
   astDECLARE_GLOBALS            /* Thread-specific data */ \
   Xfloattype hi_lim;            /* Upper limit on output values */ \
   Xfloattype lo_lim;            /* Lower limit on output values */ \
   Xfloattype sum;               /* Weighted sum of pixel data values */ \
   Xfloattype sum_var;           /* Weighted sum of pixel variance values */ \
   Xfloattype val;               /* Data value to be assigned to output */ \
   Xfloattype val_var;           /* Variance to be assigned to output */ \
   Xfloattype wtsum;             /* Sum of weight values */ \
   Xfloattype wtsum_sq;          /* Square of sum of weights */ \
   Xtype var;                    /* Variance value */ \
   double **wtptr;               /* Pointer to array of weight pointers */ \
   double **wtptr_last;          /* Array of highest weight pointer values */ \
   double *kval;                 /* Pointer to array of kernel values */ \
   double *wtprod;               /* Accumulated weight value array pointer */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double pixwt;                 /* Weight to apply to individual pixel */ \
   double wt_y;                  /* Value of y-dependent pixel weight */ \
   double x;                     /* x coordinate value */ \
   double xmax;                  /* x upper limit */ \
   double xmin;                  /* x lower limit */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   double ymax;                  /* y upper limit */ \
   double ymin;                  /* y lower limit */ \
   int *hi;                      /* Pointer to array of upper indices */ \
   int *lo;                      /* Pointer to array of lower indices */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int bad_var;                  /* Output variance bad? */ \
   int done;                     /* All pixel indices done? */ \
   int hi_x;                     /* Upper pixel index (x dimension) */ \
   int hi_y;                     /* Upper pixel index (y dimension) */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ii;                       /* Loop counter for dimensions */ \
   int ix;                       /* Pixel index in input grid x dimension */ \
   int ixn;                      /* Pixel index in input grid (n-d) */ \
   int iy;                       /* Pixel index in input grid y dimension */ \
   int kerror;                   /* Error signalled by kernel function? */ \
   int lo_x;                     /* Lower pixel index (x dimension) */ \
   int lo_y;                     /* Lower pixel index (y dimension) */ \
   int nobad;                    /* Was the AST__NOBAD flag set? */ \
   int off1;                     /* Input pixel offset due to y index */ \
   int off_in;                   /* Offset to input pixel */ \
   int off_out;                  /* Offset to output pixel */ \
   int pixel;                    /* Offset to input pixel containing point */ \
   int point;                    /* Loop counter for output points */ \
   int result;                   /* Result value to return */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int ystride;                  /* Stride along input grid y dimension */ \
\
/* Initialise. */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Get a pointer to a structure holding thread-specific global data values */ \
   astGET_GLOBALS(this); \
\
/* Further initialisation. */ \
   kerror = 0; \
   sum_var = 0; \
   val = 0; \
   val_var = 0; \
   wtsum = 0; \
   bad = 0; \
   bad_var = 0; \
   sum = 0.0; \
\
/* Determine if we are processing bad pixels or variances. */ \
   nobad = flags & AST__NOBAD; \
   usebad = flags & AST__USEBAD; \
   usevar = in_var && out_var; \
\
/* Set up limits for checking output values to ensure that they do not \
   overflow the range of the data type being used. */ \
   lo_lim = LO_##X; \
   hi_lim = HI_##X; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_in == 1 ) { \
\
/* Calculate the coordinate limits of the input grid. */ \
      xmin = (double) lbnd_in[ 0 ] - 0.5; \
      xmax = (double) ubnd_in[ 0 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
               } \
            } \
         } \
\
/* Four more cases as above, but this time with the AST__NOBAD flag \
   un-set. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
               } \
            } \
         } \
      } \
\
/* Exit point on error in kernel function */ \
      Kernel_Error_1d: ; \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_in == 2 ) { \
\
/* Allocate workspace. */ \
      kval = astMalloc( sizeof( double ) * (size_t) ( 2 * neighb ) ); \
      if ( astOK ) { \
\
/* Calculate the stride along the y dimension of the input grid. */ \
         ystride = ubnd_in[ 0 ] - lbnd_in[ 0 ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
         xmin = (double) lbnd_in[ 0 ] - 0.5; \
         xmax = (double) ubnd_in[ 0 ] + 0.5; \
         ymin = (double) lbnd_in[ 1 ] - 0.5; \
         ymax = (double) ubnd_in[ 1 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
         if ( nobad ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
                  } \
               } \
            } \
\
/* Another four cases, as above, but this time without the AST__NOBAD \
   flag. */ \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
                  } \
               } \
            } \
         } \
\
/* Exit point on error in kernel function */ \
         Kernel_Error_2d: ; \
      } \
\
/* Free the workspace. */ \
      kval = astFree( kval ); \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      hi = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      lo = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      kval = astMalloc( sizeof( double ) * (size_t) \
                                           ( 2 * neighb * ndim_in ) ); \
      wtprod = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      wtptr = astMalloc( sizeof( double * ) * (size_t) ndim_in ); \
      wtptr_last = astMalloc( sizeof( double * ) * (size_t) ndim_in ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the input grid. */ \
         for ( s = 1, idim = 0; idim < ndim_in; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_in[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_in[ idim ] + 0.5; \
         } \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
         if( nobad ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
                  } \
               } \
            } \
\
/* Another 4 cases as above, but this time with the AST__NOBAD flag \
   un-set. */ \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
                  } \
               } \
            } \
         } \
\
/* Exit point on error in kernel function */ \
         Kernel_Error_Nd: ;\
      } \
\
/* Free the workspace. */ \
      hi = astFree( hi ); \
      lo = astFree( lo ); \
      stride = astFree( stride ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
      kval = astFree( kval ); \
      wtprod = astFree( wtprod ); \
      wtptr = astFree( wtptr ); \
      wtptr_last = astFree( wtptr_last ); \
   } \
\
/* If an error occurred in the kernel function, then report a \
   contextual error message. */ \
   if ( kerror ) { \
      astError( astStatus, "astResample"#X"(%s): Error signalled by " \
                "user-supplied 1-d interpolation kernel.", status, \
                astGetClass( unsimplified_mapping ) ); \
   } \
\
/* If an error has occurred, clear the returned result. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
}

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 1-dimensional
   case. */
#define ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid, or is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If input bad pixels must be detected, then obtain the offset along \
   the input grid x dimension of the input pixel which contains the \
   current coordinate, and calculate this pixel's offset from the \
   start of the input array. */ \
      if ( Usebad ) { \
         pixel = (int) floor( x + 0.5 ) - lbnd_in[ 0 ]; \
\
/* Test if the pixel is bad. */ \
         bad = ( in[ pixel ] == badval ); \
      } \
\
/* If OK, calculate the lowest and highest indices (in the x \
   dimension) of the region of neighbouring pixels that will \
   contribute to the interpolated result. Constrain these values to \
   lie within the input grid. */ \
      if ( !bad ) { \
         ix = (int) floor( x ); \
         lo_x = MaxI( ix - neighb + 1, lbnd_in[ 0 ], status ); \
         hi_x = MinI( ix + neighb,     ubnd_in[ 0 ], status ); \
\
/* Initialise sums for forming the interpolated result. */ \
         sum = (Xfloattype) 0.0; \
         wtsum = (Xfloattype) 0.0; \
         if ( Usevar ) { \
            sum_var = (Xfloattype) 0.0; \
            bad_var = 0; \
         } \
\
/* Loop to inspect all the contributing pixels, calculating the offset \
   of each pixel from the start of the input array. */ \
         off_in = lo_x - lbnd_in[ 0 ]; \
         for ( ix = lo_x; ix <= hi_x; ix++, off_in++ ) { \
\
/* If necessary, test if the input pixel is bad. If not, calculate its \
   weight by evaluating the kernel function. */ \
            if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
               if( kernel ) { \
                  ( *kernel )( (double) ix - x, params, flags, &pixwt, status ); \
               } else { \
                  ( *fkernel )( (double) ix - x, params, flags, &pixwt ); \
               } \
\
/* Check for errors arising in the kernel function. */ \
               if ( !astOK ) { \
                  kerror = 1; \
                  goto Kernel_Error_1d; \
               } \
\
/* Form the weighted sums required for finding the interpolated \
   value. */ \
               sum += ( (Xfloattype) pixwt ) * ( (Xfloattype) in[ off_in ] ); \
               wtsum += (Xfloattype) pixwt; \
\
/* If a variance estimate is required and it still seems possible to \
   obtain one, then obtain the variance value associated with the \
   current input pixel. */ \
               if ( Usevar ) { \
                  if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                     var = in_var[ off_in ]; \
\
/* If necessary, test if this value is bad (if the data type is \
   signed, also check that it is not negative). */ \
                     if ( Usebad ) bad_var = ( var == badval ); \
                     CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If any bad input variance value is obtained, we cannot generate a \
   valid output variance estimate. Otherwise, form the sum needed to \
   calculate this estimate. */ \
                     if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                        sum_var += ( (Xfloattype) ( pixwt * pixwt ) ) * \
                                   ( (Xfloattype) var ); \
                     } \
                  } \
               } \
            } \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 2-dimensional
   case. */
#define ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid, or is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If not, then similarly obtain and test the y coordinate. */ \
      y = coords[ 1 ][ point ]; \
      bad = ( y < ymin ) || ( y >= ymax ) || ( y == AST__BAD ); \
      if ( !bad ) { \
\
/* If input bad pixels must be detected, then obtain the offsets along \
   each input grid dimension of the input pixel which contains the \
   current coordinates, and calculate this pixel's offset from the \
   start of the input array. */ \
         if ( Usebad ) { \
            ix = (int) floor( x + 0.5 ); \
            iy = (int) floor( y + 0.5 ); \
            pixel = ix - lbnd_in[ 0 ] + ystride * ( iy - lbnd_in[ 1 ] ); \
\
/* Test if the pixel is bad. */ \
            bad = ( in[ pixel ] == badval ); \
         } \
\
/* If OK, calculate the lowest and highest indices (in each dimension) \
   of the region of neighbouring pixels that will contribute to the \
   interpolated result. Constrain these values to lie within the input \
   grid. */ \
         if ( !bad ) { \
            ix = (int) floor( x ); \
            lo_x = MaxI( ix - neighb + 1, lbnd_in[ 0 ], status ); \
            hi_x = MinI( ix + neighb,     ubnd_in[ 0 ], status ); \
            iy = (int) floor( y ); \
            lo_y = MaxI( iy - neighb + 1, lbnd_in[ 1 ], status ); \
            hi_y = MinI( iy + neighb,     ubnd_in[ 1 ], status ); \
\
/* Loop to evaluate the kernel function along the x dimension, storing \
   the resulting values. The function's argument is the offset of the \
   contributing pixel (along this dimension) from the input \
   position. */ \
            for ( ix = lo_x; ix <= hi_x; ix++ ) { \
               if( kernel ) { \
                  ( *kernel )( (double) ix - x, params, flags, \
                               kval + ix - lo_x, status ); \
               } else { \
                  ( *fkernel )( (double) ix - x, params, flags, \
                               kval + ix - lo_x ); \
               } \
\
/* Check for errors arising in the kernel function. */ \
               if ( !astOK ) { \
                  kerror = 1; \
                  goto Kernel_Error_2d; \
               } \
            } \
\
/* Initialise sums for forming the interpolated result. */ \
            sum = (Xfloattype) 0.0; \
            wtsum = (Xfloattype) 0.0; \
            if ( Usevar ) { \
               sum_var = (Xfloattype) 0.0; \
               bad_var = 0; \
            } \
\
/* Loop over the y index to inspect all the contributing pixels, while \
   keeping track of their offset within the input array. Evaluate the \
   kernel function for each y index value. */ \
            off1 = lo_x - lbnd_in[ 0 ] + ystride * ( lo_y - lbnd_in[ 1 ] ); \
            for ( iy = lo_y; iy <= hi_y; iy++, off1 += ystride ) { \
               if( kernel ) { \
                  ( *kernel )( (double) iy - y, params, flags, &wt_y, status ); \
               } else { \
                  ( *fkernel )( (double) iy - y, params, flags, &wt_y ); \
               } \
\
/* Check for errors arising in the kernel function. */ \
               if ( !astOK ) { \
                  kerror = 1; \
                  goto Kernel_Error_2d; \
               } \
\
/* Loop over the x index, calculating the pixel offset in the input \
   array. */ \
               off_in = off1; \
               for ( ix = lo_x; ix <= hi_x; ix++, off_in++ ) { \
\
/* If necessary, test if the input pixel is bad. If not, calculate its \
   weight as the product of the kernel function's value for the x and \
   y dimensions. */ \
                  if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
                     pixwt = kval[ ix - lo_x ] * wt_y; \
\
/* Form the weighted sums required for finding the interpolated \
   value. */ \
                     sum += ( (Xfloattype) pixwt ) * \
                            ( (Xfloattype) in[ off_in ] ); \
                     wtsum += (Xfloattype) pixwt; \
\
/* If a variance estimate is required and it still seems possible to \
   obtain one, then obtain the variance value associated with the \
   current input pixel. */ \
                     if ( Usevar ) { \
                        if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                           var = in_var[ off_in ]; \
\
/* If necessary, test if this value is bad (if the data type is \
   signed, also check that it is not negative). */ \
                           if ( Usebad ) bad_var = ( var == badval ); \
                           CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If any bad input variance value is obtained, we cannot generate a \
   valid output variance estimate. Otherwise, form the sum needed to \
   calculate this estimate. */ \
                           if ( !( ( Xsigned ) || ( Usebad ) ) || \
                                !bad_var ) { \
                              sum_var += ( (Xfloattype) ( pixwt * pixwt ) ) * \
                                         ( (Xfloattype) var ); \
                           } \
                        } \
                     } \
                  } \
               } \
            } \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the n-dimensional
   case. */
#define ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Initialise offsets into the input array. Then loop to obtain each \
   coordinate associated with the current output point. */ \
   pixel = 0; \
   off_in = 0; \
   for ( idim = 0; idim < ndim_in; idim++ ) { \
      xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate lies outside the input grid, or is bad. If \
   either is true, the corresponding output pixel value will be bad, \
   so give up on this point. */ \
      bad = ( xn < xn_min[ idim ] ) || ( xn >= xn_max[ idim ] ) || \
            ( xn == AST__BAD ); \
      if ( bad ) break; \
\
/* If input bad pixels must be detected, then obtain the index along \
   the current input grid dimension of the pixel which contains this \
   coordinate and accumulate the pixel's offset from the start of the \
   input array. */ \
      if ( Usebad ) { \
         pixel += stride[ idim ] * \
                  ( (int) floor( xn + 0.5 ) - lbnd_in[ idim ] ); \
      } \
\
/* Calculate the lowest and highest indices (in the current dimension) \
   of the region of neighbouring pixels that will contribute to the \
   interpolated result. Constrain these values to lie within the input \
   grid. */ \
      ixn = (int) floor( xn ); \
      lo[ idim ] = MaxI( ixn - neighb + 1, lbnd_in[ idim ], status ); \
      hi[ idim ] = MinI( ixn + neighb,     ubnd_in[ idim ], status ); \
\
/* Accumulate the offset (from the start of the input array) of the \
   contributing pixel which has the lowest index in each dimension. */ \
      off_in += stride[ idim ] * ( lo[ idim ] - lbnd_in[ idim ] ); \
   } \
\
/* Once the input pixel which contains the required coordinates has \
   been identified, test if it is bad, if necessary. */ \
   if ( Usebad ) bad = bad || ( in[ pixel ] == badval ); \
\
/* If OK, loop to evaluate the kernel function which will be used to \
   weight the contributions from surrounding pixels. */ \
   if ( !bad ) { \
      for ( idim = 0; idim < ndim_in; idim++ ) { \
\
/* Set up an array of pointers to locate kernel values (stored in the \
   "kval" array) for each dimension. Initially, each of these pointers \
   locates the first weight value which applies to the contributing \
   pixel with the lowest index in each dimension. */ \
         wtptr[ idim ] = kval + ( 2 * neighb * idim ); \
\
/* Also set up pointers to the last weight value in each dimension. */ \
         wtptr_last[ idim ] = wtptr[ idim ] + ( hi[ idim ] - lo[ idim ] ); \
\
/* Loop to evaluate the kernel function along each dimension, storing \
   the resulting values. The function's argument is the offset of the \
   contributing pixel (along the relevant dimension) from the input \
   point. */ \
         xn = coords[ idim ][ point ]; \
         for ( ixn = lo[ idim ]; ixn <= hi[ idim ]; ixn++ ) { \
            if( kernel ) { \
               ( *kernel )( (double) ixn - xn, params, flags, \
                            wtptr[ idim ] + ixn - lo[ idim ], status ); \
            } else { \
               ( *fkernel )( (double) ixn - xn, params, flags, \
                             wtptr[ idim ] + ixn - lo[ idim ] ); \
            } \
\
/* Check for errors arising in the kernel function. */ \
            if ( !astOK ) { \
               kerror = 1; \
               goto Kernel_Error_Nd; \
            } \
         } \
      } \
\
/* Initialise, and loop over the neighbouring input pixels to obtain \
   an interpolated value. */ \
      sum = (Xfloattype) 0.0; \
      wtsum = (Xfloattype) 0.0; \
      if ( Usevar ) { \
         sum_var = (Xfloattype) 0.0; \
         bad_var = 0; \
      } \
      idim = ndim_in - 1; \
      wtprod[ idim ] = 1.0; \
      done = 0; \
      do { \
\
/* Each contributing pixel is weighted by the product of the kernel \
   weight factors evaluated along each input dimension. However, since \
   we typically only change the index of one dimension at a time, we \
   can avoid forming this product repeatedly by retaining an array of \
   accumulated products for all higher dimensions. We need then only \
   update the lower elements in this array, corresponding to those \
   dimensions whose index has changed. We do this here, "idim" being \
   the index of the most significant dimension to have changed. Note \
   that on the first pass, all dimensions are considered changed, \
   causing this array to be initialised. */ \
         for ( ii = idim; ii >= 1; ii-- ) { \
            wtprod[ ii - 1 ] = wtprod[ ii ] * *( wtptr[ ii ] ); \
         } \
\
/* If necessary, test each pixel which may contribute to the result to \
   see if it is bad. If not, obtain its weight from the accumulated \
   product of weights. Also multiply by the weight for dimension zero, \
   which is not included in the "wtprod" array). */ \
         if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
            pixwt = wtprod[ 0 ] * *( wtptr[ 0 ] ); \
\
/* Form the weighted sums required for finding the interpolated \
   value. */ \
            sum += ( (Xfloattype) pixwt ) * ( (Xfloattype) in[ off_in ] ); \
            wtsum += (Xfloattype) pixwt; \
\
/* If a variance estimate is required and it still seems possible to \
   obtain one, then obtain the variance value associated with the \
   current input pixel. */ \
            if ( Usevar ) { \
               if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                  var = in_var[ off_in ]; \
\
/* If necessary, test if this value is bad (if the data type is \
   signed, also check that it is not negative). */ \
                  if ( Usebad ) bad_var = ( var == badval ); \
                  CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If any bad input variance value is obtained, we cannot generate a \
   valid output variance estimate. Otherwise, form the sum needed to \
   calculate this estimate. */ \
                  if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                     sum_var += ( (Xfloattype) ( pixwt * pixwt ) ) * \
                                ( (Xfloattype) var ); \
                  } \
               } \
            } \
         } \
\
/* Now update the weight value pointers and pixel offset to refer to \
   the next input pixel to be considered. */ \
         idim = 0; \
         do { \
\
/* The first input dimension whose weight value pointer has not yet \
   reached its final value has this pointer incremented, and the pixel \
   offset into the input array is updated accordingly. */ \
            if ( wtptr[ idim ] != wtptr_last[ idim ] ) { \
               wtptr[ idim ]++; \
               off_in += stride[ idim ]; \
               break; \
\
/* Any earlier dimensions (which have reached the final pointer value) \
   have this pointer returned to its lowest value. Again, the pixel \
   offset into the input image is updated accordingly. */ \
            } else { \
               wtptr[ idim ] -= ( hi[ idim ] - lo[ idim ] ); \
               off_in -= stride[ idim ] * \
                               ( hi[ idim ] - lo[ idim ] ); \
               done = ( ++idim == ndim_in ); \
            } \
         } while ( !done ); \
      } while ( !done ); \
   }

/* This subsidiary macro calculates the interpolated output value (and
   variance) from the sums over contributing pixels, checks the
   results for validity, and assigns them to the output array(s). */
#define CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Usebad,Usevar,Nobad) \
\
/* If the output data value has not yet been flagged as bad, then \
   check that an interpolated value can actually be produced.  First \
   check that the sum of weights is not zero. */ \
   if ( !bad ) { \
      bad = ( wtsum == (Xfloattype) 0.0 ); \
\
/* If OK, calculate the interpolated value. Then, if the output data \
   type is not floating point, check that this value will not overflow \
   the available output range. */ \
      if ( !bad ) { \
         val = sum / wtsum; \
         if ( !( Xfloating ) ) { \
            bad = ( val <= lo_lim ) || ( val >= hi_lim ); \
         } \
      } \
\
/* If no interpolated data value can be produced, then no associated \
   variance will be required either. */ \
      if ( ( Usevar ) && bad ) bad_var = 1; \
   } \
\
/* Now perform similar checks on the output variance value (if \
   required). This time we check that the square of the sum of \
   weights is not zero (since this might underflow before the sum of \
   weights). Again we also check to prevent the result overflowing the \
   output data type. */ \
   if ( ( Usevar ) && !bad_var ) { \
      wtsum_sq = wtsum * wtsum; \
      bad_var = ( wtsum_sq == (Xfloattype) 0.0 ); \
      if ( !bad_var ) { \
         val_var = sum_var / wtsum_sq; \
         if ( !( Xfloating ) ) { \
            bad_var = ( val_var <= lo_lim ) || ( val_var >= hi_lim ); \
         } \
      } \
   } \
\
/* Obtain the pixel offset into the output array. */ \
   off_out = offset[ point ]; \
\
/* Assign a bad output value (and variance) if required and count it. */ \
   if ( bad ) { \
      if( !Nobad ) { \
         out[ off_out ] = badval; \
         if ( Usevar ) out_var[ off_out ] = badval; \
      } \
      result++; \
\
/* Otherwise, assign the interpolated value. If the output data type \
   is floating point, the result can be stored directly, otherwise we \
   must round to the nearest integer. */ \
   } else { \
      if ( Xfloating ) { \
         out[ off_out ] = (Xtype) val; \
      } else { \
         out[ off_out ] = (Xtype) ( val + ( ( val >= (Xfloattype) 0.0 ) ? \
                                            ( (Xfloattype) 0.5 ) : \
                                            ( (Xfloattype) -0.5 ) ) ); \
      } \
\
/* If a variance estimate is required but none can be obtained, then \
   store a bad output variance value and count it. */ \
      if ( Usevar ) { \
         if ( bad_var ) { \
            if( !Nobad ) { \
               out_var[ off_out ] = badval; \
            } \
            result++; \
\
/* Otherwise, store the variance estimate, rounding to the nearest \
   integer if necessary. */ \
         } else { \
            if ( Xfloating ) { \
               out_var[ off_out ] = (Xtype) val_var; \
            } else { \
               out_var[ off_out ] = (Xtype) ( val_var + \
                                          ( ( val_var >= (Xfloattype) 0.0 ) ? \
                                            ( (Xfloattype) 0.5 ) : \
                                            ( (Xfloattype) -0.5 ) ) ); \
            } \
         } \
      } \
   }

/* These subsidiary macros define limits for range checking of results
   before conversion to the final data type. For each data type code
   <X>, HI_<X> gives the least positive floating point value which
   just overflows that data type towards plus infinity, while LO_<X>
   gives the least negative floating point value which just overflows
   that data type towards minus infinity. Thus, a floating point value
   must satisfy LO<flt_value<HI if overflow is not to occur when it is
   converted to that data type.

   The data type of each limit should be that of the smallest
   precision floating point type which will accommodate the full range
   of values that the target type may take. */

/* If <X> is a floating point type, the limits are not actually used,
   but must be present to permit error-free compilation. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#define HI_LD ( 0.0L )
#define LO_LD ( 0.0L )
#endif
#define HI_D ( 0.0 )
#define LO_D ( 0.0 )
#define HI_F ( 0.0f )
#define LO_F ( 0.0f )

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#define HI_K   ( 0.5L + (long double) LONG_MAX )
#define LO_K  ( -0.5L + (long double) LONG_MIN )
#define HI_UK  ( 0.5L + (long double) ULONG_MAX )
#define LO_UK ( -0.5L )
#define HI_L   ( 0.5L + (long double) LONG_MAX )
#define LO_L  ( -0.5L + (long double) LONG_MIN )
#define HI_UL  ( 0.5L + (long double) ULONG_MAX )
#define LO_UL ( -0.5L )
#else
#define HI_K   ( 0.5 + (double) LONG_MAX )
#define LO_K  ( -0.5 + (double) LONG_MIN )
#define HI_UK  ( 0.5 + (double) ULONG_MAX )
#define LO_UK ( -0.5 )
#define HI_L   ( 0.5 + (double) LONG_MAX )
#define LO_L  ( -0.5 + (double) LONG_MIN )
#define HI_UL  ( 0.5 + (double) ULONG_MAX )
#define LO_UL ( -0.5 )
#endif

#define HI_I   ( 0.5 + (double) INT_MAX )
#define LO_I  ( -0.5 + (double) INT_MIN )
#define HI_UI  ( 0.5 + (double) UINT_MAX )
#define LO_UI ( -0.5 )
#define HI_S   ( 0.5f + (float) SHRT_MAX )
#define LO_S  ( -0.5f + (float) SHRT_MIN )
#define HI_US  ( 0.5f + (float) USHRT_MAX )
#define LO_US ( -0.5f )
#define HI_B   ( 0.5f + (float) SCHAR_MAX )
#define LO_B  ( -0.5f + (float) SCHAR_MIN )
#define HI_UB  ( 0.5f + (float) UCHAR_MAX )
#define LO_UB ( -0.5f )

/* This subsidiary macro tests for negative variance values. This
   check is required only for signed data types. */
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
   bad_var = bad_var || ( var < ( (Xtype) 0 ) );

/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_KERNEL1(LD,long double,1,long double,1)
MAKE_INTERPOLATE_KERNEL1(L,long int,0,long double,1)
MAKE_INTERPOLATE_KERNEL1(K,INT_BIG,0,long double,1)
#else
MAKE_INTERPOLATE_KERNEL1(L,long int,0,double,1)
MAKE_INTERPOLATE_KERNEL1(K,INT_BIG,0,double,1)
#endif
MAKE_INTERPOLATE_KERNEL1(D,double,1,double,1)
MAKE_INTERPOLATE_KERNEL1(F,float,1,float,1)
MAKE_INTERPOLATE_KERNEL1(I,int,0,double,1)
MAKE_INTERPOLATE_KERNEL1(S,short int,0,float,1)
MAKE_INTERPOLATE_KERNEL1(B,signed char,0,float,1)

/* Re-define the macro for testing for negative variances to do
   nothing. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype)

/* Expand the main macro above to generate a function for each
   required unsigned data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_KERNEL1(UL,unsigned long int,0,long double,0)
MAKE_INTERPOLATE_KERNEL1(UK,UINT_BIG,0,long double,0)
#else
MAKE_INTERPOLATE_KERNEL1(UL,unsigned long int,0,double,0)
MAKE_INTERPOLATE_KERNEL1(UK,UINT_BIG,0,double,0)
#endif
MAKE_INTERPOLATE_KERNEL1(UI,unsigned int,0,double,0)
MAKE_INTERPOLATE_KERNEL1(US,unsigned short int,0,float,0)
MAKE_INTERPOLATE_KERNEL1(UB,unsigned char,0,float,0)

/* Undefine the macros used above. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#undef HI_LD
#undef LO_LD
#endif
#undef HI_D
#undef LO_D
#undef HI_F
#undef LO_F
#undef HI_L
#undef LO_L
#undef HI_UL
#undef LO_UL
#undef HI_K
#undef LO_K
#undef HI_UK
#undef LO_UK
#undef HI_I
#undef LO_I
#undef HI_UI
#undef LO_UI
#undef HI_S
#undef LO_S
#undef HI_US
#undef LO_US
#undef HI_B
#undef LO_B
#undef HI_UB
#undef LO_UB
#undef CALC_AND_ASSIGN_OUTPUT
#undef ASSEMBLE_INPUT_ND
#undef ASSEMBLE_INPUT_2D
#undef ASSEMBLE_INPUT_1D
#undef MAKE_INTERPOLATE_KERNEL1

/*
*  Name:
*     InterpolateLinear<X>

*  Purpose:
*     Resample a data grid, using the linear interpolation scheme.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int InterpolateLinear<X>( int ndim_in,
*                               const int *lbnd_in, const int *ubnd_in,
*                               const <Xtype> *in, const <Xtype> *in_var,
*                               int npoint, const int *offset,
*                               const double *const *coords,
*                               int flags, <Xtype> badval,
*                               <Xtype> *out, <Xtype> *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which resample a rectangular input
*     grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each output
*     grid point may be mapped on to a position in the input grid in
*     an arbitrary way. Where the positions given do not correspond
*     with a pixel centre in the input grid, the interpolation scheme
*     used is linear interpolation between the centres of the nearest
*     neighbouring pixels in each dimension (there are 2 nearest
*     neighbours in 1 dimension, 4 in 2 dimensions, 8 in 3 dimensions,
*     etc.).

*  Parameters:
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input grid, its extent along a particular
*        (i'th) dimension being ubnd_in[i]-lbnd_in[i]+1 (assuming "i"
*        is zero-based). They also define the input grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be resampled (with an element
*        for each pixel in the input grid). The numerical type of
*        these data should match the function used, as given by the
*        suffix on the function name. The storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
*        (i.e. Fortran array storage order).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     npoint
*        The number of points at which the input grid is to be
*        resampled.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each output point, this array should contain the zero-based
*        offset in the output array(s) (i.e. the "out" and,
*        optionally, the "out_var" arrays) at which the resampled
*        output value(s) should be stored.
*     coords
*        An array of pointers to double, with "ndim_in"
*        elements. Element "coords[coord]" should point at the first
*        element of an array of double (with "npoint" elements) which
*        contains the values of coordinate number "coord" for each
*        interpolation point. The value of coordinate number "coord"
*        for interpolation point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices to be
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding output data (and
*        variance) will be set to the value given by "badval" (unles the
*        AST__NOBAD flag is specified).
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function. Currently, only the flag
*        AST__USEBAD is significant and indicates whether there are
*        "bad" (i.e. missing) data in the input array(s) which must be
*        recognised and propagated to the output array(s).  If this
*        flag is not set, all input values are treated literally.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. Unles the AST__NOBAD flag is specified in "flags", the
*        same value will also be used to flag any output array elements
*        for which resampled values could not be obtained.  The output
*        arrays(s) may be flagged with this value whether or not the
*        AST__USEBAD flag is set (the function return value indicates
*        whether any such values have been produced).
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned. Note
*        that details of how the output grid maps on to this array
*        (e.g. the storage order, number of dimensions, etc.) is
*        arbitrary and is specified entirely by means of the "offset"
*        array. The "out" array should therefore contain sufficient
*        elements to accommodate the "offset" values supplied.  There
*        is no requirement that all elements of the "out" array should
*        be assigned values, and any which are not addressed by the
*        contents of the "offset" array will be left unchanged.
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given. It is addressed in
*        exactly the same way (via the "offset" array) as the "out"
*        array. The values returned are estimates of the statistical
*        variance of the corresponding values in the "out" array, on
*        the assumption that all errors in input grid values (in the
*        "in" array) are statistically independent and that their
*        variance estimates (in the "in_var" array) may simply be
*        summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.

*  Returned Value:
*     The number of output grid points to which a data value (or a
*     variance value if relevant) equal to "badval" has been assigned
*     because no valid output value could be obtained.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*     - A value of zero will be returned if any of these functions is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*/
/* Define macros to implement the function for a specific data
   type. */
#define MAKE_INTERPOLATE_LINEAR(X,Xtype,Xfloating,Xfloattype,Xsigned) \
static int InterpolateLinear##X( int ndim_in, \
                                 const int *lbnd_in, const int *ubnd_in, \
                                 const Xtype *in, const Xtype *in_var, \
                                 int npoint, const int *offset, \
                                 const double *const *coords, \
                                 int flags, Xtype badval, \
                                 Xtype *out, Xtype *out_var, int *status ) { \
\
/* Local Variables: */ \
   Xfloattype sum;               /* Weighted sum of pixel data values */ \
   Xfloattype sum_var;           /* Weighted sum of pixel variance values */ \
   Xfloattype val;               /* Value to be asigned to output pixel */ \
   Xfloattype wtsum;             /* Sum of weight values */ \
   Xtype var;                    /* Variance value */ \
   double *frac_hi;              /* Pointer to array of weights */ \
   double *frac_lo;              /* Pointer to array of weights */ \
   double *wt;                   /* Pointer to array of weights */ \
   double *wtprod;               /* Array of accumulated weights pointer */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double frac_hi_x;             /* Pixel weight (x dimension) */ \
   double frac_hi_y;             /* Pixel weight (y dimension) */ \
   double frac_lo_x;             /* Pixel weight (x dimension) */ \
   double frac_lo_y;             /* Pixel weight (y dimension) */ \
   double pixwt;                 /* Weight to apply to individual pixel */ \
   double x;                     /* x coordinate value */ \
   double xmax;                  /* x upper limit */ \
   double xmin;                  /* x lower limit */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   double ymax;                  /* y upper limit */ \
   double ymin;                  /* y lower limit */ \
   int *dim;                     /* Pointer to array of pixel indices */ \
   int *hi;                      /* Pointer to array of upper indices */ \
   int *lo;                      /* Pointer to array of lower indices */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int bad_var;                  /* Output variance bad? */ \
   int done;                     /* All pixel indices done? */ \
   int hi_x;                     /* Upper pixel index (x dimension) */ \
   int hi_y;                     /* Upper pixel index (y dimension) */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ii;                       /* Loop counter for weights */ \
   int ix;                       /* Pixel index in input grid x dimension */ \
   int ixn;                      /* Pixel index (n-d) */ \
   int iy;                       /* Pixel index in input grid y dimension */ \
   int lo_x;                     /* Lower pixel index (x dimension) */ \
   int lo_y;                     /* Lower pixel index (y dimension) */ \
   int nobad;                    /* Was the AST__NOBAD flag set? */ \
   int off_in;                   /* Offset to input pixel */ \
   int off_lo;                   /* Offset to "first" input pixel */ \
   int off_out;                  /* Offset to output pixel */ \
   int pixel;                    /* Offset to input pixel containing point */ \
   int point;                    /* Loop counter for output points */ \
   int result;                   /* Result value to return */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int ystride;                  /* Stride along input grid y dimension */ \
\
/* Initialise. */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Initialise variables to avoid "used of uninitialised variable" \
   messages from dumb compilers. */ \
   sum = 0; \
   sum_var = 0; \
   wtsum = 0; \
   bad = 0; \
   bad_var = 0; \
\
/* Determine if we are processing bad pixels or variances. */ \
   nobad = flags & AST__NOBAD; \
   usebad = flags & AST__USEBAD; \
   usevar = in_var && out_var; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_in == 1 ) { \
\
/* Calculate the coordinate limits of the input grid. */ \
      xmin = (double) lbnd_in[ 0 ] - 0.5; \
      xmax = (double) ubnd_in[ 0 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,0,1) \
               } \
            } \
         } \
\
/* Four more cases as above, but this time with the AST__NOBAD flag \
   un-set. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_in == 2 ) { \
\
/* Calculate the stride along the y dimension of the input grid. */ \
      ystride = ubnd_in[ 0 ] - lbnd_in[ 0 ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
      xmin = (double) lbnd_in[ 0 ] - 0.5; \
      xmax = (double) ubnd_in[ 0 ] + 0.5; \
      ymin = (double) lbnd_in[ 1 ] - 0.5; \
      ymax = (double) ubnd_in[ 1 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,0,1) \
               } \
            } \
         } \
\
/* Four more case as above, but without the AST__NOBAD flag. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                                         0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      dim = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      frac_hi = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      frac_lo = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      hi = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      lo = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      wt = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      wtprod = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the input grid. */ \
         for ( s = 1, idim = 0; idim < ndim_in; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_in[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_in[ idim ] + 0.5; \
         } \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
         if ( nobad ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,1,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,1,0,1) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,0,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,0,0,1) \
                  } \
               } \
            } \
\
/* Four more case as above, but without the AST__NOBAD flag. */ \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,1,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,1,0,0) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,0,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype, \
                                            Xsigned,0,0,0) \
                  } \
               } \
            } \
         } \
      } \
\
/* Free the workspace. */ \
      dim = astFree( dim ); \
      frac_hi = astFree( frac_hi ); \
      frac_lo = astFree( frac_lo ); \
      hi = astFree( hi ); \
      lo = astFree( lo ); \
      stride = astFree( stride ); \
      wt = astFree( wt ); \
      wtprod = astFree( wtprod ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
   } \
\
/* If an error has occurred, clear the returned result. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
}

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 1-dimensional
   case. */
#define ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid. Also test if it is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If input bad pixels must be detected, then obtain the offset along \
   the input grid x dimension of the input pixel which contains the \
   current coordinate and calculate this pixel's offset from the start \
   of the input array. */ \
      if ( Usebad ) { \
         pixel = (int) floor( x + 0.5 ) - lbnd_in[ 0 ]; \
\
/* Test if the pixel is bad. */ \
         bad = ( in[ pixel ] == badval ); \
      } \
\
/* If OK, obtain the indices along the input grid x dimension of the \
   two adjacent pixels which will contribute to the interpolated \
   result. Also obtain the fractional weight to be applied to each of \
   these pixels. */ \
      if ( !bad ) { \
         lo_x = (int) floor( x ); \
         hi_x = lo_x + 1; \
         frac_lo_x = (double) hi_x - x; \
         frac_hi_x = 1.0 - frac_lo_x; \
\
/* Obtain the offset within the input array of the first pixel to be \
   used for interpolation (the one with the smaller index). */ \
         off_lo = lo_x - lbnd_in[ 0 ]; \
\
/* Initialise sums for forming the interpolated result. */ \
         sum = (Xfloattype) 0.0; \
         wtsum = (Xfloattype) 0.0; \
         if ( Usevar ) { \
            sum_var = (Xfloattype) 0.0; \
            if ( ( Xsigned ) || ( Usebad ) ) bad_var = 0; \
         } \
\
/* For each of the two pixels which may contribute to the result, \
   test if the pixel index lies within the input grid. Where it does, \
   accumulate the sums required for forming the interpolated \
   result. In each case, we supply the pixel's offset within the input \
   array and the weight to be applied to it. */ \
         if ( lo_x >= lbnd_in[ 0 ] ) { \
            FORM_LINEAR_INTERPOLATION_SUM(off_lo,frac_lo_x,Xtype, \
                                          Xfloattype,Xsigned,Usebad,Usevar) \
         } \
         if ( hi_x <= ubnd_in[ 0 ] ) { \
            FORM_LINEAR_INTERPOLATION_SUM(off_lo + 1,frac_hi_x,Xtype, \
                                          Xfloattype,Xsigned,Usebad,Usevar) \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 2-dimensional
   case. */
#define ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid. Also test if it is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If OK, then similarly obtain and test the y coordinate. */ \
      y = coords[ 1 ][ point ]; \
      bad = ( y < ymin ) || ( y >= ymax ) || ( y == AST__BAD ); \
      if ( !bad ) { \
\
/* If input bad pixels must be detected, then obtain the offsets along \
   each input grid dimension of the input pixel which contains the \
   current coordinates. */ \
         if ( Usebad ) { \
            ix = (int) floor( x + 0.5 ); \
            iy = (int) floor( y + 0.5 ); \
\
/* Calculate this pixel's offset from the start of the input array. */ \
            pixel = ix - lbnd_in[ 0 ] + ystride * ( iy - lbnd_in[ 1 ] ); \
\
/* Test if the pixel is bad. */ \
            bad = ( in[ pixel ] == badval ); \
         } \
\
/* If OK, obtain the indices along the input grid x dimension of the \
   two adjacent pixels which will contribute to the interpolated \
   result. Also obtain the fractional weight to be applied to each of \
   these pixels. */ \
         if ( !bad ) { \
            lo_x = (int) floor( x ); \
            hi_x = lo_x + 1; \
            frac_lo_x = (double) hi_x - x; \
            frac_hi_x = 1.0 - frac_lo_x; \
\
/* Repeat this process for the y dimension. */ \
            lo_y = (int) floor( y ); \
            hi_y = lo_y + 1; \
            frac_lo_y = (double) hi_y - y; \
            frac_hi_y = 1.0 - frac_lo_y; \
\
/* Obtain the offset within the input array of the first pixel to be \
   used for interpolation (the one with the smaller index along both \
   dimensions). */ \
            off_lo = lo_x - lbnd_in[ 0 ] + ystride * ( lo_y - lbnd_in[ 1 ] ); \
\
/* Initialise sums for forming the interpolated result. */ \
            sum = (Xfloattype) 0.0; \
            wtsum = (Xfloattype) 0.0; \
            if ( Usevar ) { \
               sum_var = (Xfloattype) 0.0; \
               if ( ( Xsigned ) || ( Usebad ) ) bad_var = 0; \
            } \
\
/* For each of the four pixels which may contribute to the result, \
   test if the pixel indices lie within the input grid. Where they do, \
   accumulate the sums required for forming the interpolated \
   result. In each case, we supply the pixel's offset within the input \
   array and the weight to be applied to it. */ \
            if ( lo_y >= lbnd_in[ 1 ] ) { \
               if ( lo_x >= lbnd_in[ 0 ] ) { \
                  FORM_LINEAR_INTERPOLATION_SUM(off_lo, \
                                                frac_lo_x * frac_lo_y,Xtype, \
                                                Xfloattype, Xsigned, \
                                                Usebad,Usevar) \
               } \
               if ( hi_x <= ubnd_in[ 0 ] ) { \
                  FORM_LINEAR_INTERPOLATION_SUM(off_lo + 1, \
                                                frac_hi_x * frac_lo_y,Xtype, \
                                                Xfloattype,Xsigned, \
                                                Usebad,Usevar) \
               } \
            } \
            if ( hi_y <= ubnd_in[ 1 ] ) { \
               if ( lo_x >= lbnd_in[ 0 ] ) { \
                  FORM_LINEAR_INTERPOLATION_SUM(off_lo + ystride, \
                                                frac_lo_x * frac_hi_y,Xtype, \
                                                Xfloattype,Xsigned, \
                                                Usebad,Usevar) \
               } \
               if ( hi_x <= ubnd_in[ 0 ] ) { \
                  FORM_LINEAR_INTERPOLATION_SUM(off_lo + ystride + 1, \
                                                frac_hi_x * frac_hi_y,Xtype, \
                                                Xfloattype,Xsigned, \
                                                Usebad,Usevar) \
               } \
            } \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the n-dimensional
   case. */
#define ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Initialise offsets into the input array. Then loop to obtain each
   coordinate associated with the current output point. */ \
   off_in = 0; \
   if ( Usebad ) pixel = 0; \
   for ( idim = 0; idim < ndim_in; idim++ ) { \
      xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate lies outside the input grid.  Also test if \
   it is bad. If either is true, the corresponding output pixel value \
   will be bad, so give up on this point. */ \
      bad = ( xn < xn_min[ idim ] ) || ( xn >= xn_max[ idim ] ) || \
            ( xn == AST__BAD ); \
      if ( bad ) break; \
\
/* If input bad pixels must be detected, obtain the index along the \
   current input grid dimension of the pixel which contains this \
   coordinate and accumulate the pixel's offset from the start of the \
   input array. */ \
      if ( Usebad ) { \
         pixel += stride[ idim ] * \
                  ( (int) floor( xn + 0.5 ) - lbnd_in[ idim ] ); \
      } \
\
/* Obtain the indices along the current dimension of the input grid of \
   the two (usually adjacent) pixels which will contribute to the \
   output value. If necessary, however, restrict each index to ensure \
   it does not lie outside the input grid. Also calculate the \
   fractional weight to be given to each pixel in order to interpolate \
   linearly between them. */ \
      ixn = (int) floor( xn ); \
      lo[ idim ] = MaxI( ixn, lbnd_in[ idim ], status ); \
      hi[ idim ] = MinI( ixn + 1, ubnd_in[ idim ], status ); \
      frac_lo[ idim ] = 1.0 - fabs( xn - (double) lo[ idim ] ); \
      frac_hi[ idim ] = 1.0 - fabs( xn - (double) hi[ idim ] ); \
\
/* Store the lower index involved in interpolation along each \
   dimension and accumulate the offset from the start of the input \
   array of the pixel which has these indices. */ \
      dim[ idim ] = lo[ idim ]; \
      off_in += stride[ idim ] * ( lo[ idim ] - lbnd_in[ idim ] ); \
\
/* Also store the fractional weight associated with the lower pixel \
   along each dimension. */ \
      wt[ idim ] = frac_lo[ idim ]; \
   } \
\
/* If the input pixel which contains the required coordinates has \
   been identified, test if it is bad. */ \
   if ( Usebad ) bad = bad || ( in[ pixel ] == badval ); \
\
/* If OK, initialise and loop over adjacent input pixels to obtain an \
   interpolated value. */ \
   if ( !bad ) { \
      sum = (Xfloattype) 0.0; \
      wtsum = (Xfloattype) 0.0; \
      if ( Usevar ) { \
         sum_var = (Xfloattype) 0.0; \
         if ( ( Xsigned ) || ( Usebad ) ) bad_var = 0; \
      } \
      idim = ndim_in - 1; \
      wtprod[ idim ] = 1.0; \
      done = 0; \
      do { \
\
/* Each contributing pixel is weighted by the product of the weights \
   which account for the displacement of its centre from the required \
   position along each dimension. However, since we typically only \
   change the index of one dimension at a time, we can avoid forming \
   this product repeatedly by retaining an array of accumulated weight \
   products for all higher dimensions. We need then only update the \
   lower elements in this array, corresponding to those dimensions \
   whose index has changed. We do this here, "idim" being the index of \
   the most significant dimension to have changed. Note that on the \
   first pass, all dimensions are considered changed, causing this \
   array to be initialised. */ \
         for ( ii = idim; ii >= 1; ii-- ) { \
            wtprod[ ii - 1 ] = wtprod[ ii ] * wt[ ii ]; \
         } \
\
/* Accumulate the sums required for forming the interpolated \
   result. We supply the pixel's offset within the input array and the \
   weight to be applied to it. The pixel weight is formed by including \
   the weight factor for dimension zero, since this is not included in \
   the "wtprod" array. */ \
         FORM_LINEAR_INTERPOLATION_SUM(off_in,wtprod[ 0 ] * wt[ 0 ], \
                                       Xtype,Xfloattype,Xsigned, \
                                       Usebad,Usevar) \
\
/* Now update the indices, offset and weight factors to refer to the \
   next input pixel to be considered. */ \
         idim = 0; \
         do { \
\
/* The first input dimension which still refers to the pixel with the \
   lower of the two possible indices is switched to refer to the other \
   pixel (with the higher index). The offset into the input array and \
   the fractional weight factor for this dimension are also updated \
   accordingly. */ \
            if ( dim[ idim ] != hi[ idim ] ) { \
               dim[ idim ] = hi[ idim ]; \
               off_in += stride[ idim ]; \
               wt[ idim ] = frac_hi[ idim ]; \
               break; \
\
/* Any earlier dimensions (referring to the higher index) are switched \
   back to the lower index, if not already there, before going on to \
   consider the next dimension. (This process is the same as \
   incrementing a binary number and propagating overflows up through \
   successive digits, except that dimensions where the "lo" and "hi" \
   values are the same can only take one value.) The process stops at \
   the first attempt to return the final dimension to the lower \
   index. */ \
            } else { \
               if ( dim[ idim ] != lo[ idim ] ) { \
                  dim[ idim ] = lo[ idim ]; \
                  off_in -= stride[ idim ]; \
                  wt[ idim ] = frac_lo[ idim ]; \
               } \
               done = ( ++idim == ndim_in ); \
            } \
         } while ( !done ); \
      } while ( !done ); \
   }

/* This subsidiary macro adds the contribution from a specified input
   pixel to the accumulated sums for forming the linearly interpolated
   value. */
#define FORM_LINEAR_INTERPOLATION_SUM(off,wt,Xtype,Xfloattype,Xsigned, \
                                      Usebad,Usevar) \
\
/* Obtain the offset of the input pixel to use. */ \
   off_in = ( off ); \
\
/* If necessary, test if this pixel is bad. If not, then obtain the \
   weight to apply to it. */ \
   if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
      pixwt = ( wt ); \
\
/* Increment the weighted sum of pixel values and the sum of weights. */ \
      sum += ( (Xfloattype) in[ off_in ] ) * ( (Xfloattype) pixwt ); \
      wtsum += (Xfloattype) pixwt; \
\
/* If an output variance estimate is to be generated, and it still \
   seems possible to produce one, then obtain the input variance \
   value. */ \
      if ( Usevar ) { \
         if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
            var = in_var[ off_in ]; \
\
/* Test if the variance value is bad (if the data type is signed, also \
   check that it is not negative). */ \
            if ( Usebad ) bad_var = ( var == badval ); \
            CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If OK, increment the weighted sum of variance values. */ \
            if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
               sum_var += ( (Xfloattype) ( pixwt * pixwt ) ) * \
                          ( (Xfloattype) var ); \
            } \
         } \
      } \
   }

/* This subsidiary macro calculates the interpolated output value (and
   variance) from the sums over contributing pixels and assigns them
   to the output array(s). */
#define CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Xsigned, \
                               Usebad,Usevar,Nobad) \
\
/* Obtain the pixel offset into the output array. */ \
   off_out = offset[ point ]; \
\
/* Assign a bad output value (and variance) if required and count it. */ \
   if ( bad ) { \
      if( !Nobad ) { \
         out[ off_out ] = badval; \
         if ( Usevar ) out_var[ off_out ] = badval; \
      } \
      result++; \
\
/* Otherwise, calculate the interpolated value. If the output data \
   type is floating point, this result can be stored directly, \
   otherwise we must round to the nearest integer. */ \
   } else { \
      val = sum / wtsum; \
      if ( Xfloating ) { \
         out[ off_out ] = (Xtype) val; \
      } else { \
         out[ off_out ] = (Xtype) ( val + ( ( val >= (Xfloattype) 0.0 ) ? \
                                            ( (Xfloattype) 0.5 ) : \
                                            ( (Xfloattype) -0.5 ) ) ); \
      } \
\
/* If a variance estimate is required but none can be obtained, then \
   store a bad output variance value and count it. */ \
      if ( Usevar ) { \
         if ( ( ( Xsigned ) || ( Usebad ) ) && bad_var ) { \
            if( !Nobad ) out_var[ off_out ] = badval; \
            result++; \
\
/* Otherwise, calculate the variance estimate and store it, rounding \
   to the nearest integer if necessary. */ \
         } else { \
            val = sum_var / ( wtsum * wtsum ); \
            if ( Xfloating ) { \
               out_var[ off_out ] = (Xtype) val; \
            } else { \
               out_var[ off_out ] = (Xtype) ( val + \
                                            ( ( val >= (Xfloattype) 0.0 ) ? \
                                              ( (Xfloattype) 0.5 ) : \
                                              ( (Xfloattype) -0.5 ) ) ); \
            } \
         } \
      } \
   }

/* This subsidiary macro tests for negative variance values in the
   macros above. This check is required only for signed data types. */
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
   bad_var = bad_var || ( var < ( (Xtype) 0 ) );

/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_LINEAR(LD,long double,1,long double,1)
MAKE_INTERPOLATE_LINEAR(L,long int,0,long double,1)
MAKE_INTERPOLATE_LINEAR(K,INT_BIG,0,long double,1)
#else
MAKE_INTERPOLATE_LINEAR(L,long int,0,double,1)
MAKE_INTERPOLATE_LINEAR(K,INT_BIG,0,double,1)
#endif
MAKE_INTERPOLATE_LINEAR(D,double,1,double,1)
MAKE_INTERPOLATE_LINEAR(F,float,1,float,1)
MAKE_INTERPOLATE_LINEAR(I,int,0,double,1)
MAKE_INTERPOLATE_LINEAR(S,short int,0,float,1)
MAKE_INTERPOLATE_LINEAR(B,signed char,0,float,1)

/* Re-define the macro for testing for negative variances to do
   nothing. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype)

/* Expand the main macro above to generate a function for each
   required unsigned data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_LINEAR(UL,unsigned long int,0,long double,0)
MAKE_INTERPOLATE_LINEAR(UK,UINT_BIG,0,long double,0)
#else
MAKE_INTERPOLATE_LINEAR(UL,unsigned long int,0,double,0)
MAKE_INTERPOLATE_LINEAR(UK,UINT_BIG,0,double,0)
#endif
MAKE_INTERPOLATE_LINEAR(UI,unsigned int,0,double,0)
MAKE_INTERPOLATE_LINEAR(US,unsigned short int,0,float,0)
MAKE_INTERPOLATE_LINEAR(UB,unsigned char,0,float,0)

/* Undefine the macros uxsed above. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#undef CALC_AND_ASSIGN_OUTPUT
#undef FORM_LINEAR_INTERPOLATION_SUM
#undef ASSEMBLE_INPUT_ND
#undef ASSEMBLE_INPUT_2D
#undef ASSEMBLE_INPUT_1D
#undef MAKE_INTERPOLATE_LINEAR

/*
*  Name:
*     InterpolateNearest<X>

*  Purpose:
*     Resample a data grid, using the nearest-pixel interpolation scheme.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int InterpolateNearest<X>( int ndim_in,
*                                const int *lbnd_in, const int *ubnd_in,
*                                const <Xtype> *in, const <Xtype> *in_var,
*                                int npoint, const int *offset,
*                                const double *const *coords,
*                                int flags, <Xtype> badval,
*                                <Xtype> *out, <Xtype> *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which resample a rectangular input
*     grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each output
*     grid point may be mapped on to a position in the input grid in
*     an arbitrary way. Where the positions given do not correspond
*     with a pixel centre in the input grid, the interpolation scheme
*     used is simply to select the nearest pixel (i.e. the one whose
*     bounds contain the supplied position).

*  Parameters:
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input grid, its extent along a particular
*        (i'th) dimension being ubnd_in[i]-lbnd_in[i]+1 (assuming "i"
*        is zero-based). They also define the input grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be resampled (with an element
*        for each pixel in the input grid). The numerical type of
*        these data should match the function used, as given by the
*        suffix on the function name. The storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
*        (i.e. Fortran array storage order).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     npoint
*        The number of points at which the input grid is to be
*        resampled.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each output point, this array should contain the zero-based
*        offset in the output array(s) (i.e. the "out" and,
*        optionally, the "out_var" arrays) at which the resampled
*        output value(s) should be stored.
*     coords
*        An array of pointers to double, with "ndim_in"
*        elements. Element "coords[coord]" should point at the first
*        element of an array of double (with "npoint" elements) which
*        contains the values of coordinate number "coord" for each
*        interpolation point. The value of coordinate number "coord"
*        for interpolation point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices to be
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding output data (and
*        variance) will be set to the value given by "badval" (unles the
*        AST__NOBAD flag is specified).
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function. Currently, only the flag
*        AST__USEBAD is significant and indicates whether there are
*        "bad" (i.e. missing) data in the input array(s) which must be
*        recognised and propagated to the output array(s).  If this
*        flag is not set, all input values are treated literally.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. Unles the AST__NOBAD flag is specified in "flags", the
*        same value will also be used to flag any output array elements
*        for which resampled values could not be obtained.  The output
*        arrays(s) may be flagged with this value whether or not the
*        AST__USEBAD flag is set (the function return value indicates
*        whether any such values have been produced).
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned. Note
*        that details of how the output grid maps on to this array
*        (e.g. the storage order, number of dimensions, etc.) is
*        arbitrary and is specified entirely by means of the "offset"
*        array. The "out" array should therefore contain sufficient
*        elements to accommodate the "offset" values supplied.  There
*        is no requirement that all elements of the "out" array should
*        be assigned values, and any which are not addressed by the
*        contents of the "offset" array will be left unchanged.
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given. It is addressed in
*        exactly the same way (via the "offset" array) as the "out"
*        array. The values returned are estimates of the statistical
*        variance of the corresponding values in the "out" array, on
*        the assumption that all errors in input grid values (in the
*        "in" array) are statistically independent and that their
*        variance estimates (in the "in_var" array) may simply be
*        summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.

*  Returned Value:
*     The number of output grid points to which a data value (or a
*     variance value if relevant) equal to "badval" has been assigned
*     because no valid output value could be obtained.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*     - A value of zero will be returned if any of these functions is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_INTERPOLATE_NEAREST(X,Xtype,Xsigned) \
static int InterpolateNearest##X( int ndim_in, \
                                  const int *lbnd_in, const int *ubnd_in, \
                                  const Xtype *in, const Xtype *in_var, \
                                  int npoint, const int *offset, \
                                  const double *const *coords, \
                                  int flags, Xtype badval, \
                                  Xtype *out, Xtype *out_var, int *status ) { \
\
/* Local Variables: */ \
   Xtype var;                    /* Variance value */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double x;                     /* x coordinate value */ \
   double xmax;                  /* x upper limit */ \
   double xmin;                  /* x lower limit */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   double ymax;                  /* y upper limit */ \
   double ymin;                  /* y lower limit */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ix;                       /* Number of pixels offset in x direction */ \
   int ixn;                      /* Number of pixels offset (n-d) */ \
   int iy;                       /* Number of pixels offset in y direction */ \
   int nobad;                    /* Was the AST__NOBAD flag set? */ \
   int off_in;                   /* Pixel offset into input array */ \
   int off_out;                  /* Pixel offset into output array */ \
   int point;                    /* Loop counter for output points */ \
   int result;                   /* Returned result value */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int ystride;                  /* Stride along input grid y direction */ \
\
/* Initialise. */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Initialise variables to avoid "used of uninitialised variable" \
   messages from dumb compilers. */ \
   bad = 0; \
   off_in = 0; \
\
/* Determine if we are processing bad pixels or variances. */ \
   nobad = flags & AST__NOBAD; \
   usebad = flags & AST__USEBAD; \
   usevar = in_var && out_var; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_in == 1 ) { \
\
/* Calculate the coordinate limits of the input array. */ \
      xmin = (double) lbnd_in[ 0 ] - 0.5; \
      xmax = (double) ubnd_in[ 0 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,1) \
               } \
            } \
         } \
\
/* Four more cases as above, but without the AST__NOBAD flag. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_in == 2 ) { \
\
/* Calculate the stride along the y dimension of the input grid. */ \
      ystride = ubnd_in[ 0 ] - lbnd_in[ 0 ] + 1; \
\
/* Calculate the coordinate limits of the input array in each \
   dimension. */ \
      xmin = (double) lbnd_in[ 0 ] - 0.5; \
      xmax = (double) ubnd_in[ 0 ] + 0.5; \
      ymin = (double) lbnd_in[ 1 ] - 0.5; \
      ymax = (double) ubnd_in[ 1 ] + 0.5; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,1) \
               } \
            } \
         } \
\
/* Four more cases as above, but without the AST__NOBAD flag. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the input grid. */ \
         for ( s = 1, idim = 0; idim < ndim_in; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_in[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_in[ idim ] + 0.5; \
         } \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
         if ( nobad ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,1) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,1) \
                  } \
               } \
            } \
\
/* Another 4 cases as above, but without the AST__NOBAD flag. */ \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,1,0,0) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,0,0,0) \
                  } \
               } \
            } \
         } \
      } \
\
/* Free the workspace. */ \
      stride = astFree( stride ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
   } \
\
/* If an error has occurred, clear the returned result. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
}

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 1-dimensional
   case. */
#define ASSEMBLE_INPUT_1D(X,Xtype,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid, or is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If not, then obtain the offset within the input grid of the pixel \
   which contains the current point. */ \
      off_in = (int) floor( x + 0.5 ) - lbnd_in[ 0 ]; \
\
/* If necessary, test if the input pixel is bad. */ \
      if ( Usebad ) bad = ( in[ off_in ] == badval ); \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 2-dimensional
   case. */
#define ASSEMBLE_INPUT_2D(X,Xtype,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the input grid, or is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If not, then similarly obtain and test the y coordinate. */ \
      y = coords[ 1 ][ point ]; \
      bad = ( y < ymin ) || ( y >= ymax ) || ( y == AST__BAD ); \
      if ( !bad ) { \
\
/* Obtain the offsets along each input grid dimension of the input \
   pixel which contains the current point. */ \
         ix = (int) floor( x + 0.5 ) - lbnd_in[ 0 ]; \
         iy = (int) floor( y + 0.5 ) - lbnd_in[ 1 ]; \
\
/* Calculate this pixel's offset from the start of the input array. */ \
         off_in = ix + ystride * iy; \
\
/* If necessary, test if the input pixel is bad. */ \
         if ( Usebad ) bad = ( in[ off_in ] == badval ); \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the n-dimensional
   case. */
#define ASSEMBLE_INPUT_ND(X,Xtype,Usebad,Usevar) \
\
/* Initialise the offset into the input array. Then loop to obtain \
   each coordinate associated with the current output point. */ \
   off_in = 0; \
   for ( idim = 0; idim < ndim_in; idim++ ) { \
      xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate lies outside the input grid, or is bad. If \
   either is true, the corresponding output pixel value will be bad, \
   so give up on this point. */ \
      bad = ( xn < xn_min[ idim ] ) || ( xn >= xn_max[ idim ] ) || \
            ( xn == AST__BAD ); \
      if ( bad ) break; \
\
/* Obtain the offset along the current input grid dimension of the \
   input pixel which contains the current point. */ \
      ixn = (int) floor( xn + 0.5 ) - lbnd_in[ idim ]; \
\
/* Accumulate this pixel's offset from the start of the input \
   array. */ \
      off_in += ixn * stride[ idim ]; \
   } \
\
/* Once the required input pixel has been located, test if it is \
   bad, if necessary. */ \
   if ( Usebad ) bad = bad || ( in[ off_in ] == badval );

/* This subsidiary macro assigns the output value (and variance) to
   the output array(s). */
#define CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xsigned,Usebad,Usevar,Nobad) \
\
/* Obtain the pixel offset into the output array. */ \
   off_out = offset[ point ]; \
\
/* If the input data value is bad, assign a bad output value (and \
   variance, if required) and count it. */ \
   if ( bad ) { \
      if( !Nobad ) { \
         out[ off_out ] = badval; \
         if ( Usevar ) out_var[ off_out ] = badval; \
      } \
      result++; \
\
/* Otherwise, assign the value obtained from the input grid. */ \
   } else { \
      out[ off_out ] = in[ off_in ]; \
\
/* If required, obtain the associated variance value. If necessary, \
   test if it is bad (if the data type is signed, also check that it \
   is not negative). */ \
      if ( Usevar ) { \
         var = in_var[ off_in ]; \
         if ( Usebad ) bad = ( var == badval ); \
         CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If the variance value can be bad, and is, then store a bad value in \
   the output array and count it. Otherwise, store the variance \
   value. */ \
         if ( ( ( Xsigned ) || ( Usebad ) ) && bad ) { \
            if( !Nobad ) out_var[ off_out ] = badval; \
            result++; \
         } else { \
            out_var[ off_out ] = var; \
         } \
      } \
   }

/* This subsidiary macro tests for negative variance values in the
   macros above.  This check is required only for signed data
   types. */
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
   bad = bad || ( var < ( (Xtype) 0 ) );

/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_NEAREST(LD,long double,1)
#endif
MAKE_INTERPOLATE_NEAREST(D,double,1)
MAKE_INTERPOLATE_NEAREST(F,float,1)
MAKE_INTERPOLATE_NEAREST(L,long int,1)
MAKE_INTERPOLATE_NEAREST(K,INT_BIG,1)
MAKE_INTERPOLATE_NEAREST(I,int,1)
MAKE_INTERPOLATE_NEAREST(S,short int,1)
MAKE_INTERPOLATE_NEAREST(B,signed char,1)

/* Re-define the macro for testing for negative variances to do
   nothing. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype)

/* Expand the main macro above to generate a function for each
   required unsigned data type. */
MAKE_INTERPOLATE_NEAREST(UK,UINT_BIG,0)
MAKE_INTERPOLATE_NEAREST(UL,unsigned long int,0)
MAKE_INTERPOLATE_NEAREST(UI,unsigned int,0)
MAKE_INTERPOLATE_NEAREST(US,unsigned short int,0)
MAKE_INTERPOLATE_NEAREST(UB,unsigned char,0)

/* Undefine the macros used above. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#undef CALC_AND_ASSIGN_OUTPUT
#undef ASSEMBLE_INPUT_ND
#undef ASSEMBLE_INPUT_2D
#undef ASSEMBLE_INPUT_1D
#undef MAKE_INTERPOLATE_NEAREST

/*
*  Name:
*     InterpolateBlockAverage<X>

*  Purpose:
*     Resample a data grid, using multidimensional block averaging.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void InterpolateBlockAverage<X>( int ndim_in,
*                                      const int lbnd_in[],
*                                      const int ubnd_in[],
*                                      const <Xtype> in[],
*                                      const <Xtype> in_var[],
*                                      int npoint, const int offset[],
*                                      const double *const coords[],
*                                      const double params[], int flags,
*                                      <Xtype> badval, <Xtype> *out,
*                                      <Xtype> *out_var, int *nbad )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which resample a rectangular input
*     grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. To generate
*     an output grid pixel, a block average is taken over an ndim-
*     dimensional hypercube of pixels in the input grid.  If variances
*     are being used then the input pixels will be weighted according
*     to the reciprocals of the corresponding variance values, and
*     input pixels without a valid variance will be ignored;
*     otherwise an unweighted average will be taken over
*     all non-bad pixels in the cube.  The size of the cube over which
*     the average is taken is determined by the first element of the
*     params array.
*
*     This "interpolation" scheme is appropriate where an input grid
*     is to be resampled onto a much coarser output grid.

*  Parameters:
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input grid, its extent along a particular
*        (i'th) dimension being ubnd_in[i]-lbnd_in[i]+1 (assuming "i"
*        is zero-based). They also define the input grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be resampled (with an element
*        for each pixel in the input grid). The numerical type of
*        these data should match the function used, as given by the
*        suffix on the function name. The storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
*        (i.e. Fortran array storage order).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     npoint
*        The number of points at which the input grid is to be
*        resampled.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each output point, this array should contain the zero-based
*        offset in the output array(s) (i.e. the "out" and,
*        optionally, the "out_var" arrays) at which the resampled
*        output value(s) should be stored.
*     coords
*        An array of pointers to double, with "ndim_in"
*        elements. Element "coords[coord]" should point at the first
*        element of an array of double (with "npoint" elements) which
*        contains the values of coordinate number "coord" for each
*        interpolation point. The value of coordinate number "coord"
*        for interpolation point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices to be
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding output data (and
*        variance) will be set to the value given by "badval" (unles the
*        AST__NOBAD flag is specified).
*     params
*        A pointer to an array of doubles giving further information
*        about how the resampling is to proceed.  Only the first
*        element is significant; the nearest integer to this gives
*        the number of pixels on either side of the central input
*        grid pixel to use in each dimension.  Therefore
*        (1 + 2*params[0])**ndim_in pixels will be averaged over to
*        generate each output pixel.
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function. Currently, only the flag
*        AST__USEBAD is significant and indicates whether there are
*        "bad" (i.e. missing) data in the input array(s) which must be
*        recognised and propagated to the output array(s).  If this
*        flag is not set, all input values are treated literally.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. Unles the AST__NOBAD flag is specified in "flags", the
*        same value will also be used to flag any output array elements
*        for which resampled values could not be obtained.  The output
*        arrays(s) may be flagged with this value whether or not the
*        AST__USEBAD flag is set (the function return value indicates
*        whether any such values have been produced).
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned. Note
*        that details of how the output grid maps on to this array
*        (e.g. the storage order, number of dimensions, etc.) is
*        arbitrary and is specified entirely by means of the "offset"
*        array. The "out" array should therefore contain sufficient
*        elements to accommodate the "offset" values supplied.  There
*        is no requirement that all elements of the "out" array should
*        be assigned values, and any which are not addressed by the
*        contents of the "offset" array will be left unchanged.
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given. It is addressed in
*        exactly the same way (via the "offset" array) as the "out"
*        array. The values returned are estimates of the statistical
*        variance of the corresponding values in the "out" array, on
*        the assumption that all errors in input grid values (in the
*        "in" array) are statistically independent and that their
*        variance estimates (in the "in_var" array) may simply be
*        summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     nbad
*        Pointer to an int in which to return the number of
*        interpolation points at which an output data value (and/or a
*        variance value if relevant) equal to "badval" has been
*        assigned because no valid interpolated value could be
*        obtained.  The maximum value that will be returned is
*        "npoint" and the minimum is zero (indicating that all output
*        values were successfully obtained).

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_INTERPOLATE_BLOCKAVE(X,Xtype,Xfloating,Xfloattype,Xsigned) \
static void InterpolateBlockAverage##X( int ndim_in, \
                                        const int lbnd_in[], \
                                        const int ubnd_in[], \
                                        const Xtype in[], \
                                        const Xtype in_var[], \
                                        int npoint, const int offset[], \
                                        const double *const coords[], \
                                        const double params[], int flags, \
                                        Xtype badval, Xtype *out, \
                                        Xtype *out_var, int *nbad ) { \
\
/* Local Variables: */ \
   Xfloattype hi_lim;            /* Upper limit on output values */ \
   Xfloattype lo_lim;            /* Lower limit on output values */ \
   Xfloattype pixwt;             /* Weight to apply to individual pixel */ \
   Xfloattype sum;               /* Weighted sum of pixel data values */ \
   Xfloattype sum_var;           /* Weighted sum of pixel variance values */ \
   Xfloattype val;               /* Data value to be assigned to output */ \
   Xfloattype val_var;           /* Variance to be assigned to output */ \
   Xfloattype wtsum;             /* Sum of weight values */ \
   Xfloattype wtsum_sq;          /* Square of sum of weights */ \
   Xtype var;                    /* Variance value */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double x;                     /* x coordinate value */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   int *hi;                      /* Pointer to array of upper indices */ \
   int *ixm;                     /* Pointer to array of current indices */ \
   int *lo;                      /* Pointer to array of lower indices */ \
   int *status;                  /* Pointer to inherited status value */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int bad_var;                  /* Output variance bad? */ \
   int done;                     /* All pixel indices done? */ \
   int hi_x;                     /* Upper pixel index (x dimension) */ \
   int hi_y;                     /* Upper pixel index (y dimension) */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ix;                       /* Pixel index in input grid x dimension */ \
   int ixn;                      /* Pixel index in input grid (n-d) */ \
   int iy;                       /* Pixel index in input grid y dimension */ \
   int lo_x;                     /* Lower pixel index (x dimension) */ \
   int lo_y;                     /* Lower pixel index (y dimension) */ \
   int neighb;                   /* Number of adjacent pixels on each side */ \
   int nobad;                    /* Was the AST__NOBAD flag set? */ \
   int off1;                     /* Input pixel offset due to y index */ \
   int off_in;                   /* Offset to input pixel */ \
   int off_out;                  /* Offset to output pixel */ \
   int point;                    /* Loop counter for output points */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int ystride;                  /* Stride along input grid y dimension */ \
\
/* Initialise. */ \
   *nbad = 0; \
\
/* Get a pointer to the inherited status argument. */ \
   status = astGetStatusPtr; \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Initialise variables to avoid "used of uninitialised variable" \
   messages from dumb compilers. */ \
   val = 0; \
   val_var = 0; \
   sum_var = 0; \
   wtsum = 0; \
   bad = 0; \
   bad_var = 0; \
\
/* Determine if we are processing bad pixels or variances. */ \
   nobad = flags & AST__NOBAD; \
   usebad = flags & AST__USEBAD; \
   usevar = in_var && out_var; \
\
/* Set the number of pixels each side of central pixel to use. */ \
   neighb = (int) floor( params[ 0 ] + 0.5 ); \
\
/* Set up limits for checking output values to ensure that they do not \
   overflow the range of the data type being used. */ \
   lo_lim = LO_##X; \
   hi_lim = HI_##X; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_in == 1 ) { \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
               } \
            } \
         } \
\
/* Another 4 cases as above, but without the AST__NOBAD flag. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_in == 2 ) { \
\
/* Calculate the stride along the y dimension of the input grid. */ \
      ystride = ubnd_in[ 0 ] - lbnd_in[ 0 ] + 1; \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
      if ( nobad ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
               } \
            } \
         } \
\
/* Another 4 cases as above, but without the AST__NOBAD flag. */ \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
               } \
            } \
         } else { \
            if ( usevar ) { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
               } \
            } else { \
               for ( point = 0; point < npoint; point++ ) { \
                  ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                  CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
               } \
            } \
         } \
      } \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      hi = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      lo = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      ixm = astMalloc( sizeof( int ) * (size_t) ndim_in ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_in ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the input grid. */ \
         for ( s = 1, idim = 0; idim < ndim_in; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
\
/* Calculate the coordinate limits of the input grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_in[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_in[ idim ] + 0.5; \
         } \
\
/* Identify four cases, according to whether bad pixels and/or \
   variances are being processed. In each case, loop through all the \
   output points to (a) assemble the input data needed to form the \
   interpolated value, and (b) calculate the result and assign it to \
   the output arrays(s). In each case we assign constant values (0 or \
   1) to the "Usebad" and "Usevar" flags so that code for handling bad \
   pixels and variances can be eliminated when not required. */ \
         if ( nobad ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,1) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,1) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,1) \
                  } \
               } \
            } \
\
/* Another 4 cases as above, but this time without the AST__NOBAD flag. */ \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,1,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,1,0,0) \
                  } \
               } \
            } else { \
               if ( usevar ) { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,1) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,1,0) \
                  } \
               } else { \
                  for ( point = 0; point < npoint; point++ ) { \
                     ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,0,0) \
                     CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,0,0,0) \
                  } \
               } \
            } \
         } \
      } \
\
/* Free the workspace. */ \
      hi = astFree( hi ); \
      lo = astFree( lo ); \
      stride = astFree( stride ); \
      ixm = astFree( ixm ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
   } \
\
/* If an error has occurred, clear the returned result. */ \
   if ( !astOK ) *nbad = 0; \
\
/* Return. */ \
}

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 1-dimensional
   case. */
#define ASSEMBLE_INPUT_1D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x == AST__BAD ); \
\
/* Note we do not need to check here whether the pixel in this position is \
   bad; if any pixels in the cube are good we can form an average. */ \
\
/* If OK, calculate the lowest and highest indices (in the x \
   dimension) of the region of neighbouring pixels that will \
   contribute to the interpolated result.  Constrain these values to \
   lie within the input grid. */ \
   if ( !bad ) { \
      ix = (int) floor( x ); \
      lo_x = MaxI( ix - neighb + 1, lbnd_in[ 0 ], status ); \
      hi_x = MinI( ix + neighb,     ubnd_in[ 0 ], status ); \
\
/* Initialise sums for forming the interpolated result. */ \
      sum = (Xfloattype) 0.0; \
      wtsum = (Xfloattype) 0.0; \
      if ( Usevar ) { \
         sum_var = (Xfloattype) 0.0; \
         bad_var = 0; \
      } \
\
/* Loop to inspect all the contributing pixels, calculating the offset \
   of each pixel from the start of the input array. */ \
      off_in = lo_x - lbnd_in[ 0 ]; \
      for ( ix = lo_x; ix <= hi_x; ix++, off_in++ ) { \
\
/* If necessary, test if the input pixel is bad. */ \
         if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
\
/* If we are using variances, then check that the variance is valid; \
   if it is invalid then ignore this pixel altogether. */ \
            if ( Usevar ) { \
               var = in_var[ off_in ]; \
               if ( Usebad ) bad_var = ( var == badval ); \
               CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If variance is valid then accumulate suitably weighted values into \
   the totals. */ \
               if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                  pixwt = (Xfloattype) 1.0 / var; \
                  sum += pixwt * ( (Xfloattype) in[ off_in ] ); \
                  wtsum += pixwt; \
                  sum_var += pixwt; \
               } \
\
/* If we are not using variances, then accumulate values into the \
   totals with a weighting of unity. */ \
            } else { \
               sum += (Xfloattype) in[ off_in ]; \
               wtsum++; \
            } \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the 2-dimensional
   case. */
#define ASSEMBLE_INPUT_2D(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Obtain the x coordinate of the current point and test if it is bad. */ \
   x = coords[ 0 ][ point ]; \
   bad = ( x == AST__BAD ); \
   if ( !bad ) { \
\
/* If not, then similarly obtain and test the y coordinate. */ \
      y = coords[ 1 ][ point ]; \
      bad = ( y == AST__BAD ); \
\
/* Note we do not need to check here whether the pixel in this position is \
   bad; if any pixels in the cube are good we can form an average. */ \
\
/* If OK, calculate the lowest and highest indices (in each dimension) \
   of the region of neighbouring pixels that will contribute to the \
   interpolated result.  Constrain these values to lie within the input \
   grid. */ \
      if ( !bad ) { \
         ix = (int) floor( x ); \
         lo_x = MaxI( ix - neighb + 1, lbnd_in[ 0 ], status ); \
         hi_x = MinI( ix + neighb,     ubnd_in[ 0 ], status ); \
         iy = (int) floor( y ); \
         lo_y = MaxI( iy - neighb + 1, lbnd_in[ 1 ], status ); \
         hi_y = MinI( iy + neighb,     ubnd_in[ 1 ], status ); \
\
/* Initialise sums for forming the interpolated result. */ \
         sum = (Xfloattype) 0.0; \
         wtsum = (Xfloattype) 0.0; \
         if ( Usevar ) { \
            sum_var = (Xfloattype) 0.0; \
            bad_var = 0; \
         } \
\
/* Loop to inspect all the contributing pixels, calculating the offset \
   of each pixel from the start of the input array. */ \
         off1 = lo_x - lbnd_in[ 0 ] + ystride * ( lo_y - lbnd_in[ 1 ] ); \
         for ( iy = lo_y; iy <= hi_y; iy++, off1 += ystride ) { \
            off_in = off1; \
            for ( ix = lo_x; ix <= hi_x; ix++, off_in++ ) { \
\
/* If necessary, test if the input pixel is bad. */ \
               if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
\
/* If we are using variances, then check that the variance is valid; \
   if it is invalid then ignore this pixel altogether. */ \
                  if ( Usevar ) { \
                     var = in_var[ off_in ]; \
                     if ( Usebad ) bad_var = ( var == badval ); \
                     CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If variance is valid then accumulate suitably weighted values into \
   the totals. */ \
                     if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                        pixwt = (Xfloattype) 1.0 / var; \
                        sum += pixwt * ( (Xfloattype) in[ off_in ] ); \
                        wtsum += pixwt; \
                        sum_var += pixwt; \
                     } \
\
/* If we are not using variances, then accumulate values into the \
   totals with a weighting of unity. */ \
                  } else { \
                     sum += (Xfloattype) in[ off_in ]; \
                     wtsum++; \
                  } \
               } \
            } \
         } \
      } \
   }

/* This subsidiary macro assembles the input data needed in
   preparation for forming the interpolated value in the n-dimensional
   case. */
#define ASSEMBLE_INPUT_ND(X,Xtype,Xfloating,Xfloattype,Xsigned,Usebad,Usevar) \
\
/* Initialise offsets into the input array.  then loop to obtain each \
   coordinate associated with the current output poitn. */ \
   off_in = 0; \
   for ( idim = 0; idim < ndim_in; idim++ ) { \
      xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate is bad. If so give up on this point. */ \
      bad = ( xn == AST__BAD ); \
      if ( bad ) break; \
\
/* Calculate the lowest and highest indices (in the current dimension) \
   of the region of neighbouring pixels that will contribute to the \
   interpolated result. Constrain these values to lie within the input \
   grid. */ \
      ixn = (int) floor( xn ); \
      lo[ idim ] = MaxI( ixn - neighb + 1, lbnd_in[ idim ], status ); \
      hi[ idim ] = MinI( ixn + neighb,     ubnd_in[ idim ], status ); \
\
/* If the cube has a zero dimension then no data can come from it. */ \
      bad = ( lo[ idim ] > hi[ idim ] ); \
      if ( bad ) break; \
\
/* Accumulate the offset (from the start of the input array) of the \
   contributing pixel which has the lowest index in each dimension. */ \
      off_in += stride[ idim ] * ( lo[ idim ] - lbnd_in[ idim ] ); \
\
/* Initialise an array to keep track of the current position in the \
   input cube. */ \
      ixm[ idim ] = lo[ idim ]; \
   } \
\
/* Note we do not need to check here whether the pixel in this position is \
   bad; if any pixels in the cube are good we can form an average. */ \
\
/* If OK, initialise sums for forming the interpolated result. */ \
   if ( !bad ) { \
      sum = (Xfloattype) 0.0; \
      wtsum= (Xfloattype) 0.0; \
      if ( Usevar ) { \
         sum_var = (Xfloattype) 0.0; \
         bad_var = 0; \
      } \
\
/* Loop to inspect all the contributing pixels, calculating the offset \
   of each pixel from the start of the input array. */ \
      do { \
\
/* If necessary, test if the input pixel is bad. */ \
         if ( !( Usebad ) || ( in[ off_in ] != badval ) ) { \
\
/* If we are using variances, then check that the variance is valid; \
   if it is invalid then ignore this pixel altogether. */ \
            if ( Usevar ) { \
               var = in_var[ off_in ]; \
               if ( Usebad ) bad_var = ( var == badval ); \
               CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
\
/* If variance is valid then accumulate suitably weighted values into \
   the totals. */ \
               if ( !( ( Xsigned ) || ( Usebad ) ) || !bad_var ) { \
                  pixwt = (Xfloattype) 1.0 / var; \
                  sum += pixwt * ( (Xfloattype) in[ off_in ] ); \
                  wtsum += pixwt; \
                  sum_var += pixwt; \
               } \
\
/* If we are not using variances, then accumulate values into the \
   totals with a weighting of unity. */ \
            } else { \
               sum += (Xfloattype) in[ off_in ]; \
               wtsum++; \
            } \
         } \
\
/* Locate the next pixel in the input cube; try incrementing the lowest \
   dimension index first, if that rolls over increment the next  \
   dimension index, and so on. */ \
         for ( idim = 0; idim < ndim_in; idim++ ) { \
            if ( ixm[ idim ] < hi[ idim ] ) { \
               off_in += stride[ idim ]; \
               ixm[ idim ]++; \
               break; \
            } else { \
               off_in -= stride[ idim ] * ( hi[ idim ] - lo[ idim ] ); \
               ixm[ idim ] = lo[ idim ]; \
            } \
         } \
\
/* If the highest dimension index has rolled over, we have done all \
   the pixels in the cube. */ \
         done = ( idim == ndim_in ); \
      } while ( !done ); \
   }

/* This subsidiary macro calculates the interpolated output value (and
   variance) from the sums over contributing pixels, checks the
   results for validity, and assigns them to the output array(s). */
#define CALC_AND_ASSIGN_OUTPUT(X,Xtype,Xfloating,Xfloattype,Usebad,Usevar,Nobad) \
\
/* If the output data value has not yet been flagged as bad, then \
   check that an interpolated value can actually be produced.  First \
   check that the sum of weights is not zero. */ \
   if ( !bad ) { \
      bad = ( wtsum == (Xfloattype) 0.0 ); \
\
/* If OK, calculate the interpolated value. Then, if the output data \
   type is not floating point, check that this value will not overflow \
   the available output range. */ \
      if ( !bad ) { \
         val = sum / wtsum; \
         if ( !( Xfloating ) ) { \
            bad = ( val <= lo_lim ) || ( val >= hi_lim ); \
         } \
      } \
\
/* If no interpolated data value can be produced, then no associated \
   variance will be required either. */ \
      if ( ( Usevar ) && bad ) bad_var = 1; \
   } \
\
/* Now perform similar checks on the output variance value (if \
   required). This time we check that the square of the sum of \
   weights is not zero (since this might underflow before the sum of \
   weights). Again we also check to prevent the result overflowing the \
   output data type. */ \
   if ( ( Usevar ) && !bad_var ) { \
      wtsum_sq = wtsum * wtsum; \
      bad_var = ( wtsum_sq == (Xfloattype) 0.0 ); \
      if ( !bad_var ) { \
         val_var = sum_var / wtsum_sq; \
         if ( !( Xfloating ) ) { \
            bad_var = ( val_var <= lo_lim ) || ( val_var >= hi_lim ); \
         } \
      } \
   } \
\
/* Obtain the pixel offset into the output array. */ \
   off_out = offset[ point ]; \
\
/* Assign a bad output value (and variance) if required and count it. */ \
   if ( bad ) { \
      if( !Nobad ) { \
         out[ off_out ] = badval; \
         if ( Usevar ) out_var[ off_out ] = badval; \
      } \
      (*nbad)++; \
\
/* Otherwise, assign the interpolated value. If the output data type \
   is floating point, the result can be stored directly, otherwise we \
   must round to the nearest integer. */ \
   } else { \
      if ( Xfloating ) { \
         out[ off_out ] = (Xtype) val; \
      } else { \
         out[ off_out ] = (Xtype) ( val + ( ( val >= (Xfloattype) 0.0 ) ? \
                                            ( (Xfloattype) 0.5 ) : \
                                            ( (Xfloattype) -0.5 ) ) ); \
      } \
\
/* If a variance estimate is required but none can be obtained, then \
   store a bad output variance value and count it. */ \
      if ( Usevar ) { \
         if ( bad_var ) { \
            if( !Nobad ) out_var[ off_out ] = badval; \
            (*nbad)++; \
\
/* Otherwise, store the variance estimate, rounding to the nearest \
   integer if necessary. */ \
         } else { \
            if ( Xfloating ) { \
               out_var[ off_out ] = (Xtype) val_var; \
            } else { \
               out_var[ off_out ] = (Xtype) ( val_var + \
                                          ( ( val_var >= (Xfloattype) 0.0 ) ? \
                                            ( (Xfloattype) 0.5 ) : \
                                            ( (Xfloattype) -0.5 ) ) ); \
            } \
         } \
      } \
   }

/* These subsidiary macros define limits for range checking of results
   before conversion to the final data type. For each data type code
   <X>, HI_<X> gives the least positive floating point value which
   just overflows that data type towards plus infinity, while LO_<X>
   gives the least negative floating point value which just overflows
   that data type towards minus infinity. Thus, a floating point value
   must satisfy LO<flt_value<HI if overflow is not to occur when it is
   converted to that data type.

   The data type of each limit should be that of the smallest
   precision floating point type which will accommodate the full range
   of values that the target type may take. */

/* If <X> is a floating point type, the limits are not actually used,
   but must be present to permit error-free compilation. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#define HI_LD ( 0.0L )
#define LO_LD ( 0.0L )
#endif
#define HI_D ( 0.0 )
#define LO_D ( 0.0 )
#define HI_F ( 0.0f )
#define LO_F ( 0.0f )

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#define HI_L   ( 0.5L + (long double) LONG_MAX )
#define LO_L  ( -0.5L + (long double) LONG_MIN )
#define HI_UL  ( 0.5L + (long double) ULONG_MAX )
#define LO_UL ( -0.5L )
#define HI_K   ( 0.5L + (long double) LONG_MAX )
#define LO_K  ( -0.5L + (long double) LONG_MIN )
#define HI_UK  ( 0.5L + (long double) ULONG_MAX )
#define LO_UK ( -0.5L )
#else
#define HI_L   ( 0.5 + (double) LONG_MAX )
#define LO_L  ( -0.5 + (double) LONG_MIN )
#define HI_UL  ( 0.5 + (double) ULONG_MAX )
#define LO_UL ( -0.5 )
#define HI_K   ( 0.5 + (double) LONG_MAX )
#define LO_K  ( -0.5 + (double) LONG_MIN )
#define HI_UK  ( 0.5 + (double) ULONG_MAX )
#define LO_UK ( -0.5 )
#endif
#define HI_I   ( 0.5 + (double) INT_MAX )
#define LO_I  ( -0.5 + (double) INT_MIN )
#define HI_UI  ( 0.5 + (double) UINT_MAX )
#define LO_UI ( -0.5 )
#define HI_S   ( 0.5f + (float) SHRT_MAX )
#define LO_S  ( -0.5f + (float) SHRT_MIN )
#define HI_US  ( 0.5f + (float) USHRT_MAX )
#define LO_US ( -0.5f )
#define HI_B   ( 0.5f + (float) SCHAR_MAX )
#define LO_B  ( -0.5f + (float) SCHAR_MIN )
#define HI_UB  ( 0.5f + (float) UCHAR_MAX )
#define LO_UB ( -0.5f )

/* This subsidiary macro tests for negative variance values. This
   check is required only for signed data types. */
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype) \
   bad_var = bad_var || ( var < ( (Xtype) 0 ) );

/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_BLOCKAVE(LD,long double,1,long double,1)
MAKE_INTERPOLATE_BLOCKAVE(L,long int,0,long double,1)
MAKE_INTERPOLATE_BLOCKAVE(K,INT_BIG,0,long double,1)
#else
MAKE_INTERPOLATE_BLOCKAVE(L,long int,0,double,1)
MAKE_INTERPOLATE_BLOCKAVE(K,INT_BIG,0,double,1)
#endif
MAKE_INTERPOLATE_BLOCKAVE(D,double,1,double,1)
MAKE_INTERPOLATE_BLOCKAVE(F,float,1,float,1)
MAKE_INTERPOLATE_BLOCKAVE(I,int,0,double,1)
MAKE_INTERPOLATE_BLOCKAVE(S,short int,0,float,1)
MAKE_INTERPOLATE_BLOCKAVE(B,signed char,0,float,1)

/* Re-define the macro for testing for negative variances to do
   nothing. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#define CHECK_FOR_NEGATIVE_VARIANCE(Xtype)

/* Expand the main macro above to generate a function for each
   required unsigned data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_INTERPOLATE_BLOCKAVE(UL,unsigned long int,0,long double,0)
MAKE_INTERPOLATE_BLOCKAVE(UK,UINT_BIG,0,long double,0)
#else
MAKE_INTERPOLATE_BLOCKAVE(UL,unsigned long int,0,double,0)
MAKE_INTERPOLATE_BLOCKAVE(UK,UINT_BIG,0,double,0)
#endif
MAKE_INTERPOLATE_BLOCKAVE(UI,unsigned int,0,double,0)
MAKE_INTERPOLATE_BLOCKAVE(US,unsigned short int,0,float,0)
MAKE_INTERPOLATE_BLOCKAVE(UB,unsigned char,0,float,0)

/* Undefine the macros used above. */
#undef CHECK_FOR_NEGATIVE_VARIANCE
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
#undef HI_LD
#undef LO_LD
#endif
#undef HI_D
#undef LO_D
#undef HI_F
#undef LO_F
#undef HI_L
#undef LO_L
#undef HI_UL
#undef LO_UL
#undef HI_K
#undef LO_K
#undef HI_UK
#undef LO_UK
#undef HI_I
#undef LO_I
#undef HI_UI
#undef LO_UI
#undef HI_S
#undef LO_S
#undef HI_US
#undef LO_US
#undef HI_B
#undef LO_B
#undef HI_UB
#undef LO_UB
#undef CALC_AND_ASSIGN_OUTPUT
#undef ASSEMBLE_INPUT_ND
#undef ASSEMBLE_INPUT_2D
#undef ASSEMBLE_INPUT_1D
#undef MAKE_INTERPOLATE_BLOCKAVE


static void Invert( AstMapping *this, int *status ) {
/*
*++
*  Name:
c     astInvert
f     AST_INVERT

*  Purpose:
*     Invert a Mapping.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astInvert( AstMapping *this )
f     CALL AST_INVERT( THIS, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function inverts a Mapping by reversing the boolean sense
f     This routine inverts a Mapping by reversing the boolean sense
*     of its Invert attribute. If this attribute is zero (the
*     default), the Mapping will transform coordinates in the way
*     specified when it was created. If it is non-zero, the input and
*     output coordinates will be inter-changed so that the direction
*     of the Mapping is reversed. This will cause it to display the
*     inverse of its original behaviour.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping.
f     STATUS = INTEGER (Given and Returned)
f        The global status.
*--
*/

/* Local Variables: */
   int invert;                   /* New Invert attribute value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Determine the new Invert attribute value. */
   invert = !astGetInvert( this );

/* Clear the old value. */
   astClearInvert( this );

/* If the resulting default value is not the one required, then set a
   new value explicitly. */
   if ( astGetInvert( this ) != invert ) astSetInvert( this, invert );
}

static double J1Bessel( double x, int *status ) {
/*
*  Name:
*     J1Bessel

*  Purpose:
*     Calculates the first-order Bessel function of the first kind.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double J1Bessel( double x, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of the first-order Bessel function
*     of the first kind.

*  Parameters:
*     x
*        The argument for J1.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The calculated J1(x) value.

*  Notes:
*     - The algorithm is taken from the SCUBA routine SCULIB_BESSJ1, by
*     J.Lightfoot.
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   static double p1 = 1.0;
   static double p2 = 0.183105E-2;
   static double p3 = -0.3516396496E-4;
   static double p4 = 0.2457520174E-5;
   static double p5 = -0.240337019E-6;

   static double q1 = 0.04687499995;
   static double q2 = -0.2002690873E-3;
   static double q3 = 0.8449199096E-5;
   static double q4 = -0.88228987E-6;
   static double q5 = 0.105787412E-6;

   static double r1 = 72362614232.0;
   static double r2 = -7895059235.0;
   static double r3 = 242396853.1;
   static double r4 = -2972611.439;
   static double r5 = 15704.48260;
   static double r6 = -30.16036606;

   static double s1 = 144725228442.0;
   static double s2 = 2300535178.0;
   static double s3 = 18583304.74;
   static double s4 = 99447.43394;
   static double s5 = 376.9991397;
   static double s6 = 1.0;

   double ax;
   double xx;
   double z;
   double y;
   double value;
   int s;

/* Calculate the value */
   ax = fabs( x );
   if( ax < 8.0 ) {
      y = x*x;
      value = x*( r1 + y*( r2 + y*( r3 + y*( r4 + y*( r5 + y*r6 ) ) ) ) ) /
                       ( s1 + y*( s2 + y*( s3 + y*( s4 + y*( s5 + y*s6 ) ) ) ) );
   } else {
      s = ( x >= 0.0 ) ? 1 : -1;
      z = 8.0 / ax;
      y = z*z;
      xx = ax - 2.356194491;
      value = sqrt ( 0.636619772/ax )*( cos( xx )*( p1 + y*( p2 + y*
        ( p3 + y*( p4 + y*p5 ) ) ) )-z*sin( xx )*( q1 + y*( q2 + y*( q3 + y*
        ( q4 + y*q5 ) ) ) ) )*s;
   }

   return value;

}

static int LinearApprox( AstMapping *this, const double *lbnd,
                         const double *ubnd, double tol, double *fit, int *status ) {
/*
*++
*  Name:
c     astLinearApprox
f     AST_LINEARAPPROX

*  Purpose:
*     Obtain a linear approximation to a Mapping, if appropriate.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     int astLinearApprox( AstMapping *this, const double *lbnd,
c                          const double *ubnd, double tol, double *fit )
f     RESULT = AST_LINEARAPPROX( THIS, LBND, UBND, TOL, FIT, STATUS )

*  Class Membership:
*     Mapping function.

*  Description:
*     This function tests the forward coordinate transformation
*     implemented by a Mapping over a given range of input coordinates. If
*     the transformation is found to be linear to a specified level of
*     accuracy, then an array of fit coefficients is returned. These
*     may be used to implement a linear approximation to the Mapping's
*     forward transformation within the specified range of output coordinates.
*     If the transformation is not sufficiently linear, no coefficients
*     are returned.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping.
c     lbnd
f     LBND( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of doubles
f        An array
*        containing the lower bounds of a box defined within the input
*        coordinate system of the Mapping. The number of elements in this
*        array should equal the value of the Mapping's Nin attribute. This
*        box should specify the region over which linearity is required.
c     ubnd
f     UBND( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of doubles
f        An array
*        containing the upper bounds of the box specifying the region over
*        which linearity is required.
c     tol
f     TOL = DOUBLE PRECISION (Given)
*        The maximum permitted deviation from linearity, expressed as
*        a positive Cartesian displacement in the output coordinate
*        space of the Mapping. If a linear fit to the forward
*        transformation of the Mapping deviates from the true transformation
*        by more than this amount at any point which is tested, then no fit
*        coefficients will be returned.
c     fit
f     FIT( * ) = DOUBLE PRECISION (Returned)
c        Pointer to an array of doubles
f        An array
*        in which to return the co-efficients of the linear
*        approximation to the specified transformation. This array should
*        have at least "( Nin + 1 ) * Nout", elements. The first Nout elements
*        hold the constant offsets for the transformation outputs. The
*        remaining elements hold the gradients. So if the Mapping has 2 inputs
*        and 3 outputs the linear approximation to the forward transformation
*        is:
*
c           X_out = fit[0] + fit[3]*X_in + fit[4]*Y_in
f           X_out = fit(1) + fit(4)*X_in + fit(5)*Y_in
*
c           Y_out = fit[1] + fit[5]*X_in + fit[6]*Y_in
f           Y_out = fit(2) + fit(6)*X_in + fit(7)*Y_in
*
c           Z_out = fit[2] + fit[7]*X_in + fit[8]*Y_in
f           Z_out = fit(3) + fit(8)*X_in + fit(9)*Y_in
*
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astLinearApprox()
f     AST_LINEARAPPROX = LOGICAL
*        If the forward transformation is sufficiently linear,
c        a non-zero value is returned. Otherwise zero is returned
f        .TRUE is returned. Otherwise .FALSE. is returned
*        and the fit co-efficients are set to AST__BAD.

*  Notes:
*     - This function fits the Mapping's forward transformation. To fit
*     the inverse transformation, the Mapping should be inverted using
c     astInvert
f     AST_INVERT
*     before invoking this function.
*     - If a Mapping output is found to have a bad value (AST__BAD) at
*     one or more of the test points used in the linearity test, then all
*     the values in the returned fit that correspond to that output are
*     set to AST__BAD. However, this does not affect the linearity tests
*     on the other Mapping outputs - if they are all found to be linear
*     then usable coefficients will be returned for them in the fit, and
*     the function will return a
c     non-zero value.
f     .TRUE. value.
*     Consequently, it may be necessary to check that the values in the
*     returned fit are not AST__BAD before using them. If all Mapping
*     outputs generate bad values, then
c     zero is returned as the function value.
f     .FALSE. is returned as the function value.
c     - A value of zero
f     - A value of .FALSE.
*     will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*     - If all tested positions within the supplied box generate bad
*     output positions, then the returned function value will be
c     zero.
f     .FALSE.
*     However, the returned coefficients will represent a unit
*     transformation, except that the constant term for each output
*     will be set to AST__BAD.

*--

*  Implementation Deficiencies:
*     Sub-classes which implement linear mappings should probably
*     over-ride this function to get better accuracy and faster execution,
*     but currently they do not.

*/

/* Local Variables: */
   AstPointSet *pset_in_f;       /* PointSet for input fitting points */
   AstPointSet *pset_in_t;       /* PointSet for input test points */
   AstPointSet *pset_out_f;      /* PointSet for output fitting points */
   AstPointSet *pset_out_t;      /* PointSet for output test points */
   double **ptr_in_f;            /* Input coordinate array pointers */
   double **ptr_in_t;            /* Input coordinate array pointers */
   double **ptr_out_f;           /* Output coordinate array pointers */
   double **ptr_out_t;           /* Output coordinate array pointers */
   double *grad;                 /* Pointer to matrix of gradients */
   double *zero;                 /* Pointer to array of zero point values */
   double diff;                  /* Difference in coordinate values */
   double err;                   /* Sum of squared error */
   double frac;                  /* Fraction of input coordinate range */
   double in1;                   /* Input coordinate value */
   double in2;                   /* Input coordinate value */
   double indiff;                /* Difference in input coordinate values */
   double out1;                  /* Output coordinate value */
   double out2;                  /* Output coordinate value */
   double x0;                    /* Coordinate of grid centre */
   double y;                     /* Output coordinate (transformed) */
   double yfit;                  /* Coordinate resulting from fit */
   double z;                     /* Sum for calculating zero points */
   int *vertex;                  /* Pointer to flag array for vertices */
   int bad_output;               /* Does the Mapping output generate bad values? */
   int coord_in;                 /* Loop counter for input coordinates */
   int coord_out;                /* Loop counter for output coordinates. */
   int done;                     /* All vertices visited? */
   int face1;                    /* Index of first face coordinates */
   int face2;                    /* Index of second face coordinates */
   int face;                     /* Loop counter for faces */
   int ii;                       /* Index into gradient matrix */
   int linear;                   /* Mapping is linear? */
   int nc;                       /* Number of coeffs in fit */
   int ndim_in;                  /* Number of Mapping inputs */
   int ndim_out;                 /* Number of Mapping outputs */
   int npoint;                   /* Number of test points required */
   int point;                    /* Counter for points */
   int result;                   /* Returned flag */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialisation. */
   linear = 1;
   grad = NULL;
   zero = NULL;

/* Get the number of Mapping output and inputs. */
   ndim_in = astGetNin( this );
   ndim_out = astGetNout( this );

/* Store the number of coefficients in the fit.*/
   nc = ( ndim_in + 1 ) * ndim_out;

/* Initialise the supplied array to hold bad values. */
   for( ii = 0; ii < nc; ii++ ) fit[ ii ] = AST__BAD;

/* Create a PointSet to hold input coordinates and obtain a pointer
   to its coordinate arrays. */
   pset_in_f = astPointSet( 2 * ndim_in, ndim_in, "", status );
   ptr_in_f = astGetPoints( pset_in_f );
   if ( astOK ) {

/* Set up and transform an initial set of points. */
/* ---------------------------------------------- */
/* Loop to set up input coordinates at the centre of each face of the
   input grid, storing them in the PointSet created above. */
      point = 0;
      for ( face = 0; face < ( 2 * ndim_in ); face++ ) {
         for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
            ptr_in_f[ coord_in ][ point ] =
               0.5 * ( lbnd[ coord_in ] + ubnd[ coord_in ] );
         }
         ptr_in_f[ face / 2 ][ point ] = ( face % 2 ) ?
                                          ubnd[ face / 2 ] : lbnd[ face / 2 ];
         point++;
      }
   }

/* Transform these coordinates into the output grid's coordinate system
   and obtain an array of pointers to the resulting coordinate
   data. */
   pset_out_f = astTransform( this, pset_in_f, 1, NULL );
   ptr_out_f = astGetPoints( pset_out_f );
   if ( astOK ) {

/* Fit a linear approximation to the points. */
/* ----------------------------------------- */
/* Obtain pointers to the locations in the fit coefficients array
   where the gradients and zero points should be stored. */
      grad = fit + ndim_out;
      zero = fit;

/* On the assumption that the transformation applied above is
   approximately linear, loop to determine the matrix of gradients and
   the zero points which describe it. */
      ii = 0;
      for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
         bad_output = 0;
         z = 0.0;
         for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {

/* Find the indices of opposite faces in each input dimension. */
            face1 = 2 * coord_in;
            face2 = face1 + 1;

/* Obtain the input and output coordinates at these face centres. */
            in1 = ptr_in_f[ coord_in ][ face1 ];
            in2 = ptr_in_f[ coord_in ][ face2 ];
            out1 = ptr_out_f[ coord_out ][ face1 ];
            out2 = ptr_out_f[ coord_out ][ face2 ];

/* Check whether any transformed coordinates are bad. Mapping outputs
   that are bad at one or more test points have bad values stored for the
   corresponding coefficients in the returned fit, but do not invalidate
   the linearity of the fit to other outputs. */
            if ( ( out1 == AST__BAD ) || ( out2 == AST__BAD ) ) {
               bad_output = 1;
               break;
            }

/* If possible, determine the gradient along this dimension, storing
   it in the appropriate element of the gradient matrix. */
            indiff = in2 - in1;
            if ( indiff != 0.0 ) {
               grad[ ii++ ] = ( out2 - out1 ) / indiff;
            } else {
               grad[ ii++ ] = 0.0;
            }

/* Accumulate the sum used to determine the zero point. */
            z += ( out1 + out2 );
         }

/* Determine the average zero point from all dimensions. */
         if( !bad_output ) zero[ coord_out ] = z / (double) ( 2 * ndim_in );
      }

/* The zero points of the above fit will be appropriate to an input
   coordinate system with an origin at the centre of the input grid
   (we assume this to simplify the calculations above). To correct
   for this, we transform the actual input coordinates of the
   grid's centre through the matrix of gradients and subtract the
   resulting coordinates from the zero point values. The zero points
   are then correct for the actual output and input coordinate systems
   we are using. Also, if all Mapping outputs generate bad values, flag
   that we do not have a linear fit. */
      linear = 0;
      ii = 0;
      for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
         if( zero[ coord_out ] != AST__BAD ) {
            linear = 1;
            for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
               x0 = 0.5 * ( lbnd[ coord_in ] + ubnd[ coord_in ] );
               zero[ coord_out ] -= grad[ ii++ ] * x0;
            }
         } else {
            for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
               grad[ ii++ ] = AST__BAD;
            }
         }
      }
   }

/* Annul the pointers to the PointSets used above. */
   pset_out_f = astAnnul( pset_out_f );
   pset_in_f = astAnnul( pset_in_f );

/* Calculate the number of test points required. */
/* --------------------------------------------- */
/* The linear fit obtained above, will (by construction) be exact
   at the centre of each face of the input grid. However, it may
   not fit anywhere else. We therefore set up some test points to
   determine if it is an adequate approximation elsewhere. */
   if( astOK && linear ) {

/* Calculate the number of test points required to place one at each
   vertex of the grid. */
      npoint = 1;
      for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
         npoint *= 2;
      }

/* Now calculate the total number of test points required, also
   allowing one at the centre, one at half the distance to each face,
   and one at half the distance to each vertex. */
      npoint = 1 + 2 * ( ndim_in + npoint );

/* Set up test points in the input coordinate system. */
/* --------------------------------------------------- */
/* Create a PointSet to hold the test coordinates and obtain an array
   of pointers to its coordinate data. */
      pset_in_t = astPointSet( npoint, ndim_in, "", status );
      ptr_in_t = astGetPoints( pset_in_t );
      if ( astOK ) {

/* If the input array is 1-dimensional, the face and vertex positions
   calculated below will co-incide. Therefore, we simply distribute
   the required number of test points uniformly throughout the input
   coordinate range (avoiding the end-points, where the fit has been
   obtained). The coordinates are stored in the PointSet created
   above. */
         if ( ndim_in == 1 ) {
            for ( point = 0; point < npoint; point++ ) {
               frac = ( (double) ( point + 1 ) ) / (double) ( npoint + 1 );
               ptr_in_t[ 0 ][ point ] = ( 1.0 - frac ) * lbnd[ 0 ] +
                                         frac * ubnd[ 0 ];
            }

/* Otherwise, generate one point at the grid centre (offset slightly
   since the exact centre may not be very representative). */
         } else {
            point = 0;
            for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
               ptr_in_t[ coord_in ][ point ] =
                  0.49 * lbnd[ coord_in ] + 0.51 * ubnd[ coord_in ];
            }
            point++;

/* Similarly generate a point half way between the grid centre and the
   centre of each face. Again introduce some small random offsets to break
   any regularity in the grid. */
            for ( face = 0; face < ( 2 * ndim_in ); face++ ) {
               for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                  ptr_in_t[ coord_in ][ point ] =
                     0.48 * lbnd[ coord_in ] + 0.52 * ubnd[ coord_in ];
               }
               ptr_in_t[ face / 2 ][ point ] =
                        ( 0.51 * ( ( ( face % 2 ) ? ubnd[ face / 2 ] :
                                             lbnd[ face / 2 ] ) ) +
                          0.49 * ptr_in_t[ face / 2 ][ 0 ] );
               point++;
            }

/* Allocate workspace and initialise flags for identifying the
   vertices. */
            vertex = astMalloc( sizeof( int ) * (size_t) ndim_in );
            if ( astOK ) {
               for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                  vertex[ coord_in ] = 0;
               }

/* Now loop to visit each input grid vertex. */
               done = 0;
               do {

/* Generate a test point at each vertex. */
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     ptr_in_t[ coord_in ][ point ] = vertex[ coord_in ] ?
                                                       ubnd[ coord_in ] :
                                                       lbnd[ coord_in ];

/* Also place one half way between the grid centre and each vertex. */
                     ptr_in_t[ coord_in ][ point + 1 ] =
                             ( 0.52 * ptr_in_t[ coord_in ][ point ] +
                               0.48 * ptr_in_t[ coord_in ][ 0 ] );
                  }
                  point += 2;

/* Now update the array of vertex flags to identify the next vertex. */
                  coord_in = 0;
                  do {

/* The least significant dimension which does not have its upper bound
   as one of the vertex coordinates is changed to use its upper bound
   in the next vertex. */
                     if ( !vertex[ coord_in ] ) {
                        vertex[ coord_in ] = 1;
                        break;

/* Any less significant dimensions whose upper bounds are already
   being used are changed to use their lower bounds in the next
   vertex. */
                     } else {
                        vertex[ coord_in ] = 0;

/* All vertices have been visited when the most significant dimension
   is changed back to using its lower bound. */
                        done = ( ++coord_in == ndim_in );
                     }
                  } while ( !done );
               } while ( !done );
            }

/* Free the workspace used for vertex flags. */
            vertex = astFree( vertex );
         }

/* Transform the test points. */
/* -------------------------- */
/* Use the Mapping to transform the test points into the output grid's
   coordinate system, obtaining a pointer to the resulting arrays of
   output coordinates. */
         pset_out_t = astTransform( this, pset_in_t, 1, NULL );
         ptr_out_t = astGetPoints( pset_out_t );

/* Test the linear fit for accuracy. */
/* --------------------------------- */
/* If OK so far, then loop to use this fit to transform each test
   point and compare the result with the result of applying the
   Mapping. */
         if ( astOK ) {
            for ( point = 0; point < npoint; point++ ) {

/* Initialise the fitting error for the current point. */
               err = 0.0;

/* Obtain each output coordinate (produced by using the Mapping) in
   turn and check that it is not bad. If it is, then store bad values for
   the output's coefficients and pass on to the next output. */
               bad_output = 0;
               ii = 0;
               for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                  y = ptr_out_t[ coord_out ][ point ];
                  if ( y == AST__BAD || zero[ coord_out ] == AST__BAD ) {
                     zero[ coord_out ] = AST__BAD;
                     for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                        grad[ ii++ ] = AST__BAD;
                     }
                     bad_output++;
                     break;
                  }

/* Apply the fitted transformation to the input coordinates to obtain
   the approximate output coordinate value. */
                  yfit = zero[ coord_out ];
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     yfit += grad[ ii++ ] * ptr_in_t[ coord_in ][ point ];
                  }

/* Form the sum of squared differences between the Mapping's
   transformation and the fit. */
                  diff = ( y - yfit );
                  err += diff * diff;
               }

/* Test if the Cartesian distance between the true output coordinate
   and the approximate one exceeds the accuracy tolerance. If this
   happens for any test point, we declare the Mapping non-linear and
   give up. Reduce the allowed tolerance in proproprtion to the number of
   bad Mapping outputs that were found. */
               if ( sqrt( err ) > (tol*(ndim_out - bad_output))/ndim_out ) {
                  linear = 0;
                  break;
               }
            }
         }

/* Annul the pointers to the PointSets used above. */
         pset_out_t = astAnnul( pset_out_t );
      }
      pset_in_t = astAnnul( pset_in_t );

/* If all Mapping outputs generate bad values, return the coefficients of
   a unit transformation, but put a bad value into the constant term for each
   output. */
   } else if( astOK ){
      grad = fit + ndim_out;
      zero = fit;

      ii = 0;
      for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
         for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
            if ( coord_out == coord_in ) {
               grad[ ii++ ] = 1.0;
            } else {
               grad[ ii++ ] = 0.0;
            }
         }
         zero[ coord_out ] = AST__BAD;
      }
   }

/* If an error occurred, or the Mapping was found to be non-linear,
   then set the coefficients to AST_BAD. Otherwise, set the returned flag
   to indicate that the fit was succesful. */
   if ( !astOK || !linear ) {
      for( ii = 0; ii < nc; ii++ ) fit[ ii ] = AST__BAD;
   } else {
      result = 1;
   }

/* Return the result. */
   return result;
}

static double LocalMaximum( const MapData *mapdata, double acc, double fract,
                            double x[], int *status ) {
/*
*  Name:
*     LocalMaximum

*  Purpose:
*     Find a local maximum in a Mapping function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double LocalMaximum( const MapData *mapdata, double acc, double fract,
*                          double x[], int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function finds a local maximum in the Mapping function
*     supplied.  It employs the modified simplex method (as
*     implemented by UphillSimplex), but repeatedly re-starts the
*     simplex algorithm and tests for convergence of successive
*     maxima, so as to further improve robustness on difficult
*     problems.

*  Parameters:
*     mapdata
*        Pointer to a MapData structure describing the Mapping
*        function, its coordinate constraints, etc.
*     acc
*        The required accuracy with which the maximum is to be found.
*     fract
*        A value between 0.0 and 1.0 which determines the initial step
*        length along each coordinate axis. It should be given as a
*        fraction of the difference between the upper and lower
*        constraint values for each axis (as specified in the
*        "mapdata" structure).
*     x
*        Pointer to an array of double containing the coordinates of
*        an initial estimate of the position of the maximum. On exit,
*        this will be updated to contain the best estimate of the
*        maximum's position, as found by this function.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The best estimate of the Mapping function's maximum value.

*  Notes:
*     - A value of AST__BAD will be returned, and no useful
*     information about a solution will be produced, if this function
*     is invoked with the global error status set or if it should fail
*     for any reason.
*/

/* Local Constants: */
   const int maxcall = 1500;     /* Maximum number of function evaluations */
   const int maxiter = 5;        /* Maximum number of iterations */

/* Local Variables: */
   double *dx;                   /* Pointer to array of step lengths */
   double err;                   /* Simplex error estimate */
   double maximum;               /* Simplex maximum value */
   double middle;                /* Middle coordinate between bounds */
   double result;                /* Result value to return */
   int coord;                    /* Loop counter for coordinates */
   int done;                     /* Iterations complete? */
   int iter;                     /* Loop counter for iterations */
   int ncall;                    /* Number of function calls (junk) */

/* Initialise. */
   result = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialise to avoid compiler warnings. */
   err = 0.0;

/* Allocate workspace. */
   dx = astMalloc( sizeof( double ) * (size_t) mapdata->nin );

/* Perform iterations to repeatedly identify a local maximum. */
   for ( iter = 0; astOK && ( iter < maxiter ); iter++ ) {

/* Set up initial step lengths along each coordinate axis, adjusting
   their signs to avoid placing points outside the coordinate
   constraints (i.e. step away from the closer boundary on each
   axis). */
      for ( coord = 0; coord < mapdata->nin; coord++ ) {
         middle = 0.5 * ( mapdata->lbnd[ coord ] + mapdata->ubnd[ coord ] );
         dx[ coord ] = fract * ( mapdata->ubnd[ coord ] -
                                 mapdata->lbnd[ coord ] );
         if ( x[ coord ] > middle ) dx[ coord ] = -dx[ coord ];
      }

/* Find an approximation to a local maximum using the simplex method
   and check for errors. */
      maximum = UphillSimplex( mapdata, acc, maxcall, dx, x, &err, &ncall, status );
      if ( astOK ) {

/* Use this maximum value if no previous maximum has been found. */
         if ( result == AST__BAD ) {
            result = maximum;

/* Otherwise use it only if it improves on the previous maximum. */
         } else if ( maximum >= result ) {

/* We iterate, re-starting the simplex algorithm from its previous
   best position so as to guard against premature false
   convergence. Iterations continue until the improvement in the
   maximum is no greater than the required accuracy (and the simplex
   algorithm itself has converged to the required accuracy). Note when
   iterations should cease. */
            done = ( ( ( maximum - result ) <= acc ) && ( err <= acc ) );

/* Store the best maximum and quit iterating if appropriate. */
            result = maximum;
            if ( done ) break;
         }

/* Otherwise, decrement the initial step size for the next iteration. */
         fract /= 1000.0;
      }
   }

/* Free the workspace. */
   dx = astFree( dx );

/* If an error occurred, clear the result value. */
   if ( !astOK ) result = AST__BAD;

/* return the result. */
   return result;
}

static void MapBox( AstMapping *this,
                    const double lbnd_in[], const double ubnd_in[],
                    int forward, int coord_out,
                    double *lbnd_out, double *ubnd_out,
                    double xl[], double xu[], int *status ) {
/*
*+
*  Name:
*     astMapBox

*  Purpose:
*     Find a bounding box for a Mapping.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     void astMapBox( AstMapping *this,
*                     const double lbnd_in[], const double ubnd_in[],
*                     int forward, int coord_out,
*                     double *lbnd_out, double *ubnd_out,
*                     double xl[], double xu[] );

*  Class Membership:
*     Mapping method.

*  Description:
*     This function allows you to find the "bounding box" which just
*     encloses another box after it has been transformed by a Mapping
*     (using either its forward or inverse transformation). A typical
*     use might be to calculate the size which an image would have
*     after being transformed by the Mapping.
*
*     The function works on one dimension at a time. When supplied
*     with the lower and upper bounds of a rectangular region (box) of
*     input coordinate space, it finds the lowest and highest values
*     taken by a nominated output coordinate within that
*     region. Optionally, it also returns the input coordinates where
*     these bounding values are attained. It should be used repeatedly
*     if the extent of the bounding box is required in more than one
*     dimension.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     lbnd_in
*        Pointer to an array of double, with one element for each
*        Mapping input coordinate. This should contain the lower bound
*        of the input box in each dimension.
*     ubnd_in
*        Pointer to an array of double, with one element for each
*        Mapping input coordinate. This should contain the upper bound
*        of the input box in each dimension.
*
*        Note that it is permissible for the lower bound to exceed the
*        corresponding upper bound, as the values will simply be
*        swapped before use.
*     forward
*        If this value is non-zero, then the Mapping's forward
*        transformation will be used to transform the input
*        box. Otherwise, its inverse transformation will be used.
*
*        (If the inverse transformation is selected, then references
*        to "input" and "output" coordinates in this description
*        should be transposed. For example, the size of the "lbnd_in"
*        and "ubnd_in" arrays should match the number of output
*        coordinates, as given by the Mapping's Nout attribute.)
*     coord_out
*        The (zero-based) index of the output coordinate for which the
*        lower and upper bounds are required.
*     lbnd_out
*        Pointer to a double in which to return the lowest value taken
*        by the nominated output coordinate within the specified
*        region of input coordinate space.
*     ubnd_out
*        Pointer to a double in which to return the highest value
*        taken by the nominated output coordinate within the specified
*        region of input coordinate space.
*     xl
*        An optional pointer to an array of double, with one element
*        for each Mapping input coordinate. If given, this array will
*        be filled with the coordinates of an input point (although
*        not necessarily a unique one) for which the nominated output
*        coordinate takes the lower bound value returned in
*        "*lbnd_out".
*
*        If these coordinates are not required, a NULL pointer may be
*        supplied.
*     xu
*        An optional pointer to an array of double, with one element
*        for each Mapping input coordinate. If given, this array will
*        be filled with the coordinates of an input point (although
*        not necessarily a unique one) for which the nominated output
*        coordinate takes the upper bound value returned in
*        "*ubnd_out".
*
*        If these coordinates are not required, a NULL pointer may be
*        supplied.

*  Notes:
*     - Any input points which are transformed by the Mapping to give
*     output coordinates containing the value AST__BAD are regarded as
*     invalid and are ignored, They will make no contribution to
*     determining the output bounds, even although the nominated
*     output coordinate might still have a valid value at such points.
*     - An error will occur if the required output bounds cannot be
*     found. Typically, this might occur if all the input points which
*     the function considers turn out to be invalid (see above). The
*     number of points considered before generating such an error is
*     quite large, however, so this is unlikely to occur by accident
*     unless valid points are restricted to a very small subset of the
*     input coordinate space.
*     - The values returned via "lbnd_out", "ubnd_out", "xl" and "xu"
*     will be set to the value AST__BAD if this function should fail
*     for any reason. Their initial values on entry will not be
*     altered if the function is invoked with the global error status
*     set.
*-

*  Implementation Notes:
*     - This function implements the basic astMapBox method available
*     via the protected interface to the Mapping class. The public
*     interface to this method is provided by the astMapBoxId_
*     function.
*/

/* Local Variables: */
   MapData mapdata;              /* Structure to describe Mapping function */
   double *x_l;                  /* Pointer to coordinate workspace */
   double *x_u;                  /* Pointer to coordinate workspace */
   double lbnd;                  /* Required lower bound */
   double ubnd;                  /* Required upper bound */
   int coord;                    /* Loop counter for coordinates. */
   int nin;                      /* Effective number of input coordinates */
   int nout;                     /* Effective number of output coordinates */
   int refine;                   /* Can bounds be refined? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Initialisation to avoid compiler warnings. */
   lbnd = AST__BAD;
   ubnd = AST__BAD;

/* Obtain the effective numbers of input and output coordinates for
   the Mapping, taking account of which transformation is to be
   used. */
   nin = forward ? astGetNin( this ) : astGetNout( this );
   nout = forward ? astGetNout( this ) : astGetNin( this );

/* Check that the output coordinate index supplied is valid and report
   an error if it is not. Use public (one-based) coordinate numbering
   in the error message. */
   if ( astOK ) {
      if ( ( coord_out < 0 ) || ( coord_out >= nout ) ) {
         astError( AST__BADCI, "astMapBox(%s): Output coordinate index (%d) "
                   "invalid - it should be in the range 1 to %d.", status,
                   astGetClass( this ), coord_out + 1, nout );
      }
   }

/* Initialise a MapData structure to describe the Mapping function
   whose limits are to be found.  Since it may be evaluated many
   times, we attempt to simplify the Mapping supplied. */
   if ( astOK ) {
      mapdata.mapping = astSimplify( this );

/* Store the number of input/output coordinates and the index of the
   output coordinate in which we are interested. */
      mapdata.nin = nin;
      mapdata.nout = nout;
      mapdata.coord = coord_out;

/* Note which Mapping transformation is being used. */
      mapdata.forward = forward;

/* Store pointers to arrays which will contain the input coordinate
   bounds. */
      mapdata.lbnd = astMalloc( sizeof( double ) * (size_t) nin );
      mapdata.ubnd = astMalloc( sizeof( double ) * (size_t) nin );

/* Create PointSets for passing coordinate data to and from the
   Mapping. */
      mapdata.pset_in = astPointSet( 1, nin, "", status );
      mapdata.pset_out = astPointSet( 1, nout, "", status );

/* Obtain pointers to these PointSets' coordinate arrays. */
      mapdata.ptr_in = astGetPoints( mapdata.pset_in );
      mapdata.ptr_out = astGetPoints( mapdata.pset_out );

/* Allocate workspace for the returned input coordinates. */
      x_l = astMalloc( sizeof( double ) * (size_t) nin );
      x_u = astMalloc( sizeof( double ) * (size_t) nin );
      if ( astOK ) {

/* Initialise the output bounds and corresponding input coordinates to
   "unknown". */
         for ( coord = 0; coord < nin; coord++ ) {
            x_l[ coord ] = AST__BAD;
            x_u[ coord ] = AST__BAD;

/* Initialise the input bounds, ensuring they are the correct way
   around (if not already supplied this way). */
            mapdata.lbnd[ coord ] = ( lbnd_in[ coord ] < ubnd_in[ coord ] ) ?
                                      lbnd_in[ coord ] : ubnd_in[ coord ];
            mapdata.ubnd[ coord ] = ( ubnd_in[ coord ] > lbnd_in[ coord ] ) ?
                                      ubnd_in[ coord ] : lbnd_in[ coord ];
         }

/* First examine a set of special input points to obtain an initial
   estimate of the required output bounds. Do this only so long as the
   number of points involved is not excessive. */
         if ( nin <= 12 ) {
            refine = SpecialBounds( &mapdata, &lbnd, &ubnd, x_l, x_u, status );
         } else {
            refine = 1;
         }

/* Then attempt to refine this estimate using a global search
   algorithm. */
         if( refine ) GlobalBounds( &mapdata, &lbnd, &ubnd, x_l, x_u, status );

/* If an error occurred, generate a contextual error message. */
         if ( !astOK ) {
            astError( astStatus, "Unable to find a bounding box for a %s.", status,
                      astGetClass( this ) );
         }
      }

/* Return the output bounds and, if required, the input coordinate
   values which correspond with them. */
      if ( astOK ) {
         *lbnd_out = lbnd;
         *ubnd_out = ubnd;
         for ( coord = 0; coord < nin; coord++ ) {
            if ( xl ) xl[ coord ] = x_l[ coord ];
            if ( xu ) xu[ coord ] = x_u[ coord ];
         }
      }

/* Annul the simplified Mapping pointer and the temporary
   PointSets. Also free the workspace. */
      mapdata.mapping = astAnnul( mapdata.mapping );
      mapdata.lbnd = astFree( mapdata.lbnd );
      mapdata.ubnd = astFree( mapdata.ubnd );
      mapdata.pset_in = astAnnul( mapdata.pset_in );
      mapdata.pset_out = astAnnul( mapdata.pset_out );
      x_l = astFree( x_l );
      x_u = astFree( x_u );
   }

/* If an error occurred, then return bad bounds values and
   coordinates. */
   if ( !astOK ) {
      *lbnd_out = AST__BAD;
      *ubnd_out = AST__BAD;
      for ( coord = 0; coord < nin; coord++ ) {
         if ( xl ) xl[ coord ] = AST__BAD;
         if ( xu ) xu[ coord ] = AST__BAD;
      }
   }
}

static double MapFunction( const MapData *mapdata, const double in[],
                           int *ncall, int *status ) {
/*
*  Name:
*     MapFunction

*  Purpose:
*     Return the value of a selected transformed coordinate.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double MapFunction( const MapData *mapdata, const double in[],
*                         int *ncall, int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function takes a set of input coordinates and applies a
*     Mapping's coordinate transformation to them. It then returns the
*     value of one of the transformed coordinates.
*
*     It is provided for use by optimisation functions (e.g. those
*     used for finding bounding boxes). The Mapping to be used and
*     associated parameters (such as constraints on the range of input
*     coordinates and the index of the output coordinate to be
*     returned) are supplied in a MapData structure. The value
*     returned will be negated if the "negate" component of this
*     structure is non-zero.
*
*     The value AST__BAD will be returned by this function if the
*     input coordinates lie outside the constrained range given in
*     the MapData structure, or if any of the transformed output
*     coordinates is bad.

*  Parameters:
*     mapdata
*        Pointer to a MapData structure which describes the Mapping to
*        be used.
*     in
*        A double array containing the input coordinates of a single point.
*     ncall
*        Pointer to an int containing a count of the number of times
*        the Mapping's coordinate transformation has been used. This
*        value will be updated to reflect any use made by this
*        function. Normally, this means incrementing the value by 1,
*        but this will be omitted if the input coordinates supplied
*        are outside the constrained range so that no transformation
*        is performed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The selected output coordinate value, or AST__BAD, as appropriate.

*  Notes:
*     - A value of AST__BAD will be returned if this function is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*/

/* Local Variables: */
   double result;                /* Result to be returned */
   int bad;                      /* Output coordinates invalid? */
   int coord_in;                 /* Loop counter for input coordinates */
   int coord_out;                /* Loop counter for output coordinates */
   int outside;                  /* Input point outside bounds? */

/* Initialise. */
   result = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return result;

/* See if the input point lies outside the required bounds. */
   outside = 0;
   for ( coord_in = 0; coord_in < mapdata->nin; coord_in++ ) {
      if ( ( in[ coord_in ] < mapdata->lbnd[ coord_in ] ) ||
           ( in[ coord_in ] > mapdata->ubnd[ coord_in ] ) ) {
         outside = 1;
         break;
      }

/* Also store the input coordinates in the memory associated with the
   Mapping's input PointSet. */
      mapdata->ptr_in[ coord_in ][ 0 ] = in[ coord_in ];
   }

/* If the input coordinates are within bounds, transform them, using the
   PointSets identified in the "mapdata" structure. */
   if ( !outside ) {
      (void) astTransform( mapdata->mapping, mapdata->pset_in,
                           mapdata->forward, mapdata->pset_out );

/* Increment the number of calls to astTransform and check the error
   status. */
      ( *ncall )++;
      if ( astOK ) {

/* If OK, test if any of the output coordinates is bad. */
         bad = 0;
         for ( coord_out = 0; coord_out < mapdata->nout; coord_out++ ) {
            if ( mapdata->ptr_out[ coord_out ][ 0 ] == AST__BAD ) {
               bad = 1;
               break;
            }
         }

/* If not, then extract the required output coordinate, negating it if
   necessary. */
         if ( !bad ) {
            result = mapdata->ptr_out[ mapdata->coord ][ 0 ];
            if ( mapdata->negate ) result = -result;
         }
      }
   }

/* Return the result. */
   return result;
}

static int MapList( AstMapping *this, int series, int invert, int *nmap,
                     AstMapping ***map_list, int **invert_list, int *status ) {
/*
*+
*  Name:
*     astMapList

*  Purpose:
*     Decompose a Mapping into a sequence of simpler Mappings.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astMapList( AstMapping *this, int series, int invert, int *nmap,
*                      AstMapping ***map_list, int **invert_list )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function decomposes a Mapping (which, in derived classes,
*     may be a compound Mapping) into a sequence of simpler Mappings
*     which may be applied in sequence to achieve the same effect. The
*     Mapping is decomposed as far as possible, but it is not
*     guaranteed that this will necessarily yield any more than one
*     Mapping, which may actually be the original one supplied.
*
*     This function is provided to support both the simplification of
*     compound Mappings, and the analysis of Mapping structure so that
*     particular forms can be recognised.

*  Parameters:
*     this
*        Pointer to the Mapping to be decomposed (the Mapping is not
*        actually modified by this function).
*     series
*        If this value is non-zero, an attempt will be made to
*        decompose the Mapping into a sequence of equivalent Mappings
*        which can be applied in series (i.e. one after the other). If
*        it is zero, the decomposition will instead yield Mappings
*        which can be applied in parallel (i.e. on successive sub-sets
*        of the input/output coordinates).
*     invert
*        The value to which the Mapping's Invert attribute is to be
*        (notionally) set before performing the
*        decomposition. Normally, the value supplied here will be the
*        actual Invert value obtained from the Mapping (e.g. using
*        astGetInvert).  Sometimes, however, when a Mapping is
*        encapsulated within another structure, that structure may
*        retain an Invert value (in order to prevent external
*        interference) which should be used instead.
*
*        Note that the actual Invert value of the Mapping supplied is
*        not used (or modified) by this function.
*     nmap
*        The address of an int which holds a count of the number of
*        individual Mappings in the decomposition. On entry, this
*        should count the number of Mappings already in the
*        "*map_list" array (below). On exit, it is updated to include
*        any new Mappings appended by this function.
*     map_list
*        Address of a pointer to an array of Mapping pointers. On
*        entry, this array pointer should either be NULL (if no
*        Mappings have yet been obtained) or should point at a
*        dynamically allocated array containing Mapping pointers
*        ("*nmap" in number) which have been obtained from a previous
*        invocation of this function.
*
*        On exit, the dynamic array will be enlarged to contain any
*        new Mapping pointers that result from the decomposition
*        requested. These pointers will be appended to any previously
*        present, and the array pointer will be updated as necessary
*        to refer to the enlarged array (any space released by the
*        original array will be freed automatically).
*
*        The new Mapping pointers returned will identify a sequence of
*        Mappings which, when applied in order, will perform a forward
*        transformation equivalent to that of the original Mapping
*        (after its Invert flag has first been set to the value
*        requested above). The Mappings should be applied in series or
*        in parallel according to the type of decomposition requested.
*
*        All the Mapping pointers returned by this function should be
*        annulled by the caller, using astAnnul, when no longer
*        required. The dynamic array holding these pointers should
*        also be freed, using astFree.
*     invert_list
*        Address of a pointer to an array of int. On entry, this array
*        pointer should either be NULL (if no Mappings have yet been
*        obtained) or should point at a dynamically allocated array
*        containing Invert attribute values ("*nmap" in number) which
*        have been obtained from a previous invocation of this
*        function.
*
*        On exit, the dynamic array will be enlarged to contain any
*        new Invert attribute values that result from the
*        decomposition requested. These values will be appended to any
*        previously present, and the array pointer will be updated as
*        necessary to refer to the enlarged array (any space released
*        by the original array will be freed automatically).
*
*        The new Invert values returned identify the values which must
*        be assigned to the Invert attributes of the corresponding
*        Mappings (whose pointers are in the "*map_list" array) before
*        they are applied. Note that these values may differ from the
*        actual Invert attribute values of these Mappings, which are
*        not relevant.
*
*        The dynamic array holding these values should be freed by the
*        caller, using astFree, when no longer required.

*  Returned Value:
*     A non-zero value is returned if the supplied Mapping contained any
*     inverted CmpMaps.

*  Notes:
*     - It is unspecified to what extent the original Mapping and the
*     individual (decomposed) Mappings are
*     inter-dependent. Consequently, the individual Mappings cannot be
*     modified without risking modification of the original.
*     - If this function is invoked with the global error status set,
*     or if it should fail for any reason, then the *nmap value, the
*     list of Mapping pointers and the list of Invert values will all
*     be returned unchanged.
*-
*/

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Since we are dealing with a basic Mapping, only one new Mapping
   pointer will be returned. Extend the dynamic arrays to accommodate
   this Mapping. */
   *map_list = astGrow( *map_list, *nmap + 1, sizeof( AstMapping * ) );
   *invert_list = astGrow( *invert_list, *nmap + 1, sizeof( int ) );
   if ( astOK ) {

/* Return the invert flag value for the Mapping and a clone of the
   Mapping pointer. */
      ( *invert_list )[ *nmap ] = ( invert != 0 );
      ( *map_list )[ *nmap ] = astClone( this );

/* If OK, return the new Mapping count. */
      if ( astOK ) ( *nmap )++;
   }

   return 0;
}

static int MapMerge( AstMapping *this, int where, int series, int *nmap,
                     AstMapping ***map_list, int **invert_list, int *status ) {
/*
*+
*  Name:
*     astMapMerge

*  Purpose:
*     Simplify a sequence of Mappings.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int astMapMerge( AstMapping *this, int where, int series, int *nmap,
*                      AstMapping ***map_list, int **invert_list )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function attempts to simplify a sequence of Mappings by
*     merging a nominated Mapping in the sequence with its neighbours,
*     so as to shorten the sequence if possible.
*
*     In many cases, simplification will not be possible and the
*     function will return -1 to indicate this, without further
*     action.
*
*     In most cases of interest, however, this function will either
*     attempt to replace the nominated Mapping with one which it
*     considers simpler, or to merge it with the Mappings which
*     immediately precede it or follow it in the sequence (both will
*     normally be considered). This is sufficient to ensure the
*     eventual simplification of most Mapping sequences by repeated
*     application of this function.
*
*     In some cases, the function may attempt more elaborate
*     simplification, involving any number of other Mappings in the
*     sequence. It is not restricted in the type or scope of
*     simplification it may perform, but will normally only attempt
*     elaborate simplification in cases where a more straightforward
*     approach is not adequate.

*  Parameters:
*     this
*        Pointer to the nominated Mapping which is to be merged with
*        its neighbours. This should be a cloned copy of the Mapping
*        pointer contained in the array element "(*map_list)[where]"
*        (see below). This pointer will not be annulled, and the
*        Mapping it identifies will not be modified by this function.
*     where
*        Index in the "*map_list" array (below) at which the pointer
*        to the nominated Mapping resides.
*     series
*        A non-zero value indicates that the sequence of Mappings to
*        be simplified will be applied in series (i.e. one after the
*        other), whereas a zero value indicates that they will be
*        applied in parallel (i.e. on successive sub-sets of the
*        input/output coordinates).
*     nmap
*        Address of an int which counts the number of Mappings in the
*        sequence. On entry this should be set to the initial number
*        of Mappings. On exit it will be updated to record the number
*        of Mappings remaining after simplification.
*     map_list
*        Address of a pointer to a dynamically allocated array of
*        Mapping pointers (produced, for example, by the astMapList
*        method) which identifies the sequence of Mappings. On entry,
*        the initial sequence of Mappings to be simplified should be
*        supplied.
*
*        On exit, the contents of this array will be modified to
*        reflect any simplification carried out. Any form of
*        simplification may be performed. This may involve any of: (a)
*        removing Mappings by annulling any of the pointers supplied,
*        (b) replacing them with pointers to new Mappings, (c)
*        inserting additional Mappings and (d) changing their order.
*
*        The intention is to reduce the number of Mappings in the
*        sequence, if possible, and any reduction will be reflected in
*        the value of "*nmap" returned. However, simplifications which
*        do not reduce the length of the sequence (but improve its
*        execution time, for example) may also be performed, and the
*        sequence might conceivably increase in length (but normally
*        only in order to split up a Mapping into pieces that can be
*        more easily merged with their neighbours on subsequent
*        invocations of this function).
*
*        If Mappings are removed from the sequence, any gaps that
*        remain will be closed up, by moving subsequent Mapping
*        pointers along in the array, so that vacated elements occur
*        at the end. If the sequence increases in length, the array
*        will be extended (and its pointer updated) if necessary to
*        accommodate any new elements.
*
*        Note that any (or all) of the Mapping pointers supplied in
*        this array may be annulled by this function, but the Mappings
*        to which they refer are not modified in any way (although
*        they may, of course, be deleted if the annulled pointer is
*        the final one).
*     invert_list
*        Address of a pointer to a dynamically allocated array which,
*        on entry, should contain values to be assigned to the Invert
*        attributes of the Mappings identified in the "*map_list"
*        array before they are applied (this array might have been
*        produced, for example, by the astMapList method). These
*        values will be used by this function instead of the actual
*        Invert attributes of the Mappings supplied, which are
*        ignored.
*
*        On exit, the contents of this array will be updated to
*        correspond with the possibly modified contents of the
*        "*map_list" array.  If the Mapping sequence increases in
*        length, the "*invert_list" array will be extended (and its
*        pointer updated) if necessary to accommodate any new
*        elements.

*  Returned Value:
*     If simplification was possible, the function returns the index
*     in the "map_list" array of the first element which was
*     modified. Otherwise, it returns -1 (and makes no changes to the
*     arrays supplied).

*  Notes:
*     - A value of -1 will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* This is the default method which is inherited by all Mappings which
   do not explicitly provide their own simplification method. Return
   -1 to indicate that no simplification is provided. */
   return -1;
}

static int *MapSplit( AstMapping *this, int nin, const int *in,
                      AstMapping **map, int *status ){
/*
*+
*  Name:
*     astMapSplit

*  Purpose:
*     Create a Mapping representing a subset of the inputs of an existing
*     Mapping.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     int *astMapSplit( AstMapping *this, int nin, const int *in,
*                       AstMapping **map )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function creates a new Mapping by picking specified inputs from
*     an existing Mapping. This is only possible if the specified inputs
*     correspond to some subset of the Mapping outputs. That is, there
*     must exist a subset of the Mapping outputs for which each output
*     depends only on the selected Mapping inputs, and not on any of the
*     inputs which have not been selected. Also, any output which is not in
*     this subset must not depend on any of the selected inputs. If these
*     conditions are not met by the supplied Mapping, then a NULL Mapping
*     is returned.

*  Parameters:
*     this
*        Pointer to the Mapping to be split (the Mapping is not
*        actually modified by this function).
*     nin
*        The number of inputs to pick from "this".
*     in
*        Pointer to an array of indices (zero based) for the inputs which
*        are to be picked. This array should have "nin" elements. If "Nin"
*        is the number of inputs of the supplied Mapping, then each element
*        should have a value in the range zero to Nin-1.
*     map
*        Address of a location at which to return a pointer to the new
*        Mapping. This Mapping will have "nin" inputs (the number of
*        outputs may be differetn to "nin"). A NULL pointer will be
*        returned if the supplied Mapping has no subset of outputs which
*        depend only on the selected inputs. The returned Mapping is a
*        deep copy of the required parts of the supplied Mapping.

*  Returned Value:
*     A pointer to a dynamically allocated array of ints. The number of
*     elements in this array will equal the number of outputs for the
*     returned Mapping. Each element will hold the index of the
*     corresponding output in the supplied Mapping. The array should be
*     freed using astFree when no longer needed. A NULL pointer will
*     be returned if no output Mapping can be created.

*  Notes:
*     - If this function is invoked with the global error status set,
*     or if it should fail for any reason, then NULL values will be
*     returned as the function value and for the "map" pointer.
*-

*  Implementation Notes:
*     - This function implements the basic astMapSplit method available
*     via the protected interface to the Mapping class. The public
*     interface to this method is provided by the astMapSplitId_
*     function.
*/

/* Local Variables: */
   AstCmpMap *rmap;           /* Unsimplified result mapping */
   AstPermMap *pm;            /* PermMap which rearranges the inputs */
   int *outperm;              /* PermMap output axis permutation array */
   int *result;               /* Pointer to returned array */
   int iin;                   /* Input index */
   int iout;                  /* Output index */
   int mapnin;                /* Number of Mapping inputs */
   int nout;                  /* No of outputs */
   int ok;                    /* Can the supplied "in" array be used? */
   int perm;                  /* Are the inputs permuted? */

/* Initialise */
   result = NULL;
   *map = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Verify the input axis indices.*/
   mapnin = astGetNin( this );
   for( iin = 0; iin < nin; iin++ ){
      if( in[ iin ] < 0 || in[ iin ] >= mapnin ) {
         astError( AST__AXIIN, "astMapSplit(%s): One of the supplied Mapping "
                   "input indices has value %d which is invalid; it should "
                   "be in the range 1 to %d.", status, astGetClass( this ),
                   in[ iin ] + 1, mapnin );
         break;
      }
   }

/* Since we are dealing with a basic Mapping, we can only create the
   required output Mapping if all inputs are being selected. */
   if( nin == mapnin ) {

/* The inputs may have been selected in a different order to that in
   which they occur in the supplied Mapping. We therefore create a
   PermMap which rearranges the inputs into the order they have in the
   supplied Mapping. The supplied "in" array can act as the PermMap's
   "inperm" array. Allocate memory for the "outperm" array. */
      outperm = astMalloc( sizeof(int)*(size_t) nin );
      if( astOK ) {

/* Store the input index for each output in the outperm array and check that
   each input has been selected once and only once. Also set a flag
   indicating if a PermMap is needed. */
         perm = 0;
         ok = 1;
         for( iout = 0; iout < nin; iout++ ) outperm[ iout ] = -1;
         for( iin = 0; iin < nin; iin++ ) {
            iout = in[ iin ];
            if( outperm[ iout ] != -1 ) {
               ok = 0;
               break;
            } else {
               outperm[ iout ] = iin;
            }
         }
         for( iout = 0; iout < nin; iout++ ) {
            if( outperm[ iout ] == -1 ) {
               ok = 0;
               break;
            } else if( outperm[ iout ] != iout ) {
               perm = 1;
            }
         }
         if( ok ) {

/* Allocate the array to hold the returned output indices. */
            nout = astGetNout( this );
            result = astMalloc( sizeof(int)*(size_t) nout );
            if( astOK ) {

/* The outputs are copied from the supplied Mapping. */
               for( iout = 0; iout < nout; iout++ ) result[ iout ] = iout;

/* If the inputs are to be permuted, create the PermMap. */
               if( perm ) {
                  pm = astPermMap( nin, in, nin, outperm, NULL, "", status );

/* The returned Mapping is a series CmpMap containing this PermMap
   followed by the supplied Mapping. */
                  rmap = astCmpMap( pm, this, 1, "", status );
                  *map = astSimplify( rmap );
                  rmap = astAnnul( rmap );

/* Annul the PermMap pointer. */
                  pm = astAnnul( pm );

/* If no input permutation is needed, the resturned Mapping is just the
   supplied Mapping. */
               } else {
                  *map = astClone( this );
               }
            }
         }

/* Free resources. */
         outperm = astFree( outperm );
      }
   }

/* Free resources if an error has occurred. */
   if( !astOK ) {
      result = astFree( result );
      *map = astAnnul( *map );
   }

/* Return the list of output indices. */
   return result;
}

static double MatrixDet( int nrow, int ncol, const double *matrix, int *status ){
/*
*  Name:
*     MatrixDet

*  Purpose:
*     Return the determinant of a matrix.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double MatrixDet( int nrow, int ncol, const double *matrix, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function returns the determinant of the supplied matrix. Any
*     rows or columns that hold only zeros or AST_BAD values are first
*     removed from the matrix. If the resulting matrix is not square, a
*     value of AST__BAD is returned for the determinant.

*  Parameters:
*     nrow
*        The number of rows in the matrix.
*     ncol
*        The number of columns in the matrix.
*     matrix
*        The matrix element values. The first row of "ncol" elements
*        should be supplied first, followed by the second row, etc.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The determinant, or AST__BAD if the determinant could not be
*     caclculated.
*/

/* Local Variables: */
   const double *sqmat;
   const double *m;
   double *a;
   double *y;
   double result;
   int *iw;
   int *usecol;
   int *userow;
   int i;
   int icol;
   int irow;
   int jf;
   int ncoluse;
   int ndim;
   int nrowuse;

/* Initialise */
   result = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Initialise... */
   sqmat = NULL;
   nrowuse = 0;
   ncoluse = 0;

/* Flag any rows and columns that should be ignored because they contain
   only bad values or zeros. */
   userow = astCalloc( nrow, sizeof( *userow ) );
   usecol = astCalloc( ncol, sizeof( *userow ) );
   if( astOK ) {
      m = matrix;
      for( irow = 0; irow < nrow; irow++ ) {
         for( icol = 0; icol < ncol; icol++,m++ ) {
            if( *m != AST__BAD && *m != 0.0 ) {
               usecol[ icol ] = 1;
               userow[ irow ] = 1;
            }
         }
      }

/* Find the number of usable rows and columns. */
      for( irow = 0; irow < nrow; irow++ ) {
         if( userow[ irow ] ) nrowuse++;
      }

      for( icol = 0; icol < ncol; icol++ ) {
         if( usecol[ icol ] ) ncoluse++;
      }
   }

/* Return AST__BAD if the resulting matrix is not square. */
   if( ncoluse == nrowuse ) {
      ndim = ncoluse;

/* If any rows or columns contained just bad or zero values, create a new
   matrix that excludes them. */
      if( ncol > ndim || nrow > ndim ) {
         sqmat = astMalloc( ndim*ndim*sizeof(*sqmat) );
         if( astOK ) {
            m = matrix;
            a = (double *) sqmat;
            for( irow = 0; irow < nrow; irow++ ) {
               if( userow[ irow ] ) {
                  for( icol = 0; icol < ncol; icol++,m++ ) {
                     if( usecol[ icol ] ) *(a++) = *m;
                  }
               } else {
                  m += ncol;
               }
            }
         }

/* If no rows or columns contained just bad values, use the supplied
   matrix. */
      } else {
         sqmat = matrix;
      }

/* Calculate the determinant of the modified matrix */
      if( ndim == 1 ) {
         result = sqmat[ 0 ];

      } else if( ndim == 2 ) {
         result = sqmat[ 0 ]*sqmat[ 3 ] - sqmat[ 1 ]*sqmat[ 2 ];

      } else {
         a = astStore( NULL, sqmat, sizeof( double )*(size_t) (ndim*ndim) );
         iw = astMalloc( sizeof( int )*(size_t) ndim );
         y = astMalloc( sizeof( double )*(size_t) ndim );
         if( y ) {
            for( i = 0; i < ndim; i++ ) y[ i ] = 1.0;
            palDmat( ndim, a, y, &result, &jf, iw );
         }
         y = astFree( y );
         iw = astFree( iw );
         a = astFree( a );
      }

   }

/* Free the square matrix if it was allocated here. */
   if( sqmat != matrix ) sqmat = astFree( (void *) sqmat );

/* Free the usable row/column flags. */
   userow = astFree( userow );
   usecol = astFree( usecol );

   return result;
}

static double MaxD( double a, double b, int *status ) {
/*
*  Name:
*     MaxD

*  Purpose:
*     Return the maximum of two double values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double MaxD( double a, double b, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function returns the maximum of two double values.

*  Parameters:
*     a
*        The first value.
*     b
*        The second value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The maximum.
*/

/* Return the larger value. */
   return ( a > b ) ? a : b;
}

static int MaxI( int a, int b, int *status ) {
/*
*  Name:
*     MaxI

*  Purpose:
*     Return the maximum of two integer values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int MaxI( int a, int b, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function returns the maximum of two integer values.

*  Parameters:
*     a
*        The first value.
*     b
*        The second value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The maximum.
*/

/* Return the larger value. */
   return ( a > b ) ? a : b;
}

static int MinI( int a, int b, int *status ) {
/*
*  Name:
*     MinI

*  Purpose:
*     Return the minimum of two integer values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int MinI( int a, int b, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function returns the minimum of two integer values.

*  Parameters:
*     a
*        The first value.
*     b
*        The second value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The minimum.
*/

/* Return the smaller value. */
   return ( a < b ) ? a : b;
}

static double NewVertex( const MapData *mapdata, int lo, double scale,
                         double x[], double f[], int *ncall, double xnew[], int *status ) {
/*
*  Name:
*     NewVertex

*  Purpose:
*     Locate a new vertex for a simplex.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double NewVertex( const MapData *mapdata, int lo, double scale,
*                       double x[], double f[], int *ncall, double xnew[], int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function is provided for use during optimisation of a
*     Mapping function using the simplex method. It generates the
*     coordinates of a new simplex vertex and evaluates the Mapping
*     function at that point.  If the function's value is better then
*     (i.e. larger than) the value at the previously worst vertex,
*     then it is used to replace that vertex.

*  Parameters:
*     mapdata
*        Pointer to a MapData structure which describes the Mapping
*        function to be used.
*     lo
*        The (zero-based) index of the simplex vertex which initially
*        has the worst (lowest) value.
*     scale
*        The scale factor to be used to generate the new vertex. The
*        distance of the worst vertex from the centre of the face
*        opposite it is scaled by this factor to give the new vertex
*        position. Negative factors result in reflection through this
*        opposite face.
*     x
*        An array of double containing the coordinates of the vertices
*        of the simplex. The coordinates of the first vertex are
*        stored first, then those of the second vertex, etc. This
*        array will be updated by this function if the new vertex is
*        used to replace an existing one.
*     f
*        An array of double containing the Mapping function values at
*        each vertex of the simplex. This array will be updated by
*        this function if the new vertex is used to replace an
*        existing one.
*     ncall
*        Pointer to an int containing a count of the number of times
*        the Mapping function has been invoked. This value will be
*        updated to reflect the actions of this function.
*     xnew
*        An array of double with one element for each input coordinate
*        of the Mapping function. This is used as workspace.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Mapping function value at the new vertex. This value is
*     returned whether or not the new vertex replaces an existing one.

*  Notes:
*     - A value of AST__BAD will be returned by this function if it is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*     - A value of AST__BAD will also be returned if the new vertex
*     lies outside the constrained range of input coordinates
*     associated with the Mapping function (as specified in the
*     MapData structure supplied) or if any of the transformed output
*     coordinates produced by the underlying Mapping is bad. In either
*     case the new vertex will not be used to replace an existing one.
*/

/* Local Variables: */
   double fnew;                  /* Function value at new vertex */
   double xface;                 /* Coordinate of centre of magnification */
   int coord;                    /* Loop counter for coordinates */
   int ncoord;                   /* Number of coordinates */
   int nvertex;                  /* Number of simplex vertices */
   int vertex;                   /* Loop counter for vertices */

/* Initialise. */
   fnew = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return fnew;

/* Obtain the number of Mapping input coordinates from the MapData
   structure and calculate the number of simplex vertices. */
   ncoord = mapdata->nin;
   nvertex = ncoord + 1;

/* Loop to obtain each coordinate of the new vertex. */
   for ( coord = 0; coord < ncoord; coord++ ) {

/* Loop over all vertices except the lowest one and average their
   coordinates. This gives the coordinate of the centre of the face
   opposite the lowest vertex, which will act as the centre of
   magnification. */
      xface = 0.0;
      for ( vertex = 0; vertex < nvertex; vertex++ ) {
         if ( vertex != lo ) {

/* Divide each coordinate by the number of vertices as the sum is
   accumulated in order to minimise the risk of overflow. */
            xface += x[ vertex * ncoord + coord ] /
                     ( (double ) ( nvertex - 1 ) );
         }
      }

/* Magnify the lowest vertex's distance from this point by the
   required factor to give the coordinates of the new vertex. */
      xnew[ coord ] = xface + ( x[ lo * ncoord + coord ] - xface ) * scale;
   }

/* Evaluate the Mapping function at the new vertex. */
   fnew = MapFunction( mapdata, xnew, ncall, status );

/* If the result is not bad and exceeds the previous value at the
   lowest vertex, then replace the lowest vertex with this new one. */
   if ( astOK && ( fnew != AST__BAD ) && ( fnew > f[ lo ] ) ) {
      for ( coord = 0; coord < ncoord; coord++ ) {
         x[ lo * ncoord + coord ] = xnew[ coord ];
      }
      f[ lo ] = fnew;
   }

/* Return the value at the new vertex. */
   return fnew;
}

static int QuadApprox( AstMapping *this,  const double lbnd[2],
                       const double ubnd[2], int nx, int ny, double *fit,
                       double *rms, int *status ){
/*
*++
*  Name:
c     astQuadApprox
f     AST_QUADAPPROX

*  Purpose:
*     Obtain a quadratic approximation to a 2D Mapping.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     int QuadApprox( AstMapping *this,  const double lbnd[2],
c                     const double ubnd[2], int nx, int ny, double *fit,
c                     double *rms )
f     RESULT = AST_QUADAPPROX( THIS, LBND, UBND, NX, NY, FIT, RMS, STATUS )

*  Class Membership:
*     Mapping function.

*  Description:
*     This function returns the co-efficients of a quadratic fit to the
*     supplied Mapping over the input area specified by
c     "lbnd" and "ubnd".
f     LBND and UBND.
*     The Mapping must have 2 inputs, but may have any number of outputs.
*     The i'th Mapping output is modelled as a quadratic function of the
*     2 inputs (x,y):
*
*     output_i = a_i_0 + a_i_1*x + a_i_2*y + a_i_3*x*y + a_i_4*x*x +
*                a_i_5*y*y
*
c     The "fit"
f     The FIT
*     array is returned holding the values of the co-efficients a_0_0,
*     a_0_1, etc.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping.
c     lbnd
f     LBND( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of doubles
f        An array
*        containing the lower bounds of a box defined within the input
*        coordinate system of the Mapping. The number of elements in this
*        array should equal the value of the Mapping's Nin attribute. This
*        box should specify the region over which the fit is to be
*        performed.
c     ubnd
f     UBND( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of doubles
f        An array
*        containing the upper bounds of the box specifying the region over
*        which the fit is to be performed.
c     nx
f     NX = INTEGER (Given)
*        The number of points to place along the first Mapping input. The
*        first point is at
c        "lbnd[0]" and the last is at "ubnd[0]".
f        LBND( 1 ) and the last is at UBND( 1 ).
*        If a value less than three is supplied a value of three will be used.
c     ny
f     NY = INTEGER (Given)
*        The number of points to place along the second Mapping input. The
*        first point is at
c        "lbnd[1]" and the last is at "ubnd[1]".
f        LBND( 2 ) and the last is at UBND( 2 ).
*        If a value less than three is supplied a value of three will be used.
c     fit
f     FIT( * ) = DOUBLE PRECISION (Returned)
c        Pointer to an array of doubles
f        An array
*        in which to return the co-efficients of the quadratic
*        approximation to the specified transformation. This array should
*        have at least "6*Nout", elements. The first 6 elements hold the
*        fit to the first Mapping output. The next 6 elements hold the
*        fit to the second Mapping output, etc. So if the Mapping has 2
*        inputs and 2 outputs the quadratic approximation to the forward
*        transformation is:
*
c           X_out = fit[0] + fit[1]*X_in + fit[2]*Y_in + fit[3]*X_in*Y_in +
c                   fit[4]*X_in*X_in + fit[5]*Y_in*Y_in
c           Y_out = fit[6] + fit[7]*X_in + fit[8]*Y_in + fit[9]*X_in*Y_in +
c                   fit[10]*X_in*X_in + fit[11]*Y_in*Y_in
f           X_out = fit(1) + fit(2)*X_in + fit(3)*Y_in + fit(4)*X_in*Y_in +
f                   fit(5)*X_in*X_in + fit(6)*Y_in*Y_in
f           Y_out = fit(7) + fit(8)*X_in + fit(9)*Y_in + fit(10)*X_in*Y_in +
f                   fit(11)*X_in*X_in + fit(12)*Y_in*Y_in
*
c     rms
f     RMS = DOUBLE PRECISION (Returned)
c        Pointer to a double in which to return the
f        The
*        RMS residual between the fit and the Mapping, summed over all
*        Mapping outputs.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astQuadApprox()
f     AST_QUADAPPROX = LOGICAL
*        If a quadratic approximation was created,
c        a non-zero value is returned. Otherwise zero is returned
f        .TRUE is returned. Otherwise .FALSE. is returned
*        and the fit co-efficients are set to AST__BAD.

*  Notes:
*     - This function fits the Mapping's forward transformation. To fit
*     the inverse transformation, the Mapping should be inverted using
c     astInvert
f     AST_INVERT
*     before invoking this function.
c     - A value of zero
f     - A value of .FALSE.
*     will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*--

*/

/* Local Variables: */
   AstPointSet *pset1;
   AstPointSet *pset2;
   double **pdat1;
   double **pdat2;
   double *ofit;
   double *px;
   double *py;
   double *pz;
   double det;
   double dx;
   double dy;
   double mat[ 6*6 ];
   double sx2;
   double sx2y2;
   double sx2y;
   double sx3;
   double sx3y;
   double sx4;
   double sx;
   double sxy2;
   double sxy3;
   double sxy;
   double sy2;
   double sy3;
   double sy4;
   double sy;
   double sz;
   double sz2;
   double szx2;
   double szx;
   double szxy;
   double szy2;
   double szy;
   double x;
   double xx;
   double xy;
   double y;
   double yy;
   double z;
   int i;
   int iout;
   int iw[ 6 ];
   int ix;
   int iy;
   int n;
   int nin;
   int nout;
   int np;
   int ntot;
   int result;
   int sing;

/* Initialise the returned values. */
   result = 0;
   fit[ 0 ] = AST__BAD;
   *rms = AST__BAD;
   ntot = 0;

/* Check the global error status. */
   if( !astOK ) return result;

/* Get the number of Mapping inputs and outputs. Report an error if not
   correct. */
   nin = astGetI( this, "Nin" );
   nout = astGetI( this, "Nout" );
   if( nin != 2 && astOK ) {
      astError( AST__BADNI, "astQuadApprox(%s): Input Mapping has %d %s - "
                "it must have 2 inputs.", status, astGetClass( this ), nin,
                (nin==1)?"input":"inputs" );
   }

/* Ensure we are using at least 3 points on each of the two input axes. */
   if( nx < 3 ) nx = 3;
   if( ny < 3 ) ny = 3;

/* Get the total number of grid points. */
   np = nx*ny;

/* Create a PointSet to hold the 2D grid of input positions. */
   pset1 = astPointSet( np, 2, " ", status );
   pdat1 = astGetPoints( pset1 );

/* Create a PointSet to hold the N-D grid of output positions. */
   pset2 = astPointSet( np, nout, " ", status );
   pdat2 = astGetPoints( pset2 );

/* Check the memory allocation (and everything else) was succesful. */
   if( astOK ) {

/* Find the cell dimensions on X and Y input axes. */
      dx = ( ubnd[ 0 ] - lbnd[ 0 ] )/( nx - 1 );
      dy = ( ubnd[ 1 ] - lbnd[ 1 ] )/( ny - 1 );

/* Create a regular grid of input positions. */
      px = pdat1[ 0 ];
      py = pdat1[ 1 ];
      for( iy = 0; iy < ny; iy++ ) {
         x = lbnd[ 0 ];
         y = lbnd[ 1 ] + iy*dy;
         for( ix = 0; ix < nx; ix++ ) {
            *(px++) = x;
            *(py++) = y;
            x += dx;
         }
      }

/* Use the supplied Mapping to transform this grid into the output space. */
      (void) astTransform( this, pset1, 1, pset2 );

/* Assume the approximation can be created. */
      result = 1;
      *rms = 0.0;

/* Loop round each Mapping output. */
      for( iout = 0; iout < nout && astOK; iout++ ) {

/* Get a pointer to the first element of the fit array for this output. */
         ofit = fit + 6*iout;

/* Form the required sums. */
         n = 0;
         sx = 0.0;
         sy = 0.0;
         sxy = 0.0;
         sx2 = 0.0;
         sy2 = 0.0;
         sx2y = 0.0;
         sx3 = 0.0;
         sxy2 = 0.0;
         sy3 = 0.0;
         sx2y2 = 0.0;
         sx3y = 0.0;
         sxy3 = 0.0;
         sx4 = 0.0;
         sy4 = 0.0;
         sz = 0.0;
         sz2 = 0.0;
         szx = 0.0;
         szy = 0.0;
         szxy = 0.0;
         szx2 = 0.0;
         szy2 = 0.0;

         px = pdat1[ 0 ];
         py = pdat1[ 1 ];
         pz = pdat2[ iout ];

         for( i = 0; i < np; i++ ) {
            x = *(px++);
            y = *(py++);
            z = *(pz++);

            if( z != AST__BAD ) {
               xx = x*x;
               yy = y*y;
               xy = x*y;

               n++;
               sx += x;
               sy += y;
               sxy += xy;
               sx2 += xx;
               sy2 += yy;
               sx2y += xx*y;
               sx3 += xx*x;
               sxy2 += x*yy;
               sy3 += yy*y;
               sx2y2 += xx*yy;
               sx3y += xx*xy;
               sxy3 += xy*yy;
               sx4 += xx*xx;
               sy4 += yy*yy;
               sz += z;
               sz2 += z*z;
               szx += z*x;
               szy += z*y;
               szxy += z*xy;
               szx2 += z*xx;
               szy2 += z*yy;
            }
         }

/* Form a matrix (M) and vector (V) such that M.X = V, where X is the
   solution vector holding the required best fit parameter values (V is
   stored in ofit). */
         mat[ 0 ] = n;
         mat[ 1 ] = sx;
         mat[ 2 ] = sy;
         mat[ 3 ] = sxy;
         mat[ 4 ] = sx2;
         mat[ 5 ] = sy2;

         mat[ 6 ] = sx;
         mat[ 7 ] = sx2;
         mat[ 8 ] = sxy;
         mat[ 9 ] = sx2y;
         mat[ 10 ] = sx3;
         mat[ 11 ] = sxy2;

         mat[ 12 ] = sy;
         mat[ 13 ] = sxy;
         mat[ 14 ] = sy2;
         mat[ 15 ] = sxy2;
         mat[ 16 ] = sx2y;
         mat[ 17 ] = sy3;

         mat[ 18 ] = sxy;
         mat[ 19 ] = sx2y;
         mat[ 20 ] = sxy2;
         mat[ 21 ] = sx2y2;
         mat[ 22 ] = sx3y;
         mat[ 23 ] = sxy3;

         mat[ 24 ] = sx2;
         mat[ 25 ] = sx3;
         mat[ 26 ] = sx2y;
         mat[ 27 ] = sx3y;
         mat[ 28 ] = sx4;
         mat[ 29 ] = sx2y2;

         mat[ 30 ] = sy2;
         mat[ 31 ] = sxy2;
         mat[ 32 ] = sy3;
         mat[ 33 ] = sxy3;
         mat[ 34 ] = sx2y2;
         mat[ 35 ] = sy4;

         ofit[ 0 ] = sz;
         ofit[ 1 ] = szx;
         ofit[ 2 ] = szy;
         ofit[ 3 ] = szxy;
         ofit[ 4 ] = szx2;
         ofit[ 5 ] = szy2;

/* Now find the solution vector (the solution over-writes teh current
   contents of "ofit"). */
         palDmat( 6, mat, ofit, &det, &sing, iw );

/* If the fit failed, fill the coefficient array with bad values. */
         if( sing != 0 ) {
            for( i = 0; i < 6; i++ ) ofit[ i ] = AST__BAD;
            result = 0;
            break;

/* If the fit succeeded, update the summ of the squared residuals. */
         } else {
            ntot += n;
            *rms += ofit[ 0 ]*ofit[ 0 ]*n +
                    2*ofit[ 0 ]*ofit[ 1 ]*sx +
                    2*ofit[ 0 ]*ofit[ 2 ]*sy +
                    2*( ofit[ 0 ]*ofit[ 3 ] + ofit[ 1 ]*ofit[ 2 ] )*sxy +
                    ( 2*ofit[ 0 ]*ofit[ 4 ] + ofit[ 1 ]*ofit[ 1 ] )*sx2 +
                    ( 2*ofit[ 0 ]*ofit[ 5 ] + ofit[ 2 ]*ofit[ 2 ] )*sy2 +
                    2*ofit[ 1 ]*ofit[ 4 ]*sx3 +
                    2*( ofit[ 1 ]*ofit[ 3 ] + ofit[ 2 ]*ofit[ 4 ] )*sx2y +
                    2*( ofit[ 1 ]*ofit[ 5 ] + ofit[ 2 ]*ofit[ 3 ] )*sxy2 +
                    2*ofit[ 2 ]*ofit[ 5 ]*sy3 +
                    ofit[ 4 ]*ofit[ 4 ]*sx4 +
                    2*ofit[ 3 ]*ofit[ 4 ]*sx3y +
                    ( 2*ofit[ 4 ]*ofit[ 5 ] + ofit[ 3 ]*ofit[ 3 ] )*sx2y2 +
                    2*ofit[ 3 ]*ofit[ 5 ]*sxy3 +
                    ofit[ 5 ]*ofit[ 5 ]*sy4 +
                    sz2 - 2*(
                       ofit[ 0 ]*sz +
                       ofit[ 1 ]*szx +
                       ofit[ 2 ]*szy +
                       ofit[ 3 ]*szxy +
                       ofit[ 4 ]*szx2 +
                       ofit[ 5 ]*szy2
                    );
         }
      }
   }

/* Free resources. */
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Return AST__BAD if anything went wrong. */
   if( !astOK || ntot == 0 ) {
      result = 0;
      fit[ 0 ] = AST__BAD;
      *rms = AST__BAD;

/* Otherwise normalise the returned RMS. */
   } else {
      if( *rms > 0.0 ) {
         *rms = sqrt( *rms/ntot );
      } else {
         *rms = 0.0;
      }
   }

/* Return result */
   return result;
}

static double Random( long int *seed, int *status ) {
/*
*  Name:
*     Random

*  Purpose:
*     Return a pseudo-random value in the range 0 to 1.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double Random( long int *seed, int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function returns a pseudo-random double value from a PDF
*     uniformly distributed in the range 0 to 1. It also updates a
*     seed value so that a sequence of pseudo-random values may be
*     obtained with successive invocations.

*  Parameters:
*     seed
*        Pointer to a long int which should initially contain a
*        non-zero seed value. This will be updated with a new seed
*        which may be supplied on the next invocation in order to
*        obtain a different pseudo-random value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The pseudo-random value.
*/

/* Local Variables: */
   long int i;                   /* Temporary storage */

/* This a basic random number generator using constants given in
   Numerical Recipes (Press et al.). */
   i = *seed / 127773;
   *seed = ( *seed - i * 127773 ) * 16807 - i * 2836;
   if ( *seed < 0 ) *seed += 2147483647;

/* Return the result as a double value in the range 0 to 1. */
   return ( (double) ( *seed - 1 ) ) / (double) 2147483646;
}

static double Rate( AstMapping *this, double *at, int ax1, int ax2,
                    int *status ){
/*
*+
*  Name:
*     astRate

*  Purpose:
*     Calculate the rate of change of a Mapping output.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     result = astRate( AstMapping *this, double *at, int ax1, int ax2 )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function evaluates the rate of change of a specified output of
*     the supplied Mapping with respect to a specified input, at a
*     specified input position.
*
*     The result is the mean gradient within a small interval centred on
*     the supplied position. The interval size is selected automatically
*     to minimise the error on the returned value. For large intervals,
*     the error is dominated by changes in the gradient of the
*     transformation. For small intervals, the error is dominated by
*     rounding errors. The best interval is the one that gives the most
*     consistent measure of the gradient within the interval. To find this
*     consistency, each candidate interval is subdivided into eight
*     sub-intervals, the mean gradient within each sub-interval is found,
*     and the associated consistency measure is then the difference between
*     the maximum and minimum sub-interval gradient found within the interval.

*  Parameters:
*     this
*        Pointer to the Mapping to be applied.
*     at
*        The address of an array holding the axis values at the position
*        at which the rate of change is to be evaluated. The number of
*        elements in this array should equal the number of inputs to the
*        Mapping.
*     ax1
*        The index of the Mapping output for which the rate of change is to
*        be found (output numbering starts at 0 for the first output).
*     ax2
*        The index of the Mapping input which is to be varied in order to
*        find the rate of change (input numbering starts at 0 for the first
*        input).

*  Returned Value:
*     astRate()
*        The rate of change of Mapping output "ax1" with respect to input
*        "ax2", evaluated at "at", or AST__BAD if the value cannot be
*        calculated.

*  Notes:
*     - A value of AST__BAD will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-

*  Implementation Notes:
*     - This function implements the basic astRate method available
*     via the protected interface to the Mapping class. The public
*     interface to this method is provided by the astRateId_
*     function.
*/

#define NN 50

/* Local Variables: */
   double h0;
   double h;
   double mean;
   double minrange;
   double range0;
   double range;
   double ret;
   double x0;
   double y[2*NN+1];
   double z[2*NN+1];
   int ibot;
   int iin;
   int iret;
   int itop;
   int nin;
   int nout;

/* Initialise */
   ret = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return ret;

/* Allocate resources */
   RateFun( NULL, NULL, -1, 0, 0, NULL, NULL, status );

/* Obtain the numbers of input and output coordinates for the Mapping. */
   nin = astGetNin( this );
   nout = astGetNout( this );

/* Validate the output index. */
   if ( astOK && ( ax1 < 0 || ax1 >= nout ) ) {
      astError( AST__AXIIN, "astRate(%s): The supplied Mapping output "
                "index (%d) is invalid; it should be in the range 1 to %d.", status,
                astGetClass( this ), ax1 + 1, nout );
   }

/* Validate the input index. */
   if ( astOK && ( ax2 < 0 || ax2 >= nin ) ) {
      astError( AST__AXIIN, "astRate(%s): The supplied Mapping input "
                "index (%d) is invalid; it should be in the range 1 to %d.", status,
                astGetClass( this ), ax2 + 1, nin );
   }

/* Check the Mapping has a forward transformation. */
   if ( astOK && !astGetTranForward( this ) ) {
      astError( AST__NODEF, "astRate(%s): The supplied Mapping does not "
                "have a defined forward transformation.", status,
                astGetClass( this ) );
   }

/* Save the central value on the Mapping input which is to be varied. */
   x0 = at[ ax2 ];

/* If it is bad, return bad values. */
   if( astOK && x0 != AST__BAD ) {

/* The required derivative is formed by evaluating the transformation at
   two positions close to "x0", and dividing the change in y by the
   change in x. The complexity comes in deciding how close to "x0" the
   two points should be. If the points are too far apart, the gradient of
   the function may vary significantly between the two points and so we
   have little confidence that he mean gradient in the interval is a good
   estimate of the gradient at "x0". On the other hand if the points are
   too close together, rounding errors will make the gradient value
   unreliable. The optimal interval is found by testing a number of
   different intervals as follows. Each interval is split into NDIV equal
   sub-intervals, and the gradient in each sub-interval is found. The max
   and min gradient for any of these sub-intervals is found, and the
   difference between them is used as an estimate of the reliability of the
   mean gradient within the whole interval. The interval with the
   greatest reliability is used to define the returned gradient.

   The initial estimate of the interval size is a fixed small fraction of
   the supplied "x0" value, or 1.0 if "x0" is zero. */
      h0 = ( x0 != 0.0 ) ? DBL_EPSILON*1.0E9*fabs( x0 ) : 1.0;

/* Attempt to find the mean gradient, and the range of gradients, within
   an interval of size "h0" centred on "x0". If this cannot be done,
   increase "h0" by a factor fo ten repeatedly until it can be done, or a
   silly large interval size is reached. */
      mean = AST__BAD;
      while( mean == AST__BAD && h0 < 1.0E-10*DBL_MAX ) {
         h0 *= 10;
         mean = FindGradient( this, at, ax1, ax2, x0, h0, &range0, status );
      }

/* If this was not successful, return AST__BAD as the function value. */
      if( mean != AST__BAD ) {

/* We now search through a range of larger interval sizes, to see if any
   produce a more reliable mean gradient estimate (i.e. have a smaller range
   of gradients within the interval ). After that we search through a range
   of smaller interval sizes. The gradient range and mean gradient for
   each interval size are stored in arrays "y" and "z" respectively. "iret"
   is the index of the most reliable interval found so far (i.e. the one
   with the smallest range of sub-interval gradients). The original interval
   "h0" is stored in the middle element of these arrays (index "NN").
   Intervals are stored in monotonic order of interval size in the arrays. */
         iret = NN;
         y[ NN ] = range0;
         z[ NN ] = mean;
         minrange = range0;

/* itop is the index of the last array elements to store calculated values. */
         itop = NN;

/* Loop round increasing the interval size by a factor of four each time
   round. */
         h = h0;
         for( iin = NN + 1; iin <= 2*NN && astOK; iin++ ){
            h *= 4.0;

/* Calculate the mean gradient, and the range of gradients, using the
   current interval size. */
            mean = FindGradient( this, at, ax1, ax2, x0, h, &range, status );

/* If it could be done, store the values in the arrays. */
            if( mean != AST__BAD ) {
               itop++;
               z[ itop ] = mean;
               y[ itop ] = range;

/* Look for the smallest range, and note its index in the arrays. */
               if( range < minrange ) {
                  minrange = range;
                  iret = itop;

/* If a range of zero is encountered, we only believe it if the previous
   interval also had zero range. Otherwise, it's probably just a numerical
   fluke. If the previous interval also had a range of zero, we can forget
   the rest of the algorithm since the supplied transformation is linear
   and we now have its gradient. So leave the loop. */
               } else if( range == 0.0 && y[ iin - 1 ] == 0 ) {
                  iret = itop;
                  break;
               }

/* Stop looping when the interval range is 100 times the original
   interval range. */
               if( range > 100*range0 ) break;
            }
         }

/* Record the minimum range found so far. */
         range0 = minrange;

/* ibot is the index of the first array elements to store calculated values. */
         ibot = NN;

/* Loop round decreasing the interval size by a factor of four each time
   round. This is just like the last loop, but goes the other way, to
   lower indices. */
         h = h0;
         for( iin = NN - 1; iin >= 0 && astOK; iin-- ){
            h /= 4.0;

            mean = FindGradient( this, at, ax1, ax2, x0, h, &range, status );
            if( mean != AST__BAD ) {
               ibot--;
               z[ ibot ] = mean;
               y[ ibot ] = range;

               if( range < minrange ) {
                  minrange = range;
                  iret = ibot;
               } else if( range == 0.0 && y[ iin + 1 ] == 0 ) {
                  iret = ibot;
                  break;
               }

               if( range > 100*range0 ) break;
            }
         }

/* If the smallest gradient range in any interval was zero, we only
   believe it if the adjacent interval size also had zero range. */
         if( minrange == 0.0 ) {
            if( ( iret > ibot && y[ iret - 1 ] == 0 ) ||
                ( iret < itop && y[ iret + 1 ] == 0 ) ) {
               ret = z[ iret ];

/* Otherwise, search for the smallest gradient range, ignoring values
   exactly equal to zero, and return the corresponding mean interval
   gradient. */
            } else {
               for( iin = ibot; iin <= itop; iin++ ){
                  if( y[ iin ] > 0.0 ){
                     if( minrange == 0 || y[ iin ] < minrange ) {
                        minrange = y[ iin ];
                        ret = z[ iin ];
                     }
                  }
               }
            }

/* If the minimum range was non-zero, we can just return the
   corresponding mean gradient. */
         } else {
            ret = z[ iret ];
         }
      }
   }

/* Free resources */
   RateFun( NULL, NULL, -2, 0, 0, NULL, NULL, status );

/* Return the result. */
   return ret;

#undef NN
}

static void RateFun( AstMapping *map, double *at, int ax1, int ax2,
                     int n, double *x, double *y, int *status ) {
/*
*  Name:
*     RateFun

*  Purpose:
*     Find the value of the function currently being differentiated by the
*     astRate method.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void RateFun( AstMapping *map, double *at, int ax1, int ax2,
*                   int n, double *x, double *y, int *status )

*  Class Membership:
*     Mapping method.

*  Description:
*     This is a service function for the astRate method. It evaluates the
*     function being differentiated at specified axis values.
*
*     This function uses static resources in order to avoid the overhead
*     of creating new PointSets each time this function is called. These
*     static resources which must be initialised before the first invocation
*     with a given Mapping, and must be released after the final invocation.
*     See "ax1".

*  Parameters:
*     map
*        Pointer to a Mapping which yields the value of the function at x.
*        The Mapping may have any number of inputs and outputs; the specific
*        output representing the function value, f, is specified by ax1 and
*        the specific input representing the argument, x, is specified by ax2.
*     at
*        A pointer to an array holding axis values at the position at which
*        the function is to be evaluated. The number of values supplied
*        must equal the number of inputs to the Mapping. The value supplied
*        for axis "ax2" is ignored (the value of "x" is used for axis "ax2").
*     ax1
*        The zero-based index of the Mapping output which is to be
*        differentiated. Set this to -1 to allocate, or -2 to release,
*        the static resources used by this function.
*     ax2
*        The zero-based index of the Mapping input which is to be varied.
*     n
*        The number of elements in the "x" and "y" arrays. This should not
*        be greater than 2*RATE_ORDER.
*     x
*        The value of the Mapping input specified by ax2 at which the
*        function is to be evaluated. If "ax2" is set to -1, then the
*        supplied value is used as flag indicating if the static resources
*        used by this function should be initialised (if x >= 0 ) or
*        freed (if x < 0).
*     y
*        An array in which to return the function values at the positions
*        given in "x".
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS
   AstPointSet *pset1;
   AstPointSet *pset2;
   double **ptr1;
   double **ptr2;
   double *oldx;
   double *oldy;
   double *p;
   double xx;
   int i;
   int k;
   int nin;
   int nout;

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(map);

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   pset2 = NULL;

/* If required, initialise things. */
   if( ax1 == -1 ) {
      for( i = 0; i < RATEFUN_MAX_CACHE; i++ ) {
         ratefun_pset_size[ i ] = 0;
         ratefun_pset1_cache[ i ] = NULL;
         ratefun_pset2_cache[ i ] = NULL;
      }
      ratefun_next_slot = 0;

/* If required, clean up. */
   } else if( ax1 == -2 ) {
      for( i = 0; i < RATEFUN_MAX_CACHE; i++ ) {
         ratefun_pset_size[ i ] = 0;
         if( ratefun_pset1_cache[ i ] ) ratefun_pset1_cache[ i ] = astAnnul( ratefun_pset1_cache[ i ] );
         if( ratefun_pset2_cache[ i ] ) ratefun_pset2_cache[ i ] = astAnnul( ratefun_pset2_cache[ i ] );
      }
      ratefun_next_slot = 0;

/* Otherwise do the transformations. */
   } else {

/* See if we have already created PointSets of the correct size. */
      pset1 = NULL;
      for( i = 0; i < RATEFUN_MAX_CACHE; i++ ) {
         if( ratefun_pset_size[ i ] == n ) {
            pset1 = ratefun_pset1_cache[ i ];
            pset2 = ratefun_pset2_cache[ i ];
            break;
         }
      }

/* If we have not, create new PointSets now. */
      if( pset1 == NULL ) {
         nin = astGetNin( map );
         pset1 = astPointSet( n, nin, "", status );
         ptr1 = astGetPoints( pset1 );

         nout = astGetNout( map );
         pset2 = astPointSet( n, nout, "", status );
         ptr2 = astGetPoints( pset2 );

/* Store the input position in the input PointSet. */
         for( i = 0; i < nin; i++ ) {
            xx = at[ i ];
            p = ptr1[ i ];
            for( k = 0; k < n; k++, p++ ) *p = xx;
         }

/* Add these new PointSets to the cache, removing any existing
   PointSets. */
         if( ratefun_pset_size[ ratefun_next_slot ] > 0 ) {
            (void) astAnnul( ratefun_pset1_cache[ ratefun_next_slot ] );
            (void) astAnnul( ratefun_pset2_cache[ ratefun_next_slot ] );
         }
         ratefun_pset1_cache[ ratefun_next_slot ] = pset1;
         ratefun_pset2_cache[ ratefun_next_slot ] = pset2;
         ratefun_pset_size[ ratefun_next_slot ] = n;
         if( ++ratefun_next_slot == RATEFUN_MAX_CACHE ) ratefun_next_slot = 0;

/* If existing PointSets were found, get there data arrays. */
      } else {
         ptr1 = astGetPoints( pset1 );
         ptr2 = astGetPoints( pset2 );
      }

/* Store the input X values in the input PointSet data array. */
      oldx = ptr1[ ax2 ];
      ptr1[ ax2 ] = x;

/* Store the output Y values in the output PointSet data array. */
      oldy = ptr2[ ax1 ];
      ptr2[ ax1 ] = y;

/* Transform the positions. */
      (void) astTransform( map, pset1, 1, pset2 );

/* Re-instate the original arrays in the PointSets. */
      ptr1[ ax2 ] = oldx;
      ptr2[ ax1 ] = oldy;

   }
}

/*
*++
*  Name:
c     astRebin<X>
f     AST_REBIN<X>

*  Purpose:
*     Rebin a region of a data grid.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astRebin<X>( AstMapping *this, double wlim, int ndim_in,
c                      const int lbnd_in[], const int ubnd_in[],
c                      const <Xtype> in[], const <Xtype> in_var[],
c                      int spread, const double params[], int flags,
c                      double tol, int maxpix,
c                      <Xtype> badval, int ndim_out,
c                      const int lbnd_out[], const int ubnd_out[],
c                      const int lbnd[], const int ubnd[],
c                      <Xtype> out[], <Xtype> out_var[] );
f     CALL AST_REBIN<X>( THIS, WLIM, NDIM_IN, LBND_IN, UBND_IN, IN, IN_VAR,
f                        SPREAD, PARAMS, FLAGS,
f                        TOL, MAXPIX, BADVAL,
f                        NDIM_OUT, LBND_OUT, UBND_OUT,
f                        LBND, UBND, OUT, OUT_VAR, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This is a set of functions for rebinning gridded data (e.g. an
*     image) under the control of a geometrical transformation, which
*     is specified by a Mapping.  The functions operate on a pair of
*     data grids (input and output), each of which may have any number
*     of dimensions. Rebinning may be restricted to a specified
*     region of the input grid. An associated grid of error estimates
*     associated with the input data may also be supplied (in the form
*     of variance values), so as to produce error estimates for the
*     rebined output data. Propagation of missing data (bad pixels)
*     is supported.
*
*     Note, if you will be rebining a sequence of input arrays and then
*     co-adding them into a single array, the alternative
c     astRebinSeq<X> functions
f     AST_REBINSEQ<X> routines
*     will in general be more efficient.
*
*     You should use a rebinning function which matches the numerical
*     type of the data you are processing by replacing <X> in
c     the generic function name astRebin<X> by an appropriate 1- or
f     the generic function name AST_REBIN<X> by an appropriate 1- or
*     2-character type code. For example, if you are rebinning data
c     with type "float", you should use the function astRebinF (see
f     with type REAL, you should use the function AST_REBINR (see
*     the "Data Type Codes" section below for the codes appropriate to
*     other numerical types).
*
*     Rebinning of the grid of input data is performed by transforming
*     the coordinates of the centre of each input grid element (or pixel)
*     into the coordinate system of the output grid. The input pixel
*     value is then divided up and assigned to the output pixels in the
*     neighbourhood of the central output coordinates. A choice of
*     schemes are provided for determining how each input pixel value is
*     divided up between the output pixels. In general, each output pixel
*     may be assigned values from more than one input pixel. All
*     contributions to a given output pixel are summed to produce the
*     final output pixel value. Output pixels can be set to the supplied
*     bad value if they receive contributions from an insufficient number
*     of input pixels. This is controlled by the
c     "wlim" parameter.
f     WLIM argument.
*
*     Input pixel coordinates are transformed into the coordinate
*     system of the output grid using the forward transformation of the
*     Mapping which is supplied. This means that geometrical features
*     in the input data are subjected to the Mapping's forward
*     transformation as they are transferred from the input to the
*     output grid.
*
*     In practice, transforming the coordinates of every pixel of a
*     large data grid can be time-consuming, especially if the Mapping
*     involves complicated functions, such as sky projections. To
*     improve performance, it is therefore possible to approximate
*     non-linear Mappings by a set of linear transformations which are
*     applied piece-wise to separate sub-regions of the data. This
*     approximation process is applied automatically by an adaptive
*     algorithm, under control of an accuracy criterion which
*     expresses the maximum tolerable geometrical distortion which may
*     be introduced, as a fraction of a pixel.
*
*     This algorithm first attempts to approximate the Mapping with a
*     linear transformation applied over the whole region of the
*     input grid which is being used. If this proves to be
*     insufficiently accurate, the input region is sub-divided into
*     two along its largest dimension and the process is repeated
*     within each of the resulting sub-regions. This process of
*     sub-division continues until a sufficiently good linear
*     approximation is found, or the region to which it is being
*     applied becomes too small (in which case the original Mapping is
*     used directly).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to a Mapping, whose forward transformation will be
*        used to transform the coordinates of pixels in the input
*        grid into the coordinate system of the output grid.
*
*        The number of input coordinates used by this Mapping (as
*        given by its Nin attribute) should match the number of input
c        grid dimensions given by the value of "ndim_in"
f        grid dimensions given by the value of NDIM_IN
*        below. Similarly, the number of output coordinates (Nout
*        attribute) should match the number of output grid dimensions
c        given by "ndim_out".
f        given by NDIM_OUT.
c     wlim
f     WLIM = DOUBLE PRECISION (Given)
*        Gives the required number of input pixel values which must contribute
*        to an output pixel in order for the output pixel value to be
*        considered valid. If the sum of the input pixel weights contributing
*        to an output pixel is less than the supplied
c        "wlim"
f        WLIM
*        value, then the output pixel value is returned set to the
*        supplied bad value.
c     ndim_in
f     NDIM_IN = INTEGER (Given)
*        The number of dimensions in the input grid. This should be at
*        least one.
c     lbnd_in
f     LBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
c     ubnd_in
f     UBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
c        Note that "lbnd_in" and "ubnd_in" together define the shape
f        Note that LBND_IN and UBND_IN together define the shape
*        and size of the input grid, its extent along a particular
c        (j'th) dimension being ubnd_in[j]-lbnd_in[j]+1 (assuming the
c        index "j" to be zero-based). They also define
f        (J'th) dimension being UBND_IN(J)-LBND_IN(J)+1. They also define
*        the input grid's coordinate system, each pixel having unit
*        extent along each dimension with integral coordinate values
*        at its centre.
c     in
f     IN( * ) = <Xtype> (Given)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        input grid, containing the input data to be rebined.  The
*        numerical type of this array should match the 1- or
*        2-character type code appended to the function name (e.g. if
c        you are using astRebinF, the type of each array element
c        should be "float").
f        you are using AST_REBINR, the type of each array element
f        should be REAL).
*
*        The storage order of data within this array should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     in_var
f     IN_VAR( * ) = <Xtype> (Given)
c        An optional pointer to a second array with the same size and
c        type as the "in" array. If given, this should contain a set
c        of non-negative values which represent estimates of the
c        statistical variance associated with each element of the "in"
c        array. If this array is supplied (together with the
c        corresponding "out_var" array), then estimates of the
c        variance of the rebined output data will be calculated.
c
c        If no input variance estimates are being provided, a NULL
c        pointer should be given.
f        An optional second array with the same size and type as the
f        IN array. If the AST__USEVAR flag is set via the FLAGS
f        argument (below), this array should contain a set of
f        non-negative values which represent estimates of the
f        statistical variance associated with each element of the IN
f        array. Estimates of the variance of the rebined output data
f        will then be calculated.
f
f        If the AST__USEVAR flag is not set, no input variance
f        estimates are required and this array will not be used. A
f        dummy (e.g. one-element) array may then be supplied.
c     spread
f     SPREAD = INTEGER (Given)
c        This parameter specifies the scheme to be used for dividing
f        This argument specifies the scheme to be used for dividing
*        each input data value up amongst the corresponding output pixels.
*        It may be used to select
*        from a set of pre-defined schemes by supplying one of the
*        values described in the "Pixel Spreading Schemes"
*        section below.  If a value of zero is supplied, then the
*        default linear spreading scheme is used (equivalent to
*        supplying the value AST__LINEAR).
c     params
f     PARAMS( * ) = DOUBLE PRECISION (Given)
c        An optional pointer to an array of double which should contain
f        An optional array which should contain
*        any additional parameter values required by the pixel
*        spreading scheme. If such parameters are required, this
*        will be noted in the "Pixel Spreading Schemes"
*        section below.
*
c        If no additional parameters are required, this array is not
c        used and a NULL pointer may be given.
f        If no additional parameters are required, this array is not
f        used. A dummy (e.g. one-element) array may then be supplied.
c     flags
f     FLAGS = INTEGER (Given)
c        The bitwise OR of a set of flag values which may be used to
f        The sum of a set of flag values which may be used to
*        provide additional control over the rebinning operation. See
*        the "Control Flags" section below for a description of the
*        options available.  If no flag values are to be set, a value
*        of zero should be given.
c     tol
f     TOL = DOUBLE PRECISION (Given)
*        The maximum tolerable geometrical distortion which may be
*        introduced as a result of approximating non-linear Mappings
*        by a set of piece-wise linear transformations. This should be
*        expressed as a displacement in pixels in the output grid's
*        coordinate system.
*
*        If piece-wise linear approximation is not required, a value
*        of zero may be given. This will ensure that the Mapping is
*        used without any approximation, but may increase execution
*        time.
*
*        If the value is too high, discontinuities between the linear
*        approximations used in adjacent panel will be higher, and may
*        cause the edges of the panel to be visible when viewing the output
*        image at high contrast. If this is a problem, reduce the
*        tolerance value used.
c     maxpix
f     MAXPIX = INTEGER (Given)
*        A value which specifies an initial scale size (in pixels) for
*        the adaptive algorithm which approximates non-linear Mappings
*        with piece-wise linear transformations. Normally, this should
*        be a large value (larger than any dimension of the region of
*        the input grid being used). In this case, a first attempt to
*        approximate the Mapping by a linear transformation will be
*        made over the entire input region.
*
*        If a smaller value is used, the input region will first be
c        divided into sub-regions whose size does not exceed "maxpix"
f        divided into sub-regions whose size does not exceed MAXPIX
*        pixels in any dimension. Only at this point will attempts at
*        approximation commence.
*
*        This value may occasionally be useful in preventing false
*        convergence of the adaptive algorithm in cases where the
*        Mapping appears approximately linear on large scales, but has
*        irregularities (e.g. holes) on smaller scales. A value of,
*        say, 50 to 100 pixels can also be employed as a safeguard in
*        general-purpose software, since the effect on performance is
*        minimal.
*
*        If too small a value is given, it will have the effect of
*        inhibiting linear approximation altogether (equivalent to
c        setting "tol" to zero). Although this may degrade
f        setting TOL to zero). Although this may degrade
*        performance, accurate results will still be obtained.
c     badval
f     BADVAL = <Xtype> (Given)
*        This argument should have the same type as the elements of
c        the "in" array. It specifies the value used to flag missing
f        the IN array. It specifies the value used to flag missing
*        data (bad pixels) in the input and output arrays.
*
c        If the AST__USEBAD flag is set via the "flags" parameter,
f        If the AST__USEBAD flag is set via the FLAGS argument,
c        then this value is used to test for bad pixels in the "in"
c        (and "in_var") array(s).
f        then this value is used to test for bad pixels in the IN
f        (and IN_VAR) array(s).
*
*        In all cases, this value is also used to flag any output
c        elements in the "out" (and "out_var") array(s) for which
f        elements in the OUT (and OUT_VAR) array(s) for which
*        rebined values could not be obtained (see the "Propagation
*        of Missing Data" section below for details of the
*        circumstances under which this may occur).
c     ndim_out
f     NDIM_OUT = INTEGER (Given)
*        The number of dimensions in the output grid. This should be
*        at least one. It need not necessarily be equal to the number
*        of dimensions in the input grid.
c     lbnd_out
f     LBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the output grid along each dimension.
c     ubnd_out
f     UBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the output grid along each dimension.
*
c        Note that "lbnd_out" and "ubnd_out" together define the
f        Note that LBND_OUT and UBND_OUT together define the
*        shape, size and coordinate system of the output grid in the
c        same way as "lbnd_in" and "ubnd_in" define the shape, size
f        same way as LBND_IN and UBND_IN define the shape, size
*        and coordinate system of the input grid.
c     lbnd
f     LBND( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the first pixel in the region
*        of the input grid which is to be included in the rebined output
*        array.
c     ubnd
f     UBND( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the last pixel in the region of
*        the input grid which is to be included in the rebined output
*        array.
*
c        Note that "lbnd" and "ubnd" together define the shape and
f        Note that LBND and UBND together define the shape and
*        position of a (hyper-)rectangular region of the input grid
*        which is to be included in the rebined output array. This region
*        should lie wholly within the extent of the input grid (as
c        defined by the "lbnd_in" and "ubnd_in" arrays). Regions of
f        defined by the LBND_IN and UBND_IN arrays). Regions of
*        the input grid lying outside this region will not be used.
c     out
f     OUT( * ) = <Xtype> (Returned)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        output grid, in which the rebined data values will be
*        returned. The numerical type of this array should match that
c        of the "in" array, and the data storage order should be such
f        of the IN array, and the data storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     out_var
f     OUT_VAR( * ) = <Xtype> (Returned)
c        An optional pointer to an array with the same type and size
c        as the "out" array. If given, this array will be used to
c        return variance estimates for the rebined data values. This
c        array will only be used if the "in_var" array has also been
c        supplied.
f        An optional array with the same type and size as the OUT
f        array. If the AST__USEVAR flag is set via the FLAGS argument,
f        this array will be used to return variance estimates for the
f        rebined data values.
*
*        The output variance values will be calculated on the
*        assumption that errors on the input data values are
*        statistically independent and that their variance estimates
*        may simply be summed (with appropriate weighting factors)
*        when several input pixels contribute to an output data
*        value. If this assumption is not valid, then the output error
*        estimates may be biased. In addition, note that the
*        statistical errors on neighbouring output data values (as
*        well as the estimates of those errors) may often be
*        correlated, even if the above assumption about the input data
*        is correct, because of the pixel spreading schemes
*        employed.
*
c        If no output variance estimates are required, a NULL pointer
c        should be given.
f        If the AST__USEVAR flag is not set, no output variance
f        estimates will be calculated and this array will not be
f        used. A dummy (e.g. one-element) array may then be supplied.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Data Type Codes:
*     To select the appropriate rebinning function, you should
c     replace <X> in the generic function name astRebin<X> with a
f     replace <X> in the generic function name AST_REBIN<X> with a
*     1- or 2-character data type code, so as to match the numerical
*     type <Xtype> of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - B: byte (signed char)
c     - UB: unsigned byte (unsigned char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - B: BYTE (treated as signed)
f     - UB: BYTE (treated as unsigned)
*
c     For example, astRebinD would be used to process "double"
c     data, while astRebinI would be used to process "int"
c     data, etc.
f     For example, AST_REBIND would be used to process DOUBLE
f     PRECISION data, while AST_REBINI would be used to process
f     integer data (stored in an INTEGER array), etc.
*
*     Note that, unlike
c     astResample<X>, the astRebin<X>
f     AST_RESAMPLE<X>, the AST_REBIN<X>
*     set of functions does not yet support unsigned integer data types
*     or integers of different sizes.

*  Pixel Spreading Schemes:
*     The pixel spreading scheme specifies the Point Spread Function (PSF)
*     applied to each input pixel value as it is copied into the output
*     array. It can be thought of as the inverse of the sub-pixel
*     interpolation schemes used by the
c     astResample<X>
f     AST_RESAMPLE<X>
*     group of functions. That is, in a sub-pixel interpolation scheme the
*     kernel specifies the weight to assign to each input pixel when
*     forming the weighted mean of the input pixels, whereas the kernel in a
*     pixel spreading scheme specifies the fraction of the input data value
*     which is to be assigned to each output pixel. As for interpolation, the
*     choice of suitable pixel spreading scheme involves stricking a balance
*     between schemes which tend to degrade sharp features in the data by
*     smoothing them, and those which attempt to preserve sharp features but
*     which often tend to introduce unwanted artifacts. See the
c     astResample<X>
f     AST_RESAMPLE<X>
*     documentation for further discussion.
*
*     The binning algorithm used has the ability to introduce artifacts
*     not seen when using a resampling algorithm. Particularly, when
*     viewing the output image at high contrast, systems of curves lines
*     covering the entire image may be visible. These are caused by a
*     beating effect between the input pixel positions and the output pixels
*     position, and their nature and strength depend critically upon the
*     nature of the Mapping and the spreading function being used. In
*     general, the nearest neighbour spreading function demonstrates this
*     effect more clearly than the other functions, and for this reason
*     should be used with caution.
*
*     The following values (defined in the
c     "ast.h" header file)
f     AST_PAR include file)
*     may be assigned to the
c     "spread"
f     SPREAD
*     parameter. See the
c     astResample<X>
f     AST_RESAMPLE<X>
*     documentation for details of these schemes including the use of the
c     "fspread" and "params" parameters:
f     FSPREAD and PARAMS arguments:
*
*     - AST__NEAREST
*     - AST__LINEAR
*     - AST__SINC
*     - AST__SINCSINC
*     - AST__SINCCOS
*     - AST__SINCGAUSS
*     - AST__SOMBCOS
*
*     In addition, the following schemes can be used with
f     AST_REBIN<X> but not with AST_RESAMPLE<X>:
c     astRebin<X> but not with astResample<X>:
*
*     - AST__GAUSS: This scheme uses a kernel of the form exp(-k*x*x), with k
*     a positive constant determined by the full-width at half-maximum (FWHM).
*     The FWHM should be supplied in units of output pixels by means of the
c     "params[1]"
f     PARAMS(2)
*     value and should be at least 0.1. The
c     "params[0]"
f     PARAMS(1)
*     value should be used to specify at what point the Gaussian is truncated
*     to zero. This should be given as a number of output pixels on either
*     side of the central output point in each dimension (the nearest integer
*     value is used).

*  Control Flags:
c     The following flags are defined in the "ast.h" header file and
f     The following flags are defined in the AST_PAR include file and
*     may be used to provide additional control over the rebinning
*     process. Having selected a set of flags, you should supply the
c     bitwise OR of their values via the "flags" parameter:
f     sum of their values via the FLAGS argument:
*
*     - AST__USEBAD: Indicates that there may be bad pixels in the
*     input array(s) which must be recognised by comparing with the
c     value given for "badval" and propagated to the output array(s).
f     value given for BADVAL and propagated to the output array(s).
*     If this flag is not set, all input values are treated literally
c     and the "badval" value is only used for flagging output array
f     and the BADVAL value is only used for flagging output array
*     values.
f     - AST__USEVAR: Indicates that variance information should be
f     processed in order to provide estimates of the statistical error
f     associated with the rebined values. If this flag is not set,
f     no variance processing will occur and the IN_VAR and OUT_VAR
f     arrays will not be used. (Note that this flag is only available
f     in the Fortran interface to AST.)

*  Propagation of Missing Data:
*     Instances of missing data (bad pixels) in the output grid are
c     identified by occurrences of the "badval" value in the "out"
f     identified by occurrences of the BADVAL value in the OUT
*     array. These are produced if the sum of the weights of the
*     contributing input pixels is less than
c     "wlim".
f     WLIM.
*
*     An input pixel is considered bad (and is consequently ignored) if
*     its
c     data value is equal to "badval" and the AST__USEBAD flag is
c     set via the "flags" parameter.
f     data value is equal to BADVAL and the AST__USEBAD flag is
f     set via the FLAGS argument.
*
*     In addition, associated output variance estimates (if
c     calculated) may be declared bad and flagged with the "badval"
c     value in the "out_var" array for similar reasons.
f     calculated) may be declared bad and flagged with the BADVAL
f     value in the OUT_VAR array for similar reasons.
*--
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_REBIN(X,Xtype,IntType) \
static void Rebin##X( AstMapping *this, double wlim, int ndim_in, \
                     const int lbnd_in[], const int ubnd_in[], \
                     const Xtype in[], const Xtype in_var[], \
                     int spread, const double params[], int flags, \
                     double tol, int maxpix, Xtype badval, \
                     int ndim_out, const int lbnd_out[], \
                     const int ubnd_out[], const int lbnd[], \
                     const int ubnd[], Xtype out[], Xtype out_var[], int *status ) { \
\
/* Local Variables: */ \
   astDECLARE_GLOBALS            /* Thread-specific data */ \
   const char *badflag;          /* Name of illegal flag */ \
   AstMapping *simple;           /* Pointer to simplified Mapping */ \
   Xtype *d;                     /* Pointer to next output data value */ \
   Xtype *v;                     /* Pointer to next output variance value */ \
   double *w;                    /* Pointer to next weight value */ \
   double *work;                 /* Pointer to weight array */ \
   int idim;                     /* Loop counter for coordinate dimensions */ \
   int ipix_out;                 /* Index into output array */ \
   int nin;                      /* Number of Mapping input coordinates */ \
   int nout;                     /* Number of Mapping output coordinates */ \
   int npix;                     /* Number of pixels in input region */ \
   int npix_out;                 /* Number of pixels in output array */ \
   int64_t mpix;                 /* Number of pixels for testing */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Get a pointer to a structure holding thread-specific global data values */ \
   astGET_GLOBALS(this); \
\
/* Obtain values for the Nin and Nout attributes of the Mapping. */ \
   nin = astGetNin( this ); \
   nout = astGetNout( this ); \
\
/* If OK, check that the number of input grid dimensions matches the \
   number required by the Mapping and is at least 1. Report an error \
   if necessary. */ \
   if ( astOK && ( ( ndim_in != nin ) || ( ndim_in < 1 ) ) ) { \
      astError( AST__NGDIN, "astRebin"#X"(%s): Bad number of input grid " \
                "dimensions (%d).", status, astGetClass( this ), ndim_in ); \
      if ( ndim_in != nin ) { \
         astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \
                   "to specify an input position.", status, \
                   astGetClass( this ), nin, ( nin == 1 ) ? "" : "s" ); \
      } \
   } \
\
/* If OK, also check that the number of output grid dimensions matches \
   the number required by the Mapping and is at least 1. Report an \
   error if necessary. */ \
   if ( astOK && ( ( ndim_out != nout ) || ( ndim_out < 1 ) ) ) { \
      astError( AST__NGDIN, "astRebin"#X"(%s): Bad number of output grid " \
                "dimensions (%d).", status, astGetClass( this ), ndim_out ); \
      if ( ndim_out != nout ) { \
         astError( AST__NGDIN, "The %s given generates %s%d coordinate " \
                   "value%s for each output position.", status, astGetClass( this ), \
                   ( nout < ndim_out ) ? "only " : "", nout, \
                   ( nout == 1 ) ? "" : "s" ); \
      } \
   } \
\
/* Check that the lower and upper bounds of the input grid are \
   consistent. Report an error if any pair is not. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_in; idim++ ) { \
         if ( lbnd_in[ idim ] > ubnd_in[ idim ] ) { \
            astError( AST__GBDIN, "astRebin"#X"(%s): Lower bound of " \
                      "input grid (%d) exceeds corresponding upper bound " \
                      "(%d).", status, astGetClass( this ), \
                      lbnd_in[ idim ], ubnd_in[ idim ] ); \
            astError( AST__GBDIN, "Error in input dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } else { \
            mpix *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the input. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astRebin"#X"(%s): Supplied input array " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* Check that the positional accuracy tolerance supplied is valid and \
   report an error if necessary. */ \
   if ( astOK && ( tol < 0.0 ) ) { \
      astError( AST__PATIN, "astRebin"#X"(%s): Invalid positional " \
                "accuracy tolerance (%.*g pixel).", status, \
                astGetClass( this ), AST__DBL_DIG, tol ); \
      astError( AST__PATIN, "This value should not be less than zero." , status); \
   } \
\
/* Check that the initial scale size in pixels supplied is valid and \
   report an error if necessary. */ \
   if ( astOK && ( maxpix < 0 ) ) { \
      astError( AST__SSPIN, "astRebin"#X"(%s): Invalid initial scale " \
                "size in pixels (%d).", status, astGetClass( this ), maxpix ); \
      astError( AST__SSPIN, "This value should not be less than zero." , status); \
   } \
\
/* Check that the lower and upper bounds of the output grid are \
   consistent. Report an error if any pair is not. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         if ( lbnd_out[ idim ] > ubnd_out[ idim ] ) { \
            astError( AST__GBDIN, "astRebin"#X"(%s): Lower bound of " \
                      "output grid (%d) exceeds corresponding upper bound " \
                      "(%d).", status, astGetClass( this ), \
                      lbnd_out[ idim ], ubnd_out[ idim ] ); \
            astError( AST__GBDIN, "Error in output dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } else { \
            mpix *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the output. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astRebin"#X"(%s): Supplied output array " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* Similarly check the bounds of the input region. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         if ( lbnd[ idim ] > ubnd[ idim ] ) { \
            astError( AST__GBDIN, "astRebin"#X"(%s): Lower bound of " \
                      "input region (%d) exceeds corresponding upper " \
                      "bound (%d).", status, astGetClass( this ), \
                      lbnd[ idim ], ubnd[ idim ] ); \
\
/* Also check that the input region lies wholly within the input \
   grid. */ \
         } else if ( lbnd[ idim ] < lbnd_in[ idim ] ) { \
            astError( AST__GBDIN, "astRebin"#X"(%s): Lower bound of " \
                      "input region (%d) is less than corresponding " \
                      "bound of input grid (%d).", status, astGetClass( this ), \
                      lbnd[ idim ], lbnd_in[ idim ] ); \
         } else if ( ubnd[ idim ] > ubnd_in[ idim ] ) { \
            astError( AST__GBDIN, "astRebin"#X"(%s): Upper bound of " \
                      "input region (%d) exceeds corresponding " \
                      "bound of input grid (%d).", status, astGetClass( this ), \
                      ubnd[ idim ], ubnd_in[ idim ] ); \
         } else { \
            mpix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
         } \
\
/* Say which dimension produced the error. */ \
         if ( !astOK ) { \
            astError( AST__GBDIN, "Error in output dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the input region. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astRebin"#X"(%s): Supplied input region " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* If OK, loop to determine how many input pixels are to be binned. */ \
   simple = NULL; \
   npix = 1; \
   npix_out = 1; \
   unsimplified_mapping = this; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_in; idim++ ) { \
         npix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
      } \
\
/* Loop to determine how many pixels the output array contains. */ \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         npix_out *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
      } \
\
/* If there are sufficient pixels to make it worthwhile, simplify the \
   Mapping supplied to improve performance. Otherwise, just clone the \
   Mapping pointer. Note we have already saved a pointer to the original \
   Mapping so that lower-level functions can use it if they need to report \
   an error. */ \
      if ( npix > 1024 ) { \
         simple = astSimplify( this ); \
      } else { \
         simple = astClone( this ); \
      } \
   } \
\
/* Report an error if the forward transformation of this simplified \
   Mapping is not defined. */ \
   if ( !astGetTranForward( simple ) && astOK ) { \
      astError( AST__TRNND, "astRebin"#X"(%s): An forward coordinate " \
                "transformation is not defined by the %s supplied.", status, \
                astGetClass( unsimplified_mapping ), \
                astGetClass( unsimplified_mapping ) ); \
   } \
\
/* Report an error if any illegal flags were supplied. */ \
   if( flags & AST__REBININIT ) { \
      badflag = "AST__REBININIT"; \
   } else if( flags & AST__REBINEND ) { \
      badflag = "AST__REBINEND"; \
   } else if( flags & AST__GENVAR ) { \
      badflag = "AST__GENVAR"; \
   } else if( flags & AST__DISVAR ) { \
      badflag = "AST__DISVAR"; \
   } else if( flags & AST__VARWGT ) { \
      badflag = "AST__VARWGT"; \
   } else if( flags & AST__PARWGT ) { \
      badflag = "AST__PARWGT"; \
   } else if( flags & AST__NONORM ) { \
      badflag = "AST__NONORM"; \
   } else if( flags & AST__CONSERVEFLUX ) { \
      badflag = "AST__CONSERVEFLUX"; \
   } else if( flags & ~( AST__USEBAD + AST__USEVAR ) ) { \
      badflag = "unknown"; \
   } else { \
      badflag = NULL; \
   } \
   if ( badflag && astOK ) { \
      astError( AST__BADFLG, "astRebin"#X"(%s): An illegal flag (%s) "  \
                "was included in the 'flags' argument.", status, \
                astGetClass( unsimplified_mapping ), badflag ); \
   }  \
\
/* If required, allocate work array to hold the sum of the weights \
   contributing to each output pixel, and initialise it to zero. */ \
   if( wlim > 0.0 ) { \
      work = astMalloc( sizeof( double )*(size_t) npix_out ); \
      if( work ) { \
         w = work; \
         for( ipix_out = 0; ipix_out < npix_out; ipix_out++ ) *(w++) = 0.0; \
      } \
   } else { \
      work = NULL; \
   } \
\
/* Initialise the output arrays to hold zeros. */ \
   d = out; \
   if( out_var ) { \
      v = out_var; \
      for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++, v++ ) { \
         *d = 0; \
         *v = 0; \
      } \
   } else { \
      for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++ ) { \
         *d = 0; \
      } \
   } \
\
/* Perform the rebinning. Note that we pass all gridded data, the \
   spread function and the bad pixel value by means of pointer \
   types that obscure the underlying data type. This is to avoid \
   having to replicate functions unnecessarily for each data \
   type. However, we also pass an argument that identifies the data \
   type we have obscured. */ \
   if( RebinAdaptively( simple, ndim_in, lbnd_in, ubnd_in, \
                        (const void *) in, (const void *) in_var, \
                        TYPE_##X, spread, \
                        params, flags, tol, maxpix, \
                        (const void *) &badval, \
                        ndim_out, lbnd_out, ubnd_out, \
                        lbnd, ubnd, npix_out, \
                        (void *) out, (void *) out_var, work, \
                        NULL, status ) && astOK ) { \
      astError( AST__CNFLX, "astRebin"#X"(%s): Flux conservation was " \
                "requested but could not be performed because the " \
                "forward transformation of the supplied Mapping " \
                "is too non-linear.", status, astGetClass( this ) ); \
   } \
\
/* If required set output pixels bad if they have a total weight less \
   than "wlim". */ \
   if( work ) { \
      w = work; \
      d = out; \
      if( out_var ) { \
         v = out_var; \
         for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++, w++, v++ ) { \
            if( fabs( *w ) < wlim ) { \
               *d = badval; \
               *v = badval; \
            } \
         } \
      } else { \
         for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++, w++ ) { \
            if( fabs( *w ) < wlim ) *d = badval; \
         } \
      } \
\
/* Free the work array. */ \
      work = astFree( work ); \
   } \
\
/* Annul the pointer to the simplified/cloned Mapping. */ \
   simple = astAnnul( simple ); \
\
}

/* Expand the above macro to generate a function for each required
   data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_REBIN(LD,long double,0)
#endif
MAKE_REBIN(D,double,0)
MAKE_REBIN(F,float,0)
MAKE_REBIN(I,int,1)
MAKE_REBIN(B,signed char,1)
MAKE_REBIN(UB,unsigned char,1)

/* Undefine the macro. */
#undef MAKE_REBIN

static int RebinAdaptively( AstMapping *this, int ndim_in,
                            const int *lbnd_in, const int *ubnd_in,
                            const void *in, const void *in_var,
                            DataType type, int spread,
                            const double *params, int flags, double tol,
                            int maxpix, const void *badval_ptr,
                            int ndim_out, const int *lbnd_out,
                            const int *ubnd_out, const int *lbnd,
                            const int *ubnd, int npix_out,
                            void *out, void *out_var, double *work,
                            int64_t *nused, int *status ){
/*
*  Name:
*     RebinAdaptively

*  Purpose:
*     Rebin a section of a data grid adaptively.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int RebinAdaptively( AstMapping *this, int ndim_in,
*                          const int *lbnd_in, const int *ubnd_in,
*                          const void *in, const void *in_var,
*                          DataType type, int spread,
*                          const double *params, int flags, double tol,
*                          int maxpix, const void *badval_ptr,
*                          int ndim_out, const int *lbnd_out,
*                          const int *ubnd_out, const int *lbnd,
*                          const int *ubnd, int npix_out, void *out,
*                          void *out_var, double *work, int64_t *nused,
*                          int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function rebins a specified section of a rectangular grid of
*     data (with any number of dimensions) into another rectangular grid
*     (with a possibly different number of dimensions). The coordinate
*     transformation used to convert input pixel coordinates into positions
*     in the output grid is given by the forward transformation of the
*     Mapping which is supplied.  Any pixel spreading scheme may be specified
*     for distributing the flux of an input pixel amongst the output
*     pixels.
*
*     This function is very similar to RebinWithBlocking and RebinSection
*     which lie below it in the calling hierarchy. However, this function
*     also attempts to adapt to the Mapping supplied and to sub-divide the
*     section being rebinned into smaller sections within which a linear
*     approximation to the Mapping may be used.  This reduces the number of
*     Mapping evaluations, thereby improving efficiency particularly when
*     complicated Mappings are involved.

*  Parameters:
*     this
*        Pointer to a Mapping, whose forward transformation may be
*        used to transform the coordinates of pixels in the input
*        grid into associated positions in the output grid.
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be rebinned (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the rebinned data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     spread
*        A value selected from a set of pre-defined macros to identify
*        which pixel spread function should be used.
*     params
*        Pointer to an optional array of parameters that may be passed
*        to the pixel spread algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     flags
*        The bitwise OR of a set of flag values which provide additional
*        control over the resampling operation.
*     tol
*        The maximum permitted positional error in transforming input
*        pixel positions into the output grid in order to rebin
*        it. This should be expressed as a displacement in pixels in
*        the output grid's coordinate system. If the Mapping's forward
*        transformation can be approximated by piecewise linear functions
*        to this accuracy, then such functions may be used instead of the
*        Mapping in order to improve performance. Otherwise, every input
*        pixel position will be transformed individually using the Mapping.
*
*        If linear approximation is not required, a "tol" value of
*        zero may be given. This will ensure that the Mapping is used
*        without any approximation.
*     maxpix
*        A value which specifies the largest scale size on which to
*        search for non-linearities in the Mapping supplied. This
*        value should be expressed as a number of pixels in the input
*        grid. The function will break the input section specified
*        into smaller sub-sections (if necessary), each no larger than
*        "maxpix" pixels in any dimension, before it attempts to
*        approximate the Mapping by a linear function over each
*        sub-section.
*
*        If the value given is larger than the largest dimension of
*        the input section (the normal recommendation), the function
*        will initially search for non-linearity on a scale determined
*        by the size of the input section.  This is almost always
*        satisfactory. Very occasionally, however, a Mapping may
*        appear linear on this scale but nevertheless have smaller
*        irregularities (e.g. "holes") in it.  In such cases, "maxpix"
*        may be set to a suitably smaller value so as to ensure this
*        non-linearity is not overlooked. Typically, a value of 50 to
*        100 pixels might be suitable and should have little effect on
*        performance.
*
*        If too small a value is given, however, it will have the
*        effect of preventing linear approximation occurring at all
*        (equivalent to setting "tol" to zero).  Although this may
*        degrade performance, accurate results will still be obtained.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which rebinned values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the first pixel in the
*        section of the input data grid which is to be rebinned.
*     ubnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the last pixel in the
*        section of the input data grid which is to be rebinned.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the input grid which is to be rebinned. This section
*        should lie wholly within the extent of the input grid (as defined
*        by the "lbnd_out" and "ubnd_out" arrays). Regions of the input
*        grid lying outside this section will be ignored.
*     npix_out
*        The number of pixels in the output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        An optional pointer to a double array with the same size as
*        the "out" array. The contents of this array (if supplied) are
*        incremented by the accumulated weights assigned to each output pixel.
*        If no accumulated weights are required, a NULL pointer should be
*        given.
*     nused
*        An optional pointer to a int64_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A non-zero value is returned if "flags" included AST__CONSERVEFLUX (i.e.
*     flux conservation was requested), but the forward transformation of the
*     supplied Mapping had zero determinant everywhere within the region
*     being binned (no error is reported if this happens). Zero is returned
*     otherwise.

*/

/* Local Variables: */
   double *flbnd;                /* Array holding floating point lower bounds */
   double *fubnd;                /* Array holding floating point upper bounds */
   double *linear_fit;           /* Pointer to array of fit coefficients */
   int *hi;                      /* Pointer to array of section upper bounds */
   int *lo;                      /* Pointer to array of section lower bounds */
   int coord_in;                 /* Loop counter for input coordinates */
   int dim;                      /* Output section dimension size */
   int dimx;                     /* Dimension with maximum section extent */
   int divide;                   /* Sub-divide the output section? */
   int i;                        /* Loop count */
   int isLinear;                 /* Is the transformation linear? */
   int mxdim;                    /* Largest output section dimension size */
   int need_fit;                 /* Do we need to perform a linear fit? */
   int npix;                     /* Number of pixels in output section */
   int npoint;                   /* Number of points for obtaining a fit */
   int nvertex;                  /* Number of vertices of output section */
   int result;                   /* Returned value */
   int res1;                     /* Flux conservation error in 1st section? */
   int res2;                     /* Flux conservation error in 2nd section? */
   int toobig;                   /* Section too big (must sub-divide)? */
   int toosmall;                 /* Section too small to sub-divide? */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialisation. */
   npix = 1;
   mxdim = 0;
   dimx = 1;
   nvertex = 1;

/* Loop through the input grid dimensions. */
   for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {

/* Obtain the extent in each dimension of the input section which is
   to be rebinned, and calculate the total number of pixels it contains. */
      dim = ubnd[ coord_in ] - lbnd[ coord_in ] + 1;
      npix *= dim;

/* Find the maximum dimension size of this input section and note which
   dimension has this size. */
      if ( dim > mxdim ) {
         mxdim = dim;
         dimx = coord_in;
      }

/* Calculate how many vertices the output section has. */
      nvertex *= 2;
   }

/* Calculate how many sample points will be needed (by the astLinearApprox
   function) to obtain a linear fit to the Mapping's forward transformation. */
   npoint = 1 + 4 * ndim_in + 2 * nvertex;

/* If the number of pixels in the input section is not at least 4
   times this number, we will probably not save significant time by
   attempting to obtain a linear fit, so note that the input section
   is too small. */
   toosmall = ( npix < ( 4 * npoint ) );

/* Note if the maximum dimension of the input section exceeds the
   user-supplied scale factor. */
   toobig = ( maxpix < mxdim );

/* Indicate we do not yet have a linear fit. */
   linear_fit = NULL;

/* Initialise a flag indicating if we need to perform a linear fit. This
   is always the case if flux conservation was requested. */
   need_fit = ( flags & AST__CONSERVEFLUX );

/* If the output section is too small to be worth obtaining a linear
   fit, or if the accuracy tolerance is zero, we will not
   sub-divide. This means that the Mapping will be used to transform
   each pixel's coordinates and no linear approximation will be
   used. */
   if ( toosmall || ( tol == 0.0 ) ) {
      divide = 0;

/* Otherwise, if the largest input section dimension exceeds the
   scale length given, we will sub-divide. This offers the possibility
   of obtaining a linear approximation to the Mapping over a reduced
   range of input coordinates (which will be handled by a recursive
   invocation of this function). */
   } else if ( toobig ) {
      divide = 1;

/* If neither of the above apply, we need to do a fit regardless of
   whether flux conservation was requested or not. Whether we divide or
   not will depend on whether the Mapping is linear or not. Assume for
   the moment that the Mapping is not linear and so we will divide. */
   } else {
      need_fit = 1;
      divide = 1;
   }

/* If required, attempt to fit a linear approximation to the Mapping's
   forward transformation over the range of coordinates covered by the
   input section. We need to temporarily copy the integer bounds into
   floating point arrays to use astLinearApprox. */
   if( need_fit ) {

/* Allocate memory for floating point bounds and for the coefficient array */
      flbnd = astMalloc( sizeof( double )*(size_t) ndim_in );
      fubnd = astMalloc( sizeof( double )*(size_t) ndim_in );
      linear_fit = astMalloc( sizeof( double )*
                              (size_t) ( ndim_out*( ndim_in + 1 ) ) );
      if( astOK ) {

/* Copy the bounds into these arrays, and change them so that they refer
   to the lower and upper edges of the cell rather than the centre. This
   is essential if one of the axes is spanned by a single cell, since
   otherwise the upper and lower bounds would be identical. */
         for( i = 0; i < ndim_in; i++ ) {
            flbnd[ i ] = (double) lbnd[ i ] - 0.5;
            fubnd[ i ] = (double) ubnd[ i ] + 0.5;
         }

/* Get the linear approximation to the forward transformation. */
         isLinear = astLinearApprox( this, flbnd, fubnd, tol, linear_fit );

/* Free the coeff array if the inverse transformation is not linear. */
         if( !isLinear ) linear_fit = astFree( linear_fit );

      } else {
         linear_fit = astFree( linear_fit );
      }

/* Free resources */
      flbnd = astFree( flbnd );
      fubnd = astFree( fubnd );

/* If a linear fit was obtained, we will use it and therefore do not
   wish to sub-divide further. Otherwise, we sub-divide (unless the
   section is too small or too big as determined earlier) in the hope
   that this may result in a linear fit next time. */
      if( linear_fit ) divide = 0;
   }

/* If no sub-division is required, perform rebinning (in a
   memory-efficient manner, since the section we are rebinning might
   still be very large). This will use the linear fit, if obtained
   above. */
   if ( astOK ) {
      if ( !divide ) {
         result = RebinWithBlocking( this, linear_fit, ndim_in, lbnd_in,
                                     ubnd_in, in, in_var, type, spread,
                                     params, flags, badval_ptr, ndim_out,
                                     lbnd_out, ubnd_out, lbnd, ubnd, npix_out,
                                     out, out_var, work, nused, status );

/* Otherwise, allocate workspace to perform the sub-division. */
      } else {
         lo = astMalloc( sizeof( int ) * (size_t) ndim_in );
         hi = astMalloc( sizeof( int ) * (size_t) ndim_in );
         if ( astOK ) {

/* Initialise the bounds of a new input section to match the original
   input section. */
            for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
               lo[ coord_in ] = lbnd[ coord_in ];
               hi[ coord_in ] = ubnd[ coord_in ];
            }

/* Replace the upper bound of the section's largest dimension with the
   mid-point of the section along this dimension, rounded downwards. */
            hi[ dimx ] =
               (int) floor( 0.5 * (double) ( lbnd[ dimx ] + ubnd[ dimx ] ) );

/* Rebin the resulting smaller section using a recursive invocation
   of this function. */
            res1 = RebinAdaptively( this, ndim_in, lbnd_in, ubnd_in, in,
                                    in_var, type, spread, params,
                                    flags, tol, maxpix, badval_ptr, ndim_out,
                                    lbnd_out, ubnd_out, lo, hi, npix_out, out,
                                    out_var, work, nused, status );

/* Now set up a second section which covers the remaining half of the
   original input section. */
            lo[ dimx ] = hi[ dimx ] + 1;
            hi[ dimx ] = ubnd[ dimx ];

/* If this section contains pixels, resample it in the same way,
   summing the returned values. */
            if ( lo[ dimx ] <= hi[ dimx ] ) {
               res2 = RebinAdaptively( this, ndim_in, lbnd_in, ubnd_in, in,
                                       in_var, type, spread, params,
                                       flags, tol, maxpix, badval_ptr,
                                       ndim_out, lbnd_out, ubnd_out,
                                       lo, hi, npix_out, out, out_var, work,
                                       nused, status );
            } else {
               res2 = 0;
            }

/* If neither section could be rebinned because of an indeterminant
   mapping, return a result indicating this. */
            result = ( res1 && res2 );
         }

/* Free the workspace. */
         lo = astFree( lo );
         hi = astFree( hi );
      }
   }

/* If coefficients for a linear fit were obtained, then free the space
   they occupy. */
   if ( linear_fit ) linear_fit = astFree( linear_fit );

/* Retyurn a flag indicating if no part of the array could be binned
   because of an indeterminate Mapping. */
   return result;
}

static void RebinSection( AstMapping *this, const double *linear_fit,
                          int ndim_in, const int *lbnd_in, const int *ubnd_in,
                          const void *in, const void *in_var, double infac,
                          DataType type, int spread, const double *iparams,
                          int flags, const void *badval_ptr, int ndim_out,
                          const int *lbnd_out, const int *ubnd_out,
                          const int *lbnd, const int *ubnd, int npix_out,
                          void *out, void *out_var, double *work,
                          int64_t *nused, int *status ) {
/*
*  Name:
*     RebinSection

*  Purpose:
*     Rebin a section of a data grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void RebinSection( AstMapping *this, const double *linear_fit,
*                        int ndim_in, const int *lbnd_in, const int *ubnd_in,
*                        const void *in, const void *in_var, double infac,
*                        DataType type, int spread, const double *iparams,
*                        int flags, const void *badval_ptr, int ndim_out,
*                        const int *lbnd_out, const int *ubnd_out,
*                        const int *lbnd, const int *ubnd, int npix_out,
*                        void *out, void *out_var, double *work,
*                        int64_t *nused, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function rebins a specified section of a rectangular grid of
*     data (with any number of dimensions) into another rectangular grid
*     (with a possibly different number of dimensions). The coordinate
*     transformation used to convert input pixel coordinates into positions
*     in the output grid is given by the forward transformation of the
*     Mapping which is supplied or, alternatively, by a linear approximation
*     fitted to a Mapping's forward transformation. Any pixel spreading scheme
*     may be specified for distributing the flux of an input pixel amongst
*     the output pixels.

*  Parameters:
*     this
*        Pointer to a Mapping, whose forward transformation may be
*        used to transform the coordinates of pixels in the input
*        grid into associated positions in the output grid.
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's forward coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        forward transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be rebinned (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the rebinned data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     infac
*        A factor by which to multiply the input data values before use.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     spread
*        A value selected from a set of pre-defined macros to identify
*        which pixel spread function should be used.
*     iparams
*        Pointer to an optional array of parameters that may be passed
*        to the pixel spread algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     flags
*        The bitwise OR of a set of flag values which provide additional
*        control over the resampling operation.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which rebinned values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the first pixel in the
*        section of the input data grid which is to be rebinned.
*     ubnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the last pixel in the
*        section of the input data grid which is to be rebinned.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the input grid which is to be rebinned. This section
*        should lie wholly within the extent of the input grid (as defined
*        by the "lbnd_out" and "ubnd_out" arrays). Regions of the input
*        grid lying outside this section will be ignored.
*     npix_out
*        The number of pixels in the output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        An optional pointer to a double array with the same size as
*        the "out" array. The contents of this array (if supplied) are
*        incremented by the accumulated weights assigned to each output pixel.
*        If no accumulated weights are required, a NULL pointer should be
*        given.
*     nused
*        An optional pointer to a int64_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.

*  Notes:
*     - This function does not take steps to limit memory usage if the
*     grids supplied are large. To resample large grids in a more
*     memory-efficient way, the ResampleWithBlocking function should
*     be used.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Thread-specific data */
   AstPointSet *pset_in;         /* Input PointSet for transformation */
   AstPointSet *pset_out;        /* Output PointSet for transformation */
   const double *params;         /* Pointer to spreading scheme parameters */
   const double *grad;           /* Pointer to gradient matrix of linear fit */
   const double *zero;           /* Pointer to zero point array of fit */
   double **ptr_in;              /* Pointer to input PointSet coordinates */
   double **ptr_out;             /* Pointer to output PointSet coordinates */
   double *accum;                /* Pointer to array of accumulated sums */
   double conwgt;                /* Constant weight for all pixels */
   double x1;                    /* Interim x coordinate value */
   double xx1;                   /* Initial x coordinate value */
   double y1;                    /* Interim y coordinate value */
   double yy1;                   /* Initial y coordinate value */
   int *dim;                     /* Pointer to array of output pixel indices */
   int *offset;                  /* Pointer to array of output pixel offsets */
   int *stride;                  /* Pointer to array of output grid strides */
   int coord_in;                 /* Loop counter for input dimensions */
   int coord_out;                /* Loop counter for output dimensions */
   int done;                     /* All pixel indices done? */
   int i1;                       /* Interim offset into "accum" array */
   int i2;                       /* Final offset into "accum" array */
   int idim;                     /* Loop counter for dimensions */
   int ix;                       /* Loop counter for output x coordinate */
   int iy;                       /* Loop counter for output y coordinate */
   int neighb;                   /* Number of neighbouring pixels */
   int npoint;                   /* Number of output points (pixels) */
   int off1;                     /* Interim pixel offset into output array */
   int off2;                     /* Interim pixel offset into output array */
   int off;                      /* Final pixel offset into output array */
   int point;                    /* Counter for output points (pixels ) */
   int s;                        /* Temporary variable for strides */
   const double *par;            /* Pointer to parameter array */
   double fwhm;                  /* Full width half max. of gaussian */
   double lpar[ 1 ];             /* Local parameter array */
   void (* kernel)( double, const double [], int, double *, int * ); /* Kernel fn. */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to a structure holding thread-specific global data values */
   astGET_GLOBALS(this);

/* Further initialisation. */
   pset_in = NULL;
   ptr_in = NULL;
   ptr_out = NULL;
   pset_out = NULL;
   neighb = 0;
   kernel = NULL;

/* If a constant weight is to be factored in to all pixels, it will have
   been supplied as the first value in the "params" array, with the remaining
   values being the actual parameters of the requested spreading scheme.
   Copy the constant weight into another value and modify the pointer to the
   start of the params array to exclude it. */
   if( flags & AST__PARWGT ) {
      params = iparams + 1;
      conwgt = iparams[ 0 ];
   } else {
      params = iparams;
      conwgt = 1.0;
   }

/* Calculate the number of input points, as given by the product of
   the input grid dimensions. */
   for ( npoint = 1, coord_in = 0; coord_in < ndim_in; coord_in++ ) {
      npoint *= ubnd[ coord_in ] - lbnd[ coord_in ] + 1;
   }

/* Allocate workspace. */
   offset = astMalloc( sizeof( int ) * (size_t) npoint );
   stride = astMalloc( sizeof( int ) * (size_t) ndim_in );
   if ( astOK ) {

/* Calculate the stride for each input grid dimension. */
      off = 0;
      s = 1;
      for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
         stride[ coord_in ] = s;
         s *= ubnd_in[ coord_in ] - lbnd_in[ coord_in ] + 1;
      }

/* A linear fit to the Mapping is available. */
/* ========================================= */
      if ( linear_fit ) {

/* If a linear fit to the Mapping has been provided, then obtain
   pointers to the array of gradients and zero-points comprising the
   fit. */
         grad = linear_fit + ndim_out;
         zero = linear_fit;

/* Create a PointSet to hold the output grid coordinates and obtain an
   array of pointers to its coordinate data. */
         pset_out = astPointSet( npoint, ndim_out, "", status );
         ptr_out = astGetPoints( pset_out );
         if ( astOK ) {

/* Initialise the count of input points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ( ndim_in == 1 ) && ( ndim_out == 1 ) ) {

/* Loop through the pixels of the input grid and transform their x
   coordinates into the output grid's coordinate system using the
   linear fit supplied. Store the results in the PointSet created
   above. */
               off = lbnd[ 0 ] - lbnd_in[ 0 ];
               xx1 = zero[ 0 ] + grad[ 0 ] * (double) lbnd[ 0 ];

               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_out[ 0 ][ point ] = xx1;
                  xx1 += grad[ 0 ];
                  offset[ point++ ] = off++;
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ( ndim_in == 2 ) && ( ndim_out == 2 ) ) {

/* Loop through the range of y coordinates in the input grid and
   calculate interim values of the output coordinates using the linear
   fit supplied. */
               x1 = zero[ 0 ] + grad[ 1 ] * (double) ( lbnd[ 1 ] - 1 );
               y1 = zero[ 1 ] + grad[ 3 ] * (double) ( lbnd[ 1 ] - 1 );
               off1 = stride[ 1 ] * ( lbnd[ 1 ] - lbnd_in[ 1 ] - 1 ) - lbnd_in[ 0 ];
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  x1 += grad[ 1 ];
                  y1 += grad[ 3 ];

/* Also calculate an interim pixel offset into the input array. */
                  off1 += stride[ 1 ];

/* Now loop through the range of input x coordinates and calculate
   the final values of the input coordinates, storing the results in
   the PointSet created above. */
                  xx1 = x1 + grad[ 0 ] * (double) lbnd[ 0 ];
                  yy1 = y1 + grad[ 2 ] * (double) lbnd[ 0 ];
                  off = off1 + lbnd[ 0 ];
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_out[ 0 ][ point ] = xx1;
                     xx1 += grad[ 0 ];
                     ptr_out[ 1 ][ point ] = yy1;
                     yy1 += grad[ 2 ];

/* Also calculate final pixel offsets into the input array. */
                     offset[ point++ ] = off++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               accum = astMalloc( sizeof( double ) *
                                 (size_t) ( ndim_in * ndim_out ) );
               dim = astMalloc( sizeof( int ) * (size_t) ndim_in );
               if ( astOK ) {

/* Initialise an array of pixel indices for the input grid which refer to the
   first pixel which we will rebin. Also calculate the offset of this pixel
   within the input array. */
                  off = 0;
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     dim[ coord_in ] = lbnd[ coord_in ];
                     off += stride[ coord_in ] *
                            ( dim[ coord_in ] - lbnd_in[ coord_in ] );
                  }

/* To calculate each output grid coordinate we must perform a matrix
   multiply on the input grid coordinates (using the gradient matrix)
   and then add the zero points. However, since we will usually only
   be altering one input coordinate at a time (the least
   significant), we can avoid the full matrix multiply by accumulating
   partial sums for the most significant input coordinates and only
   altering those sums which need to change each time. The zero points
   never change, so we first fill the "most significant" end of the
   "accum" array with these. */
                  for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                     accum[ ( coord_out + 1 ) * ndim_in - 1 ] =
                                                              zero[ coord_out ];
                  }
                  coord_in = ndim_in - 1;

/* Now loop to process each input pixel. */
                  for ( done = 0; !done; point++ ) {

/* To generate the output coordinate that corresponds to the current
   input pixel, we work down from the most significant dimension
   whose index has changed since the previous pixel we considered
   (given by "coord_in"). For each affected dimension, we accumulate
   in "accum" the matrix sum (including the zero point) for that
   dimension and all higher input dimensions. We must accumulate a
   separate set of sums for each output coordinate we wish to
   produce. (Note that for the first pixel we process, all dimensions
   are considered "changed", so we start by initialising the whole
   "accum" array.) */
                     for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
/*
                        ptr_out[ coord_out ][ point ] = zero[ coord_out ];
                        for ( idim = 0; idim < ndim_in; idim++ ) {
                           ptr_out[ coord_out ][ point ] +=
                                 grad[ idim + coord_out*ndim_in ] *
                                 dim[ idim ];
                        }
*/

                        i1 = coord_out * ndim_in;
                        for ( idim = coord_in; idim >= 1; idim-- ) {
                           i2 = i1 + idim;
                           accum[ i2 - 1 ] = accum[ i2 ] +
                                             dim[ idim ] * grad[ i2 ];
                        }

/* The output coordinate for each dimension is given by the accumulated
   sum for input dimension zero (giving the sum over all input
   dimensions). We do not store this in the "accum" array, but assign
   the result directly to the coordinate array of the PointSet created
   earlier. */
                        ptr_out[ coord_out ][ point ] = accum[ i1 ] +
                                                      dim[ 0 ] * grad[ i1 ];
                     }

/* Store the offset of the current pixel in the input array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next input pixel. */
                     coord_in = 0;
                     do {

/* The least significant index which currently has less than its maximum
   value is incremented by one. The offset into the input array is updated
   accordingly. */
                        if ( dim[ coord_in ] < ubnd[ coord_in ] ) {
                           dim[ coord_in ]++;
                           off += stride[ coord_in ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the input pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_in ] = lbnd[ coord_in ];
                           off -= stride[ coord_in ] *
                                  ( ubnd[ coord_in ] - lbnd[ coord_in ] );

/* All the output pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_in == ndim_in );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               accum = astFree( accum );
               dim = astFree( dim );
            }
         }

/* No linear fit to the Mapping is available. */
/* ========================================== */
      } else {

/* Create a PointSet to hold the coordinates of the input pixels and
   obtain a pointer to its coordinate data. */
         pset_in = astPointSet( npoint, ndim_in, "", status );
         ptr_in = astGetPoints( pset_in );
         if ( astOK ) {

/* Initialise the count of input points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ndim_in == 1 && ndim_out == 1 ) {

/* Loop through the required range of input x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   pixel offset into the input array. */
               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_in[ 0 ][ point ] = (double) ix;
                  offset[ point++ ] = ix - lbnd_in[ 0 ];
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ndim_in == 2 && ndim_out == 2) {

/* Loop through the required range of input y coordinates,
   calculating an interim pixel offset into the input array. */
               off1 = stride[ 1 ] * ( lbnd[ 1 ] - lbnd_in[ 1 ] - 1 )
                      - lbnd_in[ 0 ];
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  off1 += stride[ 1 ];

/* Loop through the required range of input x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   final pixel offset into the input array. */
                  off2 = off1 + lbnd[ 0 ];
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_in[ 0 ][ point ] = (double) ix;
                     ptr_in[ 1 ][ point ] = (double) iy;
                     offset[ point++ ] = off2++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               dim = astMalloc( sizeof( int ) * (size_t) ndim_in );
               if ( astOK ) {

/* Initialise an array of pixel indices for the input grid which
   refer to the first pixel to be rebinned. Also calculate the offset
   of this pixel within the input array. */
                  off = 0;
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     dim[ coord_in ] = lbnd[ coord_in ];
                     off += stride[ coord_in ] *
                            ( dim[ coord_in ] - lbnd_in[ coord_in ] );
                  }

/* Loop to generate the coordinates of each input pixel. */
                  for ( done = 0; !done; point++ ) {

/* Copy each pixel's coordinates into the PointSet created above. */
                     for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                        ptr_in[ coord_in ][ point ] =
                                                     (double) dim[ coord_in ];
                    }

/* Store the offset of the pixel in the input array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next input
   pixel. */
                     coord_in = 0;
                     do {

/* The least significant index which currently has less than its
   maximum value is incremented by one. The offset into the input
   array is updated accordingly. */
                        if ( dim[ coord_in ] < ubnd[ coord_in ] ) {
                           dim[ coord_in ]++;
                           off += stride[ coord_in ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the input pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_in ] = lbnd[ coord_in ];
                           off -= stride[ coord_in ] *
                                  ( ubnd[ coord_in ] - lbnd[ coord_in ] );

/* All the input pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_in == ndim_in );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               dim = astFree( dim );
            }

/* When all the input pixel coordinates have been generated, use the
   Mapping's forward transformation to generate the output coordinates
   from them. Obtain an array of pointers to the resulting coordinate
   data. */
            pset_out = astTransform( this, pset_in, 1, NULL );
            ptr_out = astGetPoints( pset_out );
         }

/* Annul the PointSet containing the input coordinates. */
         pset_in = astAnnul( pset_in );
      }
   }


/* Rebin the input grid. */
/* ------------------------ */
   if( astOK ) {

/* Identify the pixel spreading scheme to be used. */
/* Nearest pixel. */
/* -------------- */
      switch ( spread ) {
         case AST__NEAREST:

/* Define a macro to use a "case" statement to invoke the
   nearest-pixel spreading function appropriate to a given data
   type. */
#define CASE_NEAREST(X,Xtype) \
               case ( TYPE_##X ): \
                  SpreadNearest##X( ndim_out, lbnd_out, ubnd_out, \
                                    (Xtype *) in, (Xtype *) in_var, \
                                    infac, npoint, offset, \
                                    (const double *const *) ptr_out, \
                                    conwgt, flags, *( (Xtype *) badval_ptr ), \
                                    npix_out, (Xtype *) out, \
                                    (Xtype *) out_var, work, nused, status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_NEAREST(LD,long double)
#endif
               CASE_NEAREST(D,double)
               CASE_NEAREST(F,float)
               CASE_NEAREST(I,int)
               CASE_NEAREST(B,signed char)
               CASE_NEAREST(UB,unsigned char)

               case ( TYPE_L ): break;
               case ( TYPE_K ): break;
               case ( TYPE_S ): break;
               case ( TYPE_UL ): break;
               case ( TYPE_UI ): break;
               case ( TYPE_UK ): break;
               case ( TYPE_US ): break;
            }
            break;

/* Undefine the macro. */
#undef CASE_NEAREST

/* Linear spreading. */
/* ----------------- */
/* Note this is also the default if zero is given. */
         case AST__LINEAR:
         case 0:

/* Define a macro to use a "case" statement to invoke the linear
   spreading function appropriate to a given data type. */
#define CASE_LINEAR(X,Xtype) \
               case ( TYPE_##X ): \
                  SpreadLinear##X( ndim_out, lbnd_out, ubnd_out,\
                                   (Xtype *) in, (Xtype *) in_var, \
                                   infac, npoint, offset, \
                                   (const double *const *) ptr_out, \
                                   conwgt, flags, *( (Xtype *) badval_ptr ), \
                                   npix_out, (Xtype *) out, \
                                   (Xtype *) out_var, work, nused, status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_LINEAR(LD,long double)
#endif
               CASE_LINEAR(D,double)
               CASE_LINEAR(F,float)
               CASE_LINEAR(I,int)
               CASE_LINEAR(B,signed char)
               CASE_LINEAR(UB,unsigned char)

               case ( TYPE_L ): break;
               case ( TYPE_K ): break;
               case ( TYPE_S ): break;
               case ( TYPE_UL ): break;
               case ( TYPE_UI ): break;
               case ( TYPE_UK ): break;
               case ( TYPE_US ): break;
            }
            break;

/* Undefine the macro. */
#undef CASE_LINEAR

/* Spreading using a 1-d kernel. */
/* ----------------------------- */
         case AST__SINC:
         case AST__SINCCOS:
         case AST__SINCGAUSS:
         case AST__GAUSS:
         case AST__SINCSINC:
         case AST__SOMB:
         case AST__SOMBCOS:

/* Obtain a pointer to the appropriate 1-d kernel function (either
   internal or user-defined) and set up any parameters it may
   require. */
            par = NULL;
            switch ( spread ) {

/* sinc(pi*x) */
/* ---------- */
/* Assign the kernel function. */
               case AST__SINC:
                  kernel = Sinc;

/* Calculate the number of neighbouring pixels to use. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) {
                     neighb = 2;
                  } else {
                     neighb = MaxI( 1, neighb, status );
                  }
                  break;

/* somb(pi*x) */
/* ---------- */
/* Assign the kernel function. */
               case AST__SOMB:
                  kernel = Somb;

/* Calculate the number of neighbouring pixels to use. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) {
                     neighb = 2;
                  } else {
                     neighb = MaxI( 1, neighb, status );
                  }
                  break;

/* sinc(pi*x)*cos(k*pi*x) */
/* ---------------------- */
/* Assign the kernel function. */
               case AST__SINCCOS:
                  kernel = SincCos;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;

/* sinc(pi*x)*exp(-k*x*x) */
/* ---------------------- */
/* Assign the kernel function. */
               case AST__SINCGAUSS:
                  kernel = SincGauss;

/* Constrain the full width half maximum of the gaussian factor. */
                  fwhm = MaxD( 0.1, params[ 1 ], status );

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 4.0 * log( 2.0 ) / ( fwhm * fwhm );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, use the number of neighbouring pixels required by the width
   of the kernel (out to where the gaussian term falls to 1% of its
   peak value). */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = (int) ceil( sqrt( -log( 0.01 ) /
                                                                lpar[ 0 ] ) );
                  break;

/* exp(-k*x*x) */
/* ----------- */
/* Assign the kernel function. */
               case AST__GAUSS:
                  kernel = Gauss;

/* Constrain the full width half maximum of the gaussian. */
                  fwhm = MaxD( 0.1, params[ 1 ], status );

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 4.0 * log( 2.0 ) / ( fwhm * fwhm );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, use the number of neighbouring pixels required by the width
   of the kernel (out to where the gaussian term falls to 1% of its
   peak value). */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = (int) ceil( sqrt( -log( 0.01 ) /
                                                                lpar[ 0 ] ) );
                  break;

/* somb(pi*x)*cos(k*pi*x) */
/* ---------------------- */
/* Assign the kernel function. */
               case AST__SOMBCOS:
                  kernel = SombCos;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;

/* sinc(pi*x)*sinc(k*pi*x) */
/* ----------------------- */
/* Assign the kernel function. */
               case AST__SINCSINC:
                  kernel = SincSinc;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;
            }

/* Define a macro to use a "case" statement to invoke the 1-d kernel
   interpolation function appropriate to a given data type, passing it
   the pointer to the kernel function obtained above. */
#define CASE_KERNEL1(X,Xtype) \
               case ( TYPE_##X ): \
                  SpreadKernel1##X( this, ndim_out, lbnd_out, ubnd_out, \
                                         (Xtype *) in, (Xtype *) in_var, \
                                         infac, npoint, offset, \
                                         (const double *const *) ptr_out, \
                                         kernel, neighb, par, conwgt, flags, \
                                         *( (Xtype *) badval_ptr ), \
                                         npix_out, (Xtype *) out, \
                                         (Xtype *) out_var, work, nused, \
                                         status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_KERNEL1(LD,long double)
#endif
               CASE_KERNEL1(D,double)
               CASE_KERNEL1(F,float)
               CASE_KERNEL1(I,int)
               CASE_KERNEL1(B,signed char)
               CASE_KERNEL1(UB,unsigned char)

               case ( TYPE_L ): break;
               case ( TYPE_K ): break;
               case ( TYPE_S ): break;
               case ( TYPE_UL ): break;
               case ( TYPE_UI ): break;
               case ( TYPE_UK ): break;
               case ( TYPE_US ): break;
            }
            break;

/* Undefine the macro. */
#undef CASE_KERNEL1

/* Error: invalid pixel spreading scheme specified. */
/* ------------------------------------------------ */
         default:

/* Define a macro to report an error message appropriate to a given
   data type. */
#define CASE_ERROR(X) \
            case TYPE_##X: \
               astError( AST__SISIN, "astRebin"#X"(%s): Invalid " \
                         "pixel spreading scheme (%d) specified.", status, \
                         astGetClass( unsimplified_mapping ), spread ); \
               break;

/* Use the above macro to report an appropriate error message. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_ERROR(LD)
#endif
               CASE_ERROR(D)
               CASE_ERROR(F)
               CASE_ERROR(I)
               CASE_ERROR(B)
               CASE_ERROR(UB)

               case ( TYPE_L ): break;
               case ( TYPE_K ): break;
               case ( TYPE_S ): break;
               case ( TYPE_UL ): break;
               case ( TYPE_UI ): break;
               case ( TYPE_UK ): break;
               case ( TYPE_US ): break;
            }
            break;

/* Undefine the macro. */
#undef CASE_ERROR
      }
   }

/* Annul the PointSet used to hold output coordinates. */
   pset_out = astAnnul( pset_out );

/* Free the workspace. */
   offset = astFree( offset );
   stride = astFree( stride );
}

/*
*++
*  Name:
c     astRebinSeq<X>
f     AST_REBINSEQ<X>

*  Purpose:
*     Rebin a region of a sequence of data grids.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astRebinSeq<X>( AstMapping *this, double wlim, int ndim_in,
c                          const int lbnd_in[], const int ubnd_in[],
c                          const <Xtype> in[], const <Xtype> in_var[],
c                          int spread, const double params[], int flags,
c                          double tol, int maxpix, <Xtype> badval,
c                          int ndim_out, const int lbnd_out[],
c                          const int ubnd_out[], const int lbnd[],
c                          const int ubnd[], <Xtype> out[], <Xtype> out_var[],
c                          double weights[], int64_t *nused );
f     CALL AST_REBINSEQ<X>( THIS, WLIM, NDIM_IN, LBND_IN, UBND_IN, IN, IN_VAR,
f                           SPREAD, PARAMS, FLAGS, TOL, MAXPIX, BADVAL,
f                           NDIM_OUT, LBND_OUT, UBND_OUT, LBND, UBND, OUT,
f                           OUT_VAR, WEIGHTS, NUSED, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This set of
c     functions is identical to astRebin<X>
f     routines is identical to AST_REBIN<X>
*     except that the rebinned input data is added into the supplied
*     output arrays, rather than simply over-writing the contents of the
*     output arrays. Thus, by calling this
c     function
f     routine
*     repeatedly, a sequence of input arrays can be rebinned and accumulated
*     into a single output array, effectively forming a mosaic of the
*     input data arrays.
*
*     In addition, the weights associated with each output pixel are
*     returned. The weight of an output pixel indicates the number of input
*     pixels which have been accumulated in that output pixel. If the entire
*     value of an input pixel is assigned to a single output pixel, then the
*     weight of that output pixel is incremented by one. If some fraction of
*     the value of an input pixel is assigned to an output pixel, then the
*     weight of that output pixel is incremented by the fraction used.
*
*     The start of a new sequence is indicated by specifying the
*     AST__REBININIT flag via the
c     "flags" parameter.
f     FLAGS argument.
*     This causes the supplied arrays to be filled with zeros before the
*     rebinned input data is added into them. Subsequenct invocations
*     within the same sequence should omit the AST__REBININIT flag.
*
*     The last call in a sequence is indicated by specifying the
*     AST__REBINEND flag. Depending on which flags are supplied, this may
*     cause the output data and variance arrays to be normalised before
*     being returned. This normalisation consists of dividing the data
*     array by the weights array, and can eliminate artifacts which may be
*     introduced into the rebinned data as a consequence of aliasing
*     between the input and output grids. This results in each output
*     pixel value being the weighted mean of the input pixel values that
*     fall in the neighbourhood of the output pixel (rather like
c     astResample<X>).
f     AST_RESAMPLE<X>).
*     Optionally, these normalised
*     values can then be multiplied by a scaling factor to ensure that the
*     total data sum in any small area is unchanged. This scaling factor
*     is equivalent to the number of input pixel values that fall into each
*     output pixel. In addition to
*     normalisation of the output data values, any output variances are
*     also appropriately normalised, and any output data values with
*     weight less than
c     "wlim" are set to "badval".
f     WLIM are set to BADVAL.
*
*     Output variances can be generated in two ways; by rebinning the supplied
*     input variances with appropriate weights, or by finding the spread of
*     input data values contributing to each output pixel (see the AST__GENVAR
*     and AST__USEVAR flags).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to a Mapping, whose forward transformation will be
*        used to transform the coordinates of pixels in the input
*        grid into the coordinate system of the output grid.
*
*        The number of input coordinates used by this Mapping (as
*        given by its Nin attribute) should match the number of input
c        grid dimensions given by the value of "ndim_in"
f        grid dimensions given by the value of NDIM_IN
*        below. Similarly, the number of output coordinates (Nout
*        attribute) should match the number of output grid dimensions
c        given by "ndim_out".
f        given by NDIM_OUT.
c        If "in" is NULL, the Mapping will not be used, but a valid
c        Mapping must still be supplied.
c     wlim
f     WLIM = DOUBLE PRECISION (Given)
*        This value is only used if the AST__REBINEND flag is specified
*        via the
c        "flags" parameter.
f        FLAGS argument.
*        It gives the required number of input pixel values which must
*        contribute to an output pixel (i.e. the output pixel weight) in
*        order for the output pixel value to be considered valid. If the sum
*        of the input pixel weights contributing to an output pixel is less
*        than the supplied
c        "wlim"
f        WLIM
*        value, then the output pixel value is returned set to the
*        supplied bad value. If the supplied value is less than 1.0E-10
*        then 1.0E-10 is used instead.
c     ndim_in
f     NDIM_IN = INTEGER (Given)
*        The number of dimensions in the input grid. This should be at
*        least one.
c        Not used if "in" is NULL.
c     lbnd_in
f     LBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
c        Not used if "in" is NULL.
c     ubnd_in
f     UBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
c        Note that "lbnd_in" and "ubnd_in" together define the shape
f        Note that LBND_IN and UBND_IN together define the shape
*        and size of the input grid, its extent along a particular
c        (j'th) dimension being ubnd_in[j]-lbnd_in[j]+1 (assuming the
c        index "j" to be zero-based). They also define
f        (J'th) dimension being UBND_IN(J)-LBND_IN(J)+1. They also define
*        the input grid's coordinate system, each pixel having unit
*        extent along each dimension with integral coordinate values
*        at its centre.
c        Not used if "in" is NULL.
c     in
f     IN( * ) = <Xtype> (Given)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        input grid, containing the input data to be rebined.  The
*        numerical type of this array should match the 1- or
*        2-character type code appended to the function name (e.g. if
c        you are using astRebinSeqF, the type of each array element
c        should be "float").
f        you are using AST_REBINSEQR, the type of each array element
f        should be REAL).
*
*        The storage order of data within this array should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c        If a NULL pointer is supplied for "in", then no data is added to
c        the output arrays, but any initialisation or normalisation
c        requested by "flags" is still performed.
c     in_var
f     IN_VAR( * ) = <Xtype> (Given)
*        An optional
c        pointer to a
*        second array with the same size and type as the
c        "in"
f        IN
*        array. If given, this should contain a set of non-negative values
*        which represent estimates of the statistical variance associated
*        with each element of the
c        "in"
f        IN
*        array.
*        If neither the AST__USEVAR nor the AST__VARWGT flag is set, no
*        input variance estimates are required and this
f        array
c        pointer
*        will not be used.
f        A dummy (e.g. one-element) array
c        A NULL pointer
*        may then be supplied.
c     spread
f     SPREAD = INTEGER (Given)
c        This parameter specifies the scheme to be used for dividing
f        This argument specifies the scheme to be used for dividing
*        each input data value up amongst the corresponding output pixels.
*        It may be used to select
*        from a set of pre-defined schemes by supplying one of the
*        values described in the "Pixel Spreading Schemes"
*        section in the description of the
c        astRebin<X> functions.
f        AST_REBIN<X> routines.
*        If a value of zero is supplied, then the default linear spreading
*        scheme is used (equivalent to supplying the value AST__LINEAR).
c        Not used if "in" is NULL.
c     params
f     PARAMS( * ) = DOUBLE PRECISION (Given)
c        An optional pointer to an array of double which should contain
f        An optional array which should contain
*        any additional parameter values required by the pixel
*        spreading scheme. If such parameters are required, this
*        will be noted in the "Pixel Spreading Schemes" section in the
*        description of the
c        astRebin<X> functions.
f        AST_REBIN<X> routines.
*
c        If no additional parameters are required, this array is not
c        used and a NULL pointer may be given. See also flag AST__PARWGT.
f        If no additional parameters are required, this array is not
f        used. A dummy (e.g. one-element) array may then be supplied.
c        Not used if "in" is NULL.
c     flags
f     FLAGS = INTEGER (Given)
c        The bitwise OR of a set of flag values which may be used to
f        The sum of a set of flag values which may be used to
*        provide additional control over the rebinning operation. See
*        the "Control Flags" section below for a description of the
*        options available.  If no flag values are to be set, a value
*        of zero should be given.
c     tol
f     TOL = DOUBLE PRECISION (Given)
*        The maximum tolerable geometrical distortion which may be
*        introduced as a result of approximating non-linear Mappings
*        by a set of piece-wise linear transformations. This should be
*        expressed as a displacement in pixels in the output grid's
*        coordinate system.
*
*        If piece-wise linear approximation is not required, a value
*        of zero may be given. This will ensure that the Mapping is
*        used without any approximation, but may increase execution
*        time.
*
*        If the value is too high, discontinuities between the linear
*        approximations used in adjacent panel will be higher, and may
*        cause the edges of the panel to be visible when viewing the output
*        image at high contrast. If this is a problem, reduce the
*        tolerance value used.
c        Not used if "in" is NULL.
c     maxpix
f     MAXPIX = INTEGER (Given)
*        A value which specifies an initial scale size (in pixels) for
*        the adaptive algorithm which approximates non-linear Mappings
*        with piece-wise linear transformations. Normally, this should
*        be a large value (larger than any dimension of the region of
*        the input grid being used). In this case, a first attempt to
*        approximate the Mapping by a linear transformation will be
*        made over the entire input region.
*
*        If a smaller value is used, the input region will first be
c        divided into sub-regions whose size does not exceed "maxpix"
f        divided into sub-regions whose size does not exceed MAXPIX
*        pixels in any dimension. Only at this point will attempts at
*        approximation commence.
*
*        This value may occasionally be useful in preventing false
*        convergence of the adaptive algorithm in cases where the
*        Mapping appears approximately linear on large scales, but has
*        irregularities (e.g. holes) on smaller scales. A value of,
*        say, 50 to 100 pixels can also be employed as a safeguard in
*        general-purpose software, since the effect on performance is
*        minimal.
*
*        If too small a value is given, it will have the effect of
*        inhibiting linear approximation altogether (equivalent to
c        setting "tol" to zero). Although this may degrade
f        setting TOL to zero). Although this may degrade
*        performance, accurate results will still be obtained.
c        Not used if "in" is NULL.
c     badval
f     BADVAL = <Xtype> (Given)
*        This argument should have the same type as the elements of
c        the "in" array. It specifies the value used to flag missing
f        the IN array. It specifies the value used to flag missing
*        data (bad pixels) in the input and output arrays.
*
c        If the AST__USEBAD flag is set via the "flags" parameter,
f        If the AST__USEBAD flag is set via the FLAGS argument,
c        then this value is used to test for bad pixels in the "in"
c        (and "in_var") array(s).
f        then this value is used to test for bad pixels in the IN
f        (and IN_VAR) array(s).
*
*        In all cases, this value is also used to flag any output
c        elements in the "out" (and "out_var") array(s) for which
f        elements in the OUT (and OUT_VAR) array(s) for which
*        rebined values could not be obtained (see the "Propagation
*        of Missing Data" section below for details of the
*        circumstances under which this may occur).
c     ndim_out
f     NDIM_OUT = INTEGER (Given)
*        The number of dimensions in the output grid. This should be
*        at least one. It need not necessarily be equal to the number
*        of dimensions in the input grid.
c     lbnd_out
f     LBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the output grid along each dimension.
c     ubnd_out
f     UBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the output grid along each dimension.
*
c        Note that "lbnd_out" and "ubnd_out" together define the
f        Note that LBND_OUT and UBND_OUT together define the
*        shape, size and coordinate system of the output grid in the
c        same way as "lbnd_in" and "ubnd_in" define the shape, size
f        same way as LBND_IN and UBND_IN define the shape, size
*        and coordinate system of the input grid.
c     lbnd
f     LBND( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the first pixel in the region
*        of the input grid which is to be included in the rebined output
*        array.
c        Not used if "in" is NULL.
c     ubnd
f     UBND( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the last pixel in the region of
*        the input grid which is to be included in the rebined output
*        array.
*
c        Note that "lbnd" and "ubnd" together define the shape and
f        Note that LBND and UBND together define the shape and
*        position of a (hyper-)rectangular region of the input grid
*        which is to be included in the rebined output array. This region
*        should lie wholly within the extent of the input grid (as
c        defined by the "lbnd_in" and "ubnd_in" arrays). Regions of
f        defined by the LBND_IN and UBND_IN arrays). Regions of
*        the input grid lying outside this region will not be used.
c        Not used if "in" is NULL.
c     out
f     OUT( * ) = <Xtype> (Given and Returned)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        output grid. The rebined data values will be added into the
*        original contents of this array. The numerical type of this array
*        should match that of the
c        "in" array, and the data storage order should be such
f        IN array, and the data storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     out_var
f     OUT_VAR( * ) = <Xtype> (Given and Returned)
*        A
c        pointer to an
*        array with the same type and size as the
c        "out"
f        OUT
*        array. This
c        pointer
f        array
*        will only be used if the AST__USEVAR or AST__GENVAR flag is set
f        via the FLAGS argument,
f        via the "flags" parameter,
*        in which case variance estimates for the rebined data values will
*        be added into the array. If neither the AST__USEVAR flag nor the
*        AST__GENVAR flag is set, no output variance estimates will be
*        calculated and this
c        pointer
f        array
*        will not be used. A
c        NULL pointer
f        dummy (e.g. one-element) array
*        may then be supplied.
c     weights
f     WEIGHTS( * ) = DOUBLE PRECISION (Given and Returned)
c        Pointer to an array of double,
f        An array
*        with one or two elements for each pixel in the output grid,
*        depending on whether or not the AST__GENVAR flag has been supplied
*        via the
c        "flags" parameter.
f        FLAGS parameter.
*        If AST__GENVAR has not been specified then the array should have
*        one element for each output pixel, and it will be used to
*        accumulate the weight associated with each output pixel.
*        If AST__GENVAR has been specified then the array should have
*        two elements for each output pixel. The first half of the array
*        is again used to accumulate the weight associated with each output
*        pixel, and the second half is used to accumulate the square of
*        the weights. In each half, the data storage order should be such that
*        the index of the first grid dimension varies most rapidly and that of
*        the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     nused
f     NUSED = INTEGER*8 (Given and Returned)
c        A pointer to an int64_t containing the
f        The
*        number of input data values that have been added into the output
*        array so far. The supplied value is incremented on exit by the
*        number of input values used. The value is initially set to zero
*        if the AST__REBININIT flag is set in
c        "flags".
f        FLAGS.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Data Type Codes:
*     To select the appropriate rebinning function, you should
c     replace <X> in the generic function name astRebinSeq<X> with a
f     replace <X> in the generic function name AST_REBINSEQ<X> with a
*     1- or 2-character data type code, so as to match the numerical
*     type <Xtype> of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - B: byte (signed char)
c     - UB: unsigned byte (unsigned char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - B: BYTE (treated as signed)
f     - UB: BYTE (treated as unsigned)
*
c     For example, astRebinSeqD would be used to process "double"
c     data, while astRebinSeqI would be used to process "int"
c     data, etc.
f     For example, AST_REBIND would be used to process DOUBLE
f     PRECISION data, while AST_REBINI would be used to process
f     integer data (stored in an INTEGER array), etc.
*
*     Note that, unlike
c     astResample<X>, the astRebinSeq<X>
f     AST_RESAMPLE<X>, the AST_REBINSEQ<X>
*     set of functions does not yet support unsigned integer data types
*     or integers of different sizes.

*  Control Flags:
c     The following flags are defined in the "ast.h" header file and
f     The following flags are defined in the AST_PAR include file and
*     may be used to provide additional control over the rebinning
*     process. Having selected a set of flags, you should supply the
c     bitwise OR of their values via the "flags" parameter:
f     sum of their values via the FLAGS argument:
*
*     - AST__REBININIT: Used to mark the first call in a sequence. It indicates
*     that the supplied
c     "out", "out_var" and "weights"
f     OUT, OUT_VAR and WEIGHTS
*     arrays should be filled with zeros (thus over-writing any supplied
*     values) before adding the rebinned input data into them. This flag
*     should be used when rebinning the first input array in a sequence.
*     - AST__REBINEND: Used to mark the last call in a sequence. It causes
*     each value in the
c     "out" and "out_var"
f     OUT and OUT_VAR
*     arrays to be divided by a normalisation factor before being
*     returned. The normalisation factor for each output data value is just
*     the corresponding value from the weights array. The normalisation
*     factor for each output variance value is the square of the data value
*     normalisation factor (see also AST__CONSERVEFLUX). It also causes
*     output data values to be set bad if the corresponding weight is less
*     than the value supplied for
c     parameter "wlim".
f     argument WLIM.
*     It also causes any temporary values stored in the output variance array
*     (see flag AST__GENVAR below) to be converted into usable variance values.
*     Note, this flag is ignored if the AST__NONORM flag is set.
*     - AST__USEBAD: Indicates that there may be bad pixels in the
*     input array(s) which must be recognised by comparing with the
c     value given for "badval" and propagated to the output array(s).
f     value given for BADVAL and propagated to the output array(s).
*     If this flag is not set, all input values are treated literally
c     and the "badval" value is only used for flagging output array
f     and the BADVAL value is only used for flagging output array
*     values.
*     - AST__USEVAR: Indicates that output variance estimates should be
*     created by rebinning the supplied input variance estimates. An
*     error will be reported if both this flag and the AST__GENVAR flag
*     are supplied.
*     - AST__GENVAR: Indicates that output variance estimates should be
*     created based on the spread of input data values contributing to each
*     output pixel. An error will be reported if both this flag and the
*     AST__USEVAR flag are supplied. If the AST__GENVAR flag is specified,
*     the supplied output variance array is first used as a work array to
*     accumulate the temporary values needed to generate the output
*     variances. When the sequence ends (as indicated by the
*     AST__REBINEND flag), the contents of the output variance array are
*     converted into the required variance estimates. If the generation of
*     such output variances is required, this flag should be used on every
*     invocation of this
c     function
f     routine
*     within a sequence, and any supplied input variances will have no effect
*     on the output variances (although input variances will still be used
*     to weight the input data if the AST__VARWGT flag is also supplied).
*     The statistical meaning of these output varianes is determined by
*     the presence or absence of the AST__DISVAR flag (see below).
*     - AST__DISVAR: This flag is ignored unless the AST__GENVAR flag
*     has also been specified. It determines the statistical meaning of
*     the generated output variances. If AST__DISVAR is not specified,
*     generated variances represent variances on the output mean  values. If
*     AST__DISVAR is specified, the generated variances represent the variance
*     of the distribution from which the input values were taken. Each output
*     variance created with AST__DISVAR will be larger than that created
*     without AST__DISVAR by a factor equal to the number of input samples
*     that contribute to the output sample.
*     - AST__VARWGT: Indicates that the input data should be weighted by
*     the reciprocal of the input variances. Otherwise, all input data are
*     given equal weight. If this flag is specified, the calculation of the
*     output variances (if any) is modified to take account of the
*     varying weights assigned to the input data values. See also AST__PARWGT.
*     - AST__PARWGT: Indicates that a constant weight should be used when
*     pasting each pixel of the supplied input array into the returned
*     arrays. This extra weight value should be inserted at the start of the
c     "params"
f     'PARAMS
*     array (which should consequently be one element longer than specified in
*     the "Pixel Spreading Schemes" section in the description of the
c     astRebin<X> functions).
f     AST_REBIN<X> routines).
*     If the AST__VARWGT flag is also specified, the total weight for
*     each pixel is the product of the reciprocal of the pixel variance
*     and the value supplied in the last element of the
c     "params" array.
f     'PARAMS array.
*     - AST__NONORM: If the simple unnormalised sum of all input data falling
*     in each output pixel is required, then this flag should be set on
*     each call in the sequence and the AST__REBINEND should not be used
*     on the last call. In this case
c     NULL pointers can be supplied for "weights" and "nused".
f     WEIGHTS and NUSED are ignored.
*     This flag cannot be used with the AST__CONSERVEFLUX, AST__GENVAR,
*     AST__PARWGT or AST__VARWGT flag.
*     - AST__CONSERVEFLUX: Indicates that the normalized output pixel values
*     generated by the AST__REBINEND flag should be scaled in such a way as
*     to preserve the total data value in a feature on the sky. Without this
*     flag, each normalised output pixel value represents a weighted mean
*     of the input data values around the corresponding input position.
f     (i.e. AST_REBINSEQ<F> behaves similarly to AST_RESAMPLE<X>). This
f     (i.e. AST_REBINSEQ<F> behaves similarly to AST_RESAMPLE<X>). This
*     is appropriate if the input data represents the spatial density of
*     some quantity (e.g. surface brightness in Janskys per square
*     arc-second) because the output pixel values will have the same
*     normalisation and units as the input pixel values. However, if the
*     input data values represent flux (or some other physical quantity)
*     per pixel, then the AST__CONSERVEFLUX flag could be of use. It causes
*     each output pixel value to be scaled by the ratio of the output pixel
*     size to the input pixel size.
*
*     This flag can only be used if the Mapping is successfully approximated
*     by one or more linear transformations. Thus an error will be reported
*     if it used when the
c     "tol" parameter
f     TOL argument
*     is set to zero (which stops the use of linear approximations), or
*     if the Mapping is too non-linear to be approximated by a piece-wise
*     linear transformation. The ratio of output to input pixel size is
*     evaluated once for each panel of the piece-wise linear approximation to
*     the Mapping, and is assumed to be constant for all output pixels in the
*     panel. The scaling factors for adjacent panels will in general
*     differ slightly, and so the joints between panels may be visible when
*     viewing the output image at high contrast. If this is a problem,
*     reduce the value of the
c     "tol" parameter
f     TOL argument
*     until the difference between adjacent panels is sufficiently small
*     to be insignificant.
*
*     This flag should normally be supplied on each invocation of
c     astRebinSeq<X>
f     AST_REBINSEQ<X>
*     within a given sequence.
*
*     Note, this flag cannot be used in conjunction with the AST__NOSCALE
*     flag (an error will be reported if both flags are specified).

*  Propagation of Missing Data:
*     Instances of missing data (bad pixels) in the output grid are
c     identified by occurrences of the "badval" value in the "out"
f     identified by occurrences of the BADVAL value in the OUT
*     array. These are only produced if the AST__REBINEND flag is
*     specified and a pixel has zero weight.
*
*     An input pixel is considered bad (and is consequently ignored) if
*     its
c     data value is equal to "badval" and the AST__USEBAD flag is
c     set via the "flags" parameter.
f     data value is equal to BADVAL and the AST__USEBAD flag is
f     set via the FLAGS argument.
*
*     In addition, associated output variance estimates (if
c     calculated) may be declared bad and flagged with the "badval"
c     value in the "out_var" array for similar reasons.
f     calculated) may be declared bad and flagged with the BADVAL
f     value in the OUT_VAR array for similar reasons.

*--
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_REBINSEQ(X,Xtype,IntType) \
static void RebinSeq##X( AstMapping *this, double wlim, int ndim_in, \
                     const int lbnd_in[], const int ubnd_in[], \
                     const Xtype in[], const Xtype in_var[], \
                     int spread, const double params[], int flags, \
                     double tol, int maxpix, Xtype badval, \
                     int ndim_out, const int lbnd_out[], \
                     const int ubnd_out[], const int lbnd[], \
                     const int ubnd[], Xtype out[], Xtype out_var[], \
                     double weights[], int64_t *nused, int *status ) { \
\
/* Local Variables: */ \
   AstMapping *simple;           /* Pointer to simplified Mapping */ \
   Xtype *d;                     /* Pointer to next output data value */ \
   Xtype *v;                     /* Pointer to next output variance value */ \
   astDECLARE_GLOBALS            /* Thread-specific data */ \
   double *w;                    /* Pointer to next weight value */ \
   double mwpip;                 /* Mean weight per input pixel */ \
   double neff;                  /* Effective number of contributing input pixels */ \
   double sw;                    /* Sum of weights at output pixel */ \
   double wgt;                   /* Output pixel weight */ \
   int i;                        /* Loop counter for output pixels */ \
   int idim;                     /* Loop counter for coordinate dimensions */ \
   int ipix_out;                 /* Index into output array */ \
   int nin;                      /* Number of Mapping input coordinates */ \
   int nout;                     /* Number of Mapping output coordinates */ \
   int npix;                     /* Number of pixels in input region */ \
   int npix_out;                 /* Number of pixels in output array */ \
   int64_t mpix;                 /* Number of pixels for testing */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Get a pointer to a structure holding thread-specific global data values */ \
   astGET_GLOBALS(this); \
\
/* Loop to determine how many pixels the output array contains. */ \
   npix_out = 1; \
   for ( idim = 0; idim < ndim_out; idim++ ) { \
      npix_out *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
   } \
\
/* Obtain values for the Nin and Nout attributes of the Mapping. */ \
   nin = astGetNin( this ); \
   nout = astGetNout( this ); \
\
/* If OK, also check that the number of output grid dimensions matches \
   the number required by the Mapping and is at least 1. Report an \
   error if necessary. */ \
   if ( astOK && ( ( ndim_out != nout ) || ( ndim_out < 1 ) ) ) { \
      astError( AST__NGDIN, "astRebinSeq"#X"(%s): Bad number of output grid " \
                "dimensions (%d).", status, astGetClass( this ), ndim_out ); \
      if ( ndim_out != nout ) { \
         astError( AST__NGDIN, "The %s given generates %s%d coordinate " \
                   "value%s for each output position.", status, astGetClass( this ), \
                   ( nout < ndim_out ) ? "only " : "", nout, \
                   ( nout == 1 ) ? "" : "s" ); \
      } \
   } \
\
/* If no input data was supplied, jump to the normalisation section. */ \
   simple = NULL; \
   if( in ) { \
\
/* If OK, check that the number of input grid dimensions matches the \
   number required by the Mapping and is at least 1. Report an error \
   if necessary. */ \
      if ( astOK && ( ( ndim_in != nin ) || ( ndim_in < 1 ) ) ) { \
         astError( AST__NGDIN, "astRebinSeq"#X"(%s): Bad number of input grid " \
                   "dimensions (%d).", status, astGetClass( this ), ndim_in ); \
         if ( ndim_in != nin ) { \
            astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \
                      "to specify an input position.", status, \
                      astGetClass( this ), nin, ( nin == 1 ) ? "" : "s" ); \
         } \
      } \
\
/* Check that the lower and upper bounds of the input grid are \
   consistent. Report an error if any pair is not. */ \
      mpix = 1; \
      if ( astOK ) { \
         for ( idim = 0; idim < ndim_in; idim++ ) { \
            if ( lbnd_in[ idim ] > ubnd_in[ idim ] ) { \
              astError( AST__GBDIN, "astRebinSeq"#X"(%s): Lower bound of " \
                        "input grid (%d) exceeds corresponding upper bound " \
                        "(%d).", status, astGetClass( this ), \
                        lbnd_in[ idim ], ubnd_in[ idim ] ); \
              astError( AST__GBDIN, "Error in input dimension %d.", status, \
                        idim + 1 ); \
              break; \
            } else { \
               mpix *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
            } \
         } \
      } \
\
/* Report an error if there are too many pixels in the input. */ \
      if ( astOK && (int) mpix != mpix ) { \
         astError( AST__EXSPIX, "astRebinSeq"#X"(%s): Supplied input array " \
                   "contains too many pixels (%g): must be fewer than %d.", \
                   status, astGetClass( this ), (double) mpix, INT_MAX ); \
      } \
\
/* Ensure any supplied "in_var" pointer is ignored if no input variances are \
   needed. */ \
      if( !( flags & AST__USEVAR ) && !( flags & AST__VARWGT ) ) { \
         in_var = NULL; \
      } \
\
/* Ensure any supplied "out_var" pointer is ignored if no output variances \
   being created. */ \
      if( !( flags & AST__USEVAR ) && !( flags & AST__GENVAR ) ) { \
         out_var = NULL; \
      } \
\
/* Check that the positional accuracy tolerance supplied is valid and \
   report an error if necessary. */ \
      if ( astOK && ( tol < 0.0 ) ) { \
         astError( AST__PATIN, "astRebinSeq"#X"(%s): Invalid positional " \
                   "accuracy tolerance (%.*g pixel).", status, \
                   astGetClass( this ), AST__DBL_DIG, tol ); \
         astError( AST__PATIN, "This value should not be less than zero." , status); \
      } \
\
/* Check that the initial scale size in pixels supplied is valid and \
   report an error if necessary. */ \
      if ( astOK && ( maxpix < 0 ) ) { \
         astError( AST__SSPIN, "astRebinSeq"#X"(%s): Invalid initial scale " \
                   "size in pixels (%d).", status, astGetClass( this ), maxpix ); \
         astError( AST__SSPIN, "This value should not be less than zero." , status); \
      } \
\
/* Check that the lower and upper bounds of the output grid are \
   consistent. Report an error if any pair is not. */ \
      mpix = 1; \
      if ( astOK ) { \
         for ( idim = 0; idim < ndim_out; idim++ ) { \
            if ( lbnd_out[ idim ] > ubnd_out[ idim ] ) { \
               astError( AST__GBDIN, "astRebinSeq"#X"(%s): Lower bound of " \
                         "output grid (%d) exceeds corresponding upper bound " \
                         "(%d).", status, astGetClass( this ), \
                         lbnd_out[ idim ], ubnd_out[ idim ] ); \
               astError( AST__GBDIN, "Error in output dimension %d.", status, \
                         idim + 1 ); \
               break; \
            } else { \
               mpix *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
            } \
         } \
      } \
\
/* Report an error if there are too many pixels in the output. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astRebinSeq"#X"(%s): Supplied output array " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* Similarly check the bounds of the input region. */ \
      mpix = 1; \
      if ( astOK ) { \
         for ( idim = 0; idim < ndim_in; idim++ ) { \
            if ( lbnd[ idim ] > ubnd[ idim ] ) { \
               astError( AST__GBDIN, "astRebinSeq"#X"(%s): Lower bound of " \
                         "input region (%d) exceeds corresponding upper " \
                         "bound (%d).", status, astGetClass( this ), \
                         lbnd[ idim ], ubnd[ idim ] ); \
\
/* Also check that the input region lies wholly within the input \
   grid. */ \
            } else if ( lbnd[ idim ] < lbnd_in[ idim ] ) { \
               astError( AST__GBDIN, "astRebinSeq"#X"(%s): Lower bound of " \
                         "input region (%d) is less than corresponding " \
                         "bound of input grid (%d).", status, astGetClass( this ), \
                         lbnd[ idim ], lbnd_in[ idim ] ); \
            } else if ( ubnd[ idim ] > ubnd_in[ idim ] ) { \
               astError( AST__GBDIN, "astRebinSeq"#X"(%s): Upper bound of " \
                         "input region (%d) exceeds corresponding " \
                         "bound of input grid (%d).", status, astGetClass( this ), \
                         ubnd[ idim ], ubnd_in[ idim ] ); \
            } else { \
               mpix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
            } \
\
/* Say which dimension produced the error. */ \
            if ( !astOK ) { \
               astError( AST__GBDIN, "Error in output dimension %d.", status, \
                         idim + 1 ); \
               break; \
            } \
         } \
      } \
\
/* Report an error if there are too many pixels in the input region. */ \
      if ( astOK && (int) mpix != mpix ) { \
         astError( AST__EXSPIX, "astRebinSeq"#X"(%s): Supplied input region " \
                   "contains too many pixels (%g): must be fewer than %d.", \
                   status, astGetClass( this ), (double) mpix, INT_MAX ); \
      } \
\
/* Check that only one of AST__USEVAR and ASR__GENVAR has been supplied. */ \
      if( ( flags & AST__USEVAR ) && ( flags & AST__GENVAR ) ) { \
         if( astOK ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): Incompatible flags " \
                      "AST__GENVAR and AST__USEVAR have been specified " \
                      "together (programming error).", status, astGetClass( this ) ); \
         } \
      } \
\
/* If AST__USEVAR or AST_VARWGT has been specified, check we have an \
   input variance array. */ \
      if( !in_var && astOK ) { \
         if( ( flags & AST__USEVAR ) ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): The AST__USEVAR flag " \
                      "was specified but no input variance array was supplied " \
                      "(programming error).", status, astGetClass( this )  ); \
         } else if( ( flags & AST__VARWGT ) ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): The AST__VARWGT flag " \
                      "was specified but no input variance array was supplied " \
                      "(programming error).", status, astGetClass( this )  ); \
         } \
      } \
\
/* If AST__USEVAR or AST_GENVAR has been specified, check we have an \
   output variance array. */ \
      if( !out_var && astOK ) { \
         if( ( flags & AST__USEVAR ) ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): The AST__USEVAR flag " \
                      "was specified but no output variance array was supplied " \
                      "(programming error).", status, astGetClass( this )  ); \
         } else if( ( flags & AST__GENVAR ) ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): The AST__GENVAR flag " \
                      "was specified but no output variance array was supplied " \
                      "(programming error).", status, astGetClass( this )  ); \
         } \
      } \
\
/* If the AST__NONORM flag has been supplied, check no incompatible flags have \
   been specified. */ \
      if( flags & AST__NONORM ) { \
         if( ( flags & AST__GENVAR ) && astOK ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): Incompatible flags " \
                      "AST__GENVAR and AST__NONORM have been specified " \
                      "together (programming error).", status, astGetClass( this ) ); \
         } else if( ( flags & AST__VARWGT ) && astOK ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): Incompatible flags " \
                      "AST__VARWGT and AST__NONORM have been specified " \
                      "together (programming error).", status, astGetClass( this ) ); \
         } else if( ( flags & AST__PARWGT ) && astOK ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): Incompatible flags " \
                      "AST__PARWGT and AST__NONORM have been specified " \
                      "together (programming error).", status, astGetClass( this ) ); \
         } else if( ( flags & AST__CONSERVEFLUX ) && astOK ) { \
            astError( AST__BDPAR, "astRebinSeq"#X"(%s): Incompatible flags " \
                      "AST__CONSERVEFLUX and AST__NONORM have been specified " \
                      "together (programming error).", status, astGetClass( this ) ); \
         } \
\
/* If the AST__NONORM flag has not been supplied, check that a weights array \
   and nused pointer have been supplied. */ \
      } else if( !weights ){ \
         astError( AST__BDPAR, "astRebinSeq"#X"(%s): No weights array " \
                   "supplied (programming error).", status, \
                   astGetClass( this )  ); \
      } else if( !nused ){ \
         astError( AST__BDPAR, "astRebinSeq"#X"(%s): No 'nused' pointer " \
                   "supplied (programming error).", status, \
                   astGetClass( this )  ); \
      } \
\
/* If OK, loop to determine how many input pixels are to be binned. */ \
      npix = 1; \
      unsimplified_mapping = this; \
      if ( astOK ) { \
         for ( idim = 0; idim < ndim_in; idim++ ) { \
            npix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
         } \
\
/* If there are sufficient pixels to make it worthwhile, simplify the \
   Mapping supplied to improve performance. Otherwise, just clone the \
   Mapping pointer. Note we have already saved a pointer to the original \
   Mapping so that lower-level functions can use it if they need to report \
   an error. */ \
         if ( npix > 1024 ) { \
            simple = astSimplify( this ); \
         } else { \
            simple = astClone( this ); \
         } \
      } \
\
/* Report an error if the forward transformation of this simplified \
   Mapping is not defined. */ \
      if ( !astGetTranForward( simple ) && astOK ) { \
         astError( AST__TRNND, "astRebinSeq"#X"(%s): An forward coordinate " \
                   "transformation is not defined by the %s supplied.", status, \
                   astGetClass( unsimplified_mapping ), \
                   astGetClass( unsimplified_mapping ) ); \
      } \
\
/* If required, initialise the output arrays to hold zeros. */ \
      if( flags & AST__REBININIT ) { \
         d = out; \
         if( out_var ) { \
            v = out_var; \
            for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++, v++ ) { \
               *d = 0; \
               *v = 0; \
            } \
         } else { \
            for( ipix_out = 0; ipix_out < npix_out; ipix_out++, d++ ) { \
               *d = 0; \
            } \
         } \
         if( weights ) { \
            w = weights; \
            for( ipix_out = 0; ipix_out < npix_out; ipix_out++, w++ ) { \
               *w = 0; \
            } \
            if( flags & AST__GENVAR ) { \
               for( ipix_out = 0; ipix_out < npix_out; ipix_out++, w++ ) *w = 0; \
            } \
         } \
         if( nused ) *nused = 0; \
      } \
\
/* Paste the input values into the supplied output arrays. */ \
      if( RebinAdaptively( simple, ndim_in, lbnd_in, ubnd_in, \
                          (const void *) in, (const void *) in_var, \
                          TYPE_##X, spread, params, flags, \
                          tol, maxpix, (const void *) &badval, \
                          ndim_out, lbnd_out, ubnd_out, lbnd, \
                          ubnd, npix_out, (void *) out, \
                          (void *) out_var, weights, nused, status ) ) { \
         astError( AST__CNFLX, "astRebinSeq"#X"(%s): Flux conservation was " \
                   "requested but could not be performed because the " \
                   "forward transformation of the supplied Mapping " \
                   "is too non-linear.", status, astGetClass( this ) ); \
      } \
\
/* Annul the pointer to the simplified/cloned Mapping. */ \
      simple = astAnnul( simple ); \
\
   } \
\
/* If required, finalise the sequence. */ \
   if( ( flags & AST__REBINEND ) && !( flags & AST__NONORM ) && \
       weights && nused ) { \
\
/* Ensure "wlim" is not zero. */ \
      if( wlim < 1.0E-10 ) wlim = 1.0E-10; \
\
/* If it will be needed, find the average weight per input pixel. */ \
      if( !( flags & AST__GENVAR ) && *nused > 0 ) { \
         sw = 0.0; \
         for( i = 0; i < npix_out; i++ ) { \
            sw += weights[ i ]; \
         } \
         mwpip = sw/( *nused ); \
       } else { \
         mwpip = AST__BAD; \
       } \
\
/* Normalise each output pixel. */ \
      for( i = 0; i < npix_out; i++ ) { \
\
/* Find the effective number of input samples that contribute to the \
   output sample. To do this properly requires the sum of the squared \
   weights in each output pixel, but this is only available if AST__GENVAR \
   flag is in use. In order to avoid changing the API for astRebinSeq, we \
   honour this long-standing restriction, and use an approximation if \
   AST__GENVAR is not in use. */ \
         wgt = weights[ i ]; \
         if( flags & AST__GENVAR ) { \
            if( wgt > 0.0 && weights[ i + npix_out ] > 0 ) { \
               neff = (wgt*wgt)/weights[ i + npix_out ]; \
            } else { \
               neff = 0.0; \
            } \
\
/* If the sum of the squared weights is not available, compare the weight \
   for this output pixel with the mean weight per input pixel. */ \
         } else if( mwpip != AST__BAD ){ \
            neff = wgt/mwpip; \
\
         } else if( astOK ) { \
            astError( AST__BADIN, "astRebinSeq"#X"(%s): The overlap " \
                      "between the %d-d input array and the %d-d output " \
                      "array contains no pixels with good data %svalues.", \
                      status, astGetClass( this ), nin, nout,  \
                      in_var ? "and variance " : "" ); \
         } \
\
/* Assign bad values to unused output pixels. */ \
         if( neff < wlim || neff == 0.0 ) { \
            out[ i ] = badval;  \
            if( out_var ) out_var[ i ] = badval; \
\
/* Otherwise, normalise the returned data value. No need to check "wgt" \
   since it must be larger than zero since neff is larger than wlim. */ \
         } else { \
            out[ i ] /= wgt; \
\
/* Normalise the returned variance: propagated from input variances... */ \
            if( out_var ) { \
               if( flags & AST__USEVAR ) { \
                  out_var[ i ] /= wgt*wgt; \
\
/* Normalise the returned variance: from spread of input values... */ \
               } else if( flags & AST__GENVAR && neff > 1.0 ) {  \
                  out_var[ i ] /= wgt; \
                  out_var[ i ] -= out[ i ]*out[ i ]; \
                  if( out_var[ i ] < 0.0 ) out_var[ i ] = 0.0; \
\
/* If output variances are estimates of the variance of the distribution \
   from which the input values were sampled... */ \
                  if( flags & AST__DISVAR ) { \
                     out_var[ i ] *= neff/( neff - 1.0 ); \
\
/* If output variances are estimates of the error on the mean data value... */ \
                  } else { \
                     out_var[ i ] *= 1.0/( neff - 1.0 ); \
                  } \
\
               } else { \
                  out_var[ i ] = badval; \
               } \
            } \
         } \
      } \
   } \
\
}

/* Expand the above macro to generate a function for each required
   data type. */
#if HAVE_LONG_DOUBLE  /* Not normally implemented */
MAKE_REBINSEQ(LD,long double,0)
#endif
MAKE_REBINSEQ(D,double,0)
MAKE_REBINSEQ(F,float,0)
MAKE_REBINSEQ(I,int,1)
MAKE_REBINSEQ(B,signed char,1)
MAKE_REBINSEQ(UB,unsigned char,1)

/* Undefine the macro. */
#undef MAKE_REBINSEQ

static int RebinWithBlocking( AstMapping *this, const double *linear_fit,
                               int ndim_in, const int *lbnd_in,
                               const int *ubnd_in, const void *in,
                               const void *in_var, DataType type,
                               int spread, const double *params, int flags,
                               const void *badval_ptr, int ndim_out,
                               const int *lbnd_out, const int *ubnd_out,
                               const int *lbnd, const int *ubnd, int npix_out,
                               void *out, void *out_var, double *work,
                               int64_t *nused, int *status ) {
/*
*  Name:
*     RebinWithBlocking

*  Purpose:
*     Rebin a section of a data grid in a memory-efficient way.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int RebinWithBlocking( AstMapping *this, const double *linear_fit,
*                             int ndim_in, const int *lbnd_in,
*                             const int *ubnd_in, const void *in,
*                             const void *in_var, DataType type,
*                             int spread, const double *params, int flags,
*                             const void *badval_ptr, int ndim_out,
*                             const int *lbnd_out, const int *ubnd_out,
*                             const int *lbnd, const int *ubnd, int npix_out,
*                             void *out, void *out_var, double *work,
*                             int64_t *nused, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function rebins a specified section of a rectangular grid of
*     data (with any number of dimensions) into another rectangular grid
*     (with a possibly different number of dimensions). The coordinate
*     transformation used to convert input pixel coordinates into positions
*     in the output grid is given by the forward transformation of the
*     Mapping which is supplied.  Any pixel spreading scheme may be specified
*     for distributing the flux of an input pixel amongst the output
*     pixels.
*
*     This function is very similar to RebinSection, except that in
*     order to limit memory usage and to ensure locality of reference,
*     it divides the input grid up into "blocks" which have a limited
*     extent along each input dimension. Each block, which will not
*     contain more than a pre-determined maximum number of pixels, is
*     then passed to RebinSection for resampling.

*  Parameters:
*     this
*        Pointer to a Mapping, whose forward transformation may be
*        used to transform the coordinates of pixels in the input
*        grid into associated positions in the output grid.
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's forward coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        forward transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be rebinned (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the rebinned data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     spread
*        A value selected from a set of pre-defined macros to identify
*        which pixel spread function should be used.
*     params
*        Pointer to an optional array of parameters that may be passed
*        to the pixel spread algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     flags
*        The bitwise OR of a set of flag values which provide additional
*        control over the resampling operation.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which rebinned values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the first pixel in the
*        section of the input data grid which is to be rebinned.
*     ubnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the last pixel in the
*        section of the input data grid which is to be rebinned.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the input grid which is to be rebinned. This section
*        should lie wholly within the extent of the input grid (as defined
*        by the "lbnd_out" and "ubnd_out" arrays). Regions of the input
*        grid lying outside this section will be ignored.
*     npix_out
*        The number of pixels in the output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        An optional pointer to a double array with the same size as
*        the "out" array. The contents of this array (if supplied) are
*        incremented by the accumulated weights assigned to each output pixel.
*        If no accumulated weights are required, a NULL pointer should be
*        given.
*     nused
*        An optional pointer to a int64_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.

*  Returned Value:
*     A non-zero value is returned if "flags" included AST__CONSERVEFLUX (i.e.
*     flux conservation was requested), but the supplied linear fit to the
*     forward transformation of the Mapping had zero determinant (no error
*     is reported if this happens). Zero is returned otherwise.

*/

/* Local Constants: */
   const int mxpix = 2 * 1024;   /* Maximum number of pixels in a block (this
                                    relatively small number seems to give best
                                    performance) */

/* Local Variables: */
   double factor;                /* Flux conservation factor */
   int *dim_block;               /* Pointer to array of block dimensions */
   int *lbnd_block;              /* Pointer to block lower bound array */
   int *ubnd_block;              /* Pointer to block upper bound array */
   int dim;                      /* Dimension size */
   int done;                     /* All blocks rebinned? */
   int hilim;                    /* Upper limit on maximum block dimension */
   int idim;                     /* Loop counter for dimensions */
   int lolim;                    /* Lower limit on maximum block dimension */
   int mxdim_block;              /* Maximum block dimension */
   int npix;                     /* Number of pixels in block */
   int result;                   /* Returned value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Allocate workspace. */
   lbnd_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   ubnd_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   dim_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   if ( astOK ) {

/* Find the optimum block size. */
/* ---------------------------- */
/* We first need to find the maximum extent which a block of input
   pixels may have in each dimension. We determine this by taking the
   input grid extent in each dimension and then limiting the maximum
   dimension size until the resulting number of pixels is sufficiently
   small. This approach allows the block shape to approximate (or
   match) the input grid shape when appropriate. */

/* First loop to calculate the total number of input pixels and the
   maximum input dimension size. */
      npix = 1;
      mxdim_block = 0;
      for ( idim = 0; idim < ndim_in; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         npix *= dim;
         if ( mxdim_block < dim ) mxdim_block = dim;
      }

/* If the number of input pixels is too large for a single block, we
   perform iterations to determine the optimum upper limit on a
   block's dimension size. Initialise the limits on this result. */
      if ( npix > mxpix ) {
         lolim = 1;
         hilim = mxdim_block;

/* Loop to perform a binary chop, searching for the best result until
   the lower and upper limits on the result converge to adjacent
   values. */
         while ( ( hilim - lolim ) > 1 ) {

/* Form a new estimate from the mid-point of the previous limits. */
            mxdim_block = ( hilim + lolim ) / 2;

/* See how many pixels a block contains if its maximum dimension is
   limited to this new value. */
            for ( npix = 1, idim = 0; idim < ndim_in; idim++ ) {
               dim = ubnd[ idim ] - lbnd[ idim ] + 1;
               npix *= ( dim < mxdim_block ) ? dim : mxdim_block;
            }

/* Update the appropriate limit, according to whether the number of
   pixels is too large or too small. */
            *( ( npix <= mxpix ) ? &lolim : &hilim ) = mxdim_block;
         }

/* When iterations have converged, obtain the maximum limit on the
   dimension size of a block which results in no more than the maximum
   allowed number of pixels per block. However, ensure that all block
   dimensions are at least 2. */
            mxdim_block = lolim;
      }
      if ( mxdim_block < 2 ) mxdim_block = 2;

/* Calculate the block dimensions by applying this limit to the output
   grid dimensions. */
      for ( idim = 0; idim < ndim_in; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         dim_block[ idim ] = ( dim < mxdim_block ) ? dim : mxdim_block;

/* Also initialise the lower and upper bounds of the first block of
   output grid pixels to be rebinned, ensuring that this does not
   extend outside the grid itself. */
         lbnd_block[ idim ] = lbnd[ idim ];
         ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                    ubnd[ idim ], status );
      }

/* Determine the flux conservation constant if needed. */
/* --------------------------------------------------- */
      factor = 1.0;
      if( flags & AST__CONSERVEFLUX ) {
         if( linear_fit ) {
            factor = MatrixDet( ndim_out, ndim_in, linear_fit + ndim_out,
                                status );
            if( factor != 0.0 ) {
               factor = 1.0/factor;
            } else {
               result = 1;
            }
         } else {
            result = 1;
         }
      }

/* Rebin each block of input pixels. */
/* --------------------------------- */
/* Loop to generate the extent of each block of input pixels and to
   rebin them. */
      done = result;
      while ( !done && astOK ) {

/* Rebin the current block, accumulating the sum of bad pixels produced. */
         RebinSection( this, linear_fit, ndim_in, lbnd_in, ubnd_in, in,
                       in_var, factor, type, spread, params, flags, badval_ptr,
                       ndim_out, lbnd_out, ubnd_out, lbnd_block, ubnd_block,
                       npix_out, out, out_var, work, nused, status );

/* Update the block extent to identify the next block of input pixels. */
         idim = 0;
         do {

/* We find the least significant dimension where the upper bound of
   the block has not yet reached the upper bound of the region of the
   input grid which we are rebinning. The block's position is then
   incremented by one block extent along this dimension, checking that
   the resulting extent does not go outside the region being rebinned. */
            if ( ubnd_block[ idim ] < ubnd[ idim ] ) {
               lbnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ], ubnd[ idim ], status );
               ubnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );
               break;

/* If any less significant dimensions are found where the upper bound
   of the block has reached its maximum value, we reset the block to
   its lowest position. */
            } else {
               lbnd_block[ idim ] = lbnd[ idim ];
               ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );

/* All the blocks have been processed once the position along the most
   significant dimension has been reset. */
               done = ( ++idim == ndim_in );
            }
         } while ( !done );
      }
   }

/* Free the workspace. */
   lbnd_block = astFree( lbnd_block );
   ubnd_block = astFree( ubnd_block );
   dim_block = astFree( dim_block );

/* Return a flag indicating if there was an error conserving flux. */
   return result;
}

static AstMapping *RemoveRegions( AstMapping *this, int *status ) {
/*
*++
*  Name:
c     astRemoveRegions
f     AST_REMOVEREGIONS

*  Purpose:
*     Remove any Regions from a Mapping.

*  Type:
*     Public function.

*  Synopsis:
c     #include "mapping.h"
c     AstMapping *astRemoveRegions( AstMapping *this )
f     RESULT = AST_REMOVEREGIONS( THIS, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function searches the suppliedMapping (which may be a
*     compound Mapping such as a CmpMap) for any component Mappings
*     that are instances of the AST Region class. It then creates
*     a new Mapping from which all Regions have been removed. If
*     a Region cannot simply be removed (for instance, if it is a
*     component of a parallel CmpMap), then it is replaced with an
*     equivalent UnitMap in the returned Mapping.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the original Mapping.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astRemoveRegions()
f     AST_REMOVEREGIONS = INTEGER
*        A new pointer to the (possibly modified) Mapping.

*  Applicability:
*     CmpFrame
*        If the supplied Mapping is a CmpFrame, any component Frames
*        that are instances of the Region class are replaced by the
*        equivalent Frame.
*     FrameSet
*        If the supplied Mapping is a FrameSet, the returned Mapping
*        will be a copy of the supplied FrameSet in which Regions
*        have been removed from all the inter-Frame Mappings, and any
*        Frames which are instances of the Region class are replaced by
*        the equivalent Frame.
*     Mapping
*        This function applies to all Mappings.
*     Region
*        If the supplied Mapping is a Region, the returned Mapping will
*        be the equivalent Frame.

*  Notes:
*     - This function can safely be applied even to Mappings
*     which contain no Regions. If no Regions are found, it
c     behaves exactly like astClone and returns a pointer to the
f     behaves exactly like AST_CLONE and returns a pointer to the
*     original Mapping.
*     - The Mapping returned by this function may not be independent
*     of the original (even if some Regions were removed), and
*     modifying it may therefore result in indirect modification of
*     the original. If a completely independent result is required, a
c     copy should be made using astCopy.
f     copy should be made using AST_COPY.
*     - A null Object pointer (AST__NULL) will be returned if this
c     function is invoked with the AST error status set, or if it
f     function is invoked with STATUS set to an error value, or if it
*     should fail for any reason.
*--
*/

/* This base iplementation just returns a clone of the supplied Mapping
   pointer. Sub-classes should override it as necessary. */
   return astClone( this );
}

static void ReportPoints( AstMapping *this, int forward,
                          AstPointSet *in_points, AstPointSet *out_points, int *status ) {
/*
*+
*  Name:
*     astReportPoints

*  Purpose:
*     Report the effect of transforming a set of points using a Mapping.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     void astReportPoints( AstMapping *this, int forward,
*                           AstPointSet *in_points, AstPointSet *out_points )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function reports the coordinates of a set of points before
*     and after being transformed by a Mapping, by writing them to
*     standard output.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     forward
*        A non-zero value indicates that the Mapping's forward
*        coordinate transformation has been applied, while a zero
*        value indicates the inverse transformation.
*     in_points
*        Pointer to a PointSet which is associated with the
*        coordinates of a set of points before the Mapping was
*        applied.
*     out_points
*        Pointer to a PointSet which is associated with the
*        coordinates of the same set of points after the Mapping has
*        been applied.

*  Notes:
*     - This method is provided as a development and debugging aid to
*     be invoked when coordinates are transformed by public Mapping
*     methods and under control of the "Report" Mapping attribute.
*     - Derived clases may over-ride this method in order to change
*     the way in which coordinates are formatted, etc.
*-
*/

/* Local Variables: */
   double **ptr_in;              /* Pointer to array of input data pointers */
   double **ptr_out;             /* Pointer to array of output data pointers */
   int coord;                    /* Loop counter for coordinates */
   int ncoord_in;                /* Number of input coordinates per point */
   int ncoord_out;               /* Number of output coordinates per point */
   int npoint;                   /* Number of points to report */
   int npoint_in;                /* Number of input points */
   int npoint_out;               /* Number of output points */
   int point;                    /* Loop counter for points */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain the numbers of points and coordinates associated with each
   PointSet. */
   npoint_in = astGetNpoint( in_points );
   npoint_out = astGetNpoint( out_points );
   ncoord_in = astGetNcoord( in_points );
   ncoord_out = astGetNcoord( out_points );

/* Obtain the pointers that give access to the coordinate data
   associated with each PointSet. */
   ptr_in = astGetPoints( in_points );
   ptr_out = astGetPoints( out_points );

/* In the event that both PointSets don't contain equal numbers of
   points (this shouldn't actually happen), simply use the minimum
   number. */
   npoint = ( npoint_in < npoint_out ) ? npoint_in : npoint_out;

/* Loop to report the effect of the Mapping on each point in turn. */
   for ( point = 0; point < npoint; point++ ) {

/* Report the input coordinates (in parentheses and separated by
   commas). Replace coordinate values of AST__BAD with the string
   "<bad>" to indicate missing values. */
      printf( "(" );
      for ( coord = 0; coord < ncoord_in; coord++ ) {
         if ( ptr_in[ coord ][ point ] == AST__BAD ) {
            printf( "%s<bad>", coord ? ", " : "" );
         } else {
            printf( "%s%.*g", coord ? ", " : "",
                              AST__DBL_DIG, ptr_in[ coord ][ point ] );
         }
      }

/* Similarly report the output coordinates. */
      printf( ") --> (" );
      for ( coord = 0; coord < ncoord_out; coord++ ) {
         if ( ptr_out[ coord ][ point ] == AST__BAD ) {
            printf( "%s<bad>", coord ? ", " : "" );
         } else {
            printf( "%s%.*g", coord ? ", " : "",
                              AST__DBL_DIG, ptr_out[ coord ][ point ] );
         }
      }
      printf( ")\n" );
   }
}

/*
*++
*  Name:
c     astResample<X>
f     AST_RESAMPLE<X>

*  Purpose:
*     Resample a region of a data grid.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     int astResample<X>( AstMapping *this, int ndim_in,
c                         const int lbnd_in[], const int ubnd_in[],
c                         const <Xtype> in[], const <Xtype> in_var[],
c                         int interp, void (* finterp)( void ),
c                         const double params[], int flags,
c                         double tol, int maxpix,
c                         <Xtype> badval, int ndim_out,
c                         const int lbnd_out[], const int ubnd_out[],
c                         const int lbnd[], const int ubnd[],
c                         <Xtype> out[], <Xtype> out_var[] );
f     RESULT = AST_RESAMPLE<X>( THIS, NDIM_IN, LBND_IN, UBND_IN, IN, IN_VAR,
f                               INTERP, FINTERP, PARAMS, FLAGS,
f                               TOL, MAXPIX, BADVAL,
f                               NDIM_OUT, LBND_OUT, UBND_OUT,
f                               LBND, UBND, OUT, OUT_VAR, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This is a set of functions for resampling gridded data (e.g. an
*     image) under the control of a geometrical transformation, which
*     is specified by a Mapping.  The functions operate on a pair of
*     data grids (input and output), each of which may have any number
*     of dimensions. Resampling may be restricted to a specified
*     region of the output grid. An associated grid of error estimates
*     associated with the input data may also be supplied (in the form
*     of variance values), so as to produce error estimates for the
*     resampled output data. Propagation of missing data (bad pixels)
*     is supported.
*
*     You should use a resampling function which matches the numerical
*     type of the data you are processing by replacing <X> in
c     the generic function name astResample<X> by an appropriate 1- or
f     the generic function name AST_RESAMPLE<X> by an appropriate 1- or
*     2-character type code. For example, if you are resampling data
c     with type "float", you should use the function astResampleF (see
f     with type REAL, you should use the function AST_RESAMPLER (see
*     the "Data Type Codes" section below for the codes appropriate to
*     other numerical types).
*
*     Resampling of the grid of input data is performed by
*     transforming the coordinates of the centre of each output grid
*     element (or pixel) into the coordinate system of the input grid.
*     Since the resulting coordinates will not, in general, coincide
*     with the centre of an input pixel, sub-pixel interpolation is
*     performed between the neighbouring input pixels. This produces a
*     resampled value which is then assigned to the output pixel. A
*     choice of sub-pixel interpolation schemes is provided, but you
*     may also implement your own.
*
*     This algorithm samples the input data value, it does not integrate
*     it. Thus total data value in the input image will not, in general,
*     be conserved. However, an option is provided (see the "Control Flags"
*     section below) which can produce approximate flux conservation by
*     scaling the output values using the ratio of the output pixel size
*     to the input pixel size. However, if accurate flux conservation is
*     important to you, consder using the
c     astRebin<X> or astRebinSeq<X> family of functions
f     AST_REBIN<X> or AST_REBINSEQ<X> family of routines
*     instead.
*
*     Output pixel coordinates are transformed into the coordinate
*     system of the input grid using the inverse transformation of the
*     Mapping which is supplied. This means that geometrical features
*     in the input data are subjected to the Mapping's forward
*     transformation as they are transferred from the input to the
*     output grid (although the Mapping's forward transformation is
*     not explicitly used).
*
*     In practice, transforming the coordinates of every pixel of a
*     large data grid can be time-consuming, especially if the Mapping
*     involves complicated functions, such as sky projections. To
*     improve performance, it is therefore possible to approximate
*     non-linear Mappings by a set of linear transformations which are
*     applied piece-wise to separate sub-regions of the data. This
*     approximation process is applied automatically by an adaptive
*     algorithm, under control of an accuracy criterion which
*     expresses the maximum tolerable geometrical distortion which may
*     be introduced, as a fraction of a pixel.
*
*     This algorithm first attempts to approximate the Mapping with a
*     linear transformation applied over the whole region of the
*     output grid which is being used. If this proves to be
*     insufficiently accurate, the output region is sub-divided into
*     two along its largest dimension and the process is repeated
*     within each of the resulting sub-regions. This process of
*     sub-division continues until a sufficiently good linear
*     approximation is found, or the region to which it is being
*     applied becomes too small (in which case the original Mapping is
*     used directly).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to a Mapping, whose inverse transformation will be
*        used to transform the coordinates of pixels in the output
*        grid into the coordinate system of the input grid. This
*        yields the positions which are used to obtain resampled
*        values by sub-pixel interpolation within the input grid.
*
*        The number of input coordinates used by this Mapping (as
*        given by its Nin attribute) should match the number of input
c        grid dimensions given by the value of "ndim_in"
f        grid dimensions given by the value of NDIM_IN
*        below. Similarly, the number of output coordinates (Nout
*        attribute) should match the number of output grid dimensions
c        given by "ndim_out".
f        given by NDIM_OUT.
c     ndim_in
f     NDIM_IN = INTEGER (Given)
*        The number of dimensions in the input grid. This should be at
*        least one.
c     lbnd_in
f     LBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
c     ubnd_in
f     UBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
c        Note that "lbnd_in" and "ubnd_in" together define the shape
f        Note that LBND_IN and UBND_IN together define the shape
*        and size of the input grid, its extent along a particular
c        (j'th) dimension being ubnd_in[j]-lbnd_in[j]+1 (assuming the
c        index "j" to be zero-based). They also define
f        (J'th) dimension being UBND_IN(J)-LBND_IN(J)+1. They also define
*        the input grid's coordinate system, each pixel having unit
*        extent along each dimension with integral coordinate values
*        at its centre.
c     in
f     IN( * ) = <Xtype> (Given)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        input grid, containing the input data to be resampled.  The
*        numerical type of this array should match the 1- or
*        2-character type code appended to the function name (e.g. if
c        you are using astResampleF, the type of each array element
c        should be "float").
f        you are using AST_RESAMPLER, the type of each array element
f        should be REAL).
*
*        The storage order of data within this array should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     in_var
f     IN_VAR( * ) = <Xtype> (Given)
c        An optional pointer to a second array with the same size and
c        type as the "in" array. If given, this should contain a set
c        of non-negative values which represent estimates of the
c        statistical variance associated with each element of the "in"
c        array. If this array is supplied (together with the
c        corresponding "out_var" array), then estimates of the
c        variance of the resampled output data will be calculated.
c
c        If no input variance estimates are being provided, a NULL
c        pointer should be given.
f        An optional second array with the same size and type as the
f        IN array. If the AST__USEVAR flag is set via the FLAGS
f        argument (below), this array should contain a set of
f        non-negative values which represent estimates of the
f        statistical variance associated with each element of the IN
f        array. Estimates of the variance of the resampled output data
f        will then be calculated.
f
f        If the AST__USEVAR flag is not set, no input variance
f        estimates are required and this array will not be used. A
f        dummy (e.g. one-element) array may then be supplied.
c     interp
f     INTERP = INTEGER (Given)
c        This parameter specifies the scheme to be used for sub-pixel
f        This argument specifies the scheme to be used for sub-pixel
*        interpolation within the input grid. It may be used to select
*        from a set of pre-defined schemes by supplying one of the
*        values described in the "Sub-Pixel Interpolation Schemes"
*        section below.  If a value of zero is supplied, then the
*        default linear interpolation scheme is used (equivalent to
*        supplying the value AST__LINEAR).
*
*        Alternatively, you may supply a value which indicates that
c        you will provide your own function to perform sub-pixel
c        interpolation by means of the "finterp " parameter. Again, see
f        you will provide your own routine to perform sub-pixel
f        interpolation by means of the FINTERP argument. Again, see
*        the "Sub-Pixel Interpolation Schemes" section below for
*        details.
c     finterp
f     FINTERP = SUBROUTINE (Given)
c        If the value given for the "interp" parameter indicates that
c        you will provide your own function for sub-pixel
c        interpolation, then a pointer to that function should be
c        given here. For details of the interface which the function
c        should have (several are possible, depending on the value of
c        "interp"), see the "Sub-Pixel Interpolation Schemes" section
c        below.
f        If the value given for the INTERP argument indicates that you
f        will provide your own routine for sub-pixel interpolation,
f        then the name of that routine should be given here (the name
f        should also appear in a Fortran EXTERNAL statement in the
f        routine which invokes AST_RESAMPLE<X>). For details of the
f        interface which the routine should have (several are
f        possible, depending on the value of INTERP), see the
f        "Sub-Pixel Interpolation Schemes" section below.
*
c        If the "interp" parameter has any other value, corresponding
c        to one of the pre-defined interpolation schemes, then this
c        function will not be used and you may supply a NULL pointer.
f        If the INTERP argument has any other value, corresponding to
f        one of the pre-defined interpolation schemes, then this
f        routine will not be used and you may supply the null routine
f        AST_NULL here (note only one underscore).  No EXTERNAL
f        statement is required for this routine, so long as the AST_PAR
f        include file has been used.
c     params
f     PARAMS( * ) = DOUBLE PRECISION (Given)
c        An optional pointer to an array of double which should contain
f        An optional array which should contain
*        any additional parameter values required by the sub-pixel
*        interpolation scheme. If such parameters are required, this
*        will be noted in the "Sub-Pixel Interpolation Schemes"
c        section below (you may also use this array to pass values
c        to your own interpolation function).
f        section below (you may also use this array to pass values
f        to your own interpolation routine).
*
c        If no additional parameters are required, this array is not
c        used and a NULL pointer may be given.
f        If no additional parameters are required, this array is not
f        used. A dummy (e.g. one-element) array may then be supplied.
c     flags
f     FLAGS = INTEGER (Given)
c        The bitwise OR of a set of flag values which may be used to
f        The sum of a set of flag values which may be used to
*        provide additional control over the resampling operation. See
*        the "Control Flags" section below for a description of the
*        options available.  If no flag values are to be set, a value
*        of zero should be given.
c     tol
f     TOL = DOUBLE PRECISION (Given)
*        The maximum tolerable geometrical distortion which may be
*        introduced as a result of approximating non-linear Mappings
*        by a set of piece-wise linear transformations. This should be
*        expressed as a displacement in pixels in the input grid's
*        coordinate system.
*
*        If piece-wise linear approximation is not required, a value
*        of zero may be given. This will ensure that the Mapping is
*        used without any approximation, but may increase execution
*        time.
c     maxpix
f     MAXPIX = INTEGER (Given)
*        A value which specifies an initial scale size (in pixels) for
*        the adaptive algorithm which approximates non-linear Mappings
*        with piece-wise linear transformations. Normally, this should
*        be a large value (larger than any dimension of the region of
*        the output grid being used). In this case, a first attempt to
*        approximate the Mapping by a linear transformation will be
*        made over the entire output region.
*
*        If a smaller value is used, the output region will first be
c        divided into sub-regions whose size does not exceed "maxpix"
f        divided into sub-regions whose size does not exceed MAXPIX
*        pixels in any dimension. Only at this point will attempts at
*        approximation commence.
*
*        This value may occasionally be useful in preventing false
*        convergence of the adaptive algorithm in cases where the
*        Mapping appears approximately linear on large scales, but has
*        irregularities (e.g. holes) on smaller scales. A value of,
*        say, 50 to 100 pixels can also be employed as a safeguard in
*        general-purpose software, since the effect on performance is
*        minimal.
*
*        If too small a value is given, it will have the effect of
*        inhibiting linear approximation altogether (equivalent to
c        setting "tol" to zero). Although this may degrade
f        setting TOL to zero). Although this may degrade
*        performance, accurate results will still be obtained.
c     badval
f     BADVAL = <Xtype> (Given)
*        This argument should have the same type as the elements of
c        the "in" array. It specifies the value used to flag missing
f        the IN array. It specifies the value used to flag missing
*        data (bad pixels) in the input and output arrays.
*
c        If the AST__USEBAD flag is set via the "flags" parameter,
f        If the AST__USEBAD flag is set via the FLAGS argument,
c        then this value is used to test for bad pixels in the "in"
c        (and "in_var") array(s).
f        then this value is used to test for bad pixels in the IN
f        (and IN_VAR) array(s).
*
c        Unless the AST__NOBAD flag is set via the "flags" parameter,
f        Unless the AST__NOBAD flag is set via the FLAGS argument,
*        this value is also used to flag any output
c        elements in the "out" (and "out_var") array(s) for which
f        elements in the OUT (and OUT_VAR) array(s) for which
*        resampled values could not be obtained (see the "Propagation
*        of Missing Data" section below for details of the
c        circumstances under which this may occur). The astResample<X>
f        circumstances under which this may occur). The AST_RESAMPLE<X>
*        function return value indicates whether any such values have
*        been produced. If the AST__NOBAD flag is set. then output array
*        elements for which no resampled value could be obtained are
*        left set to the value they had on entry to this function.
c     ndim_out
f     NDIM_OUT = INTEGER (Given)
*        The number of dimensions in the output grid. This should be
*        at least one. It need not necessarily be equal to the number
*        of dimensions in the input grid.
c     lbnd_out
f     LBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the output grid along each dimension.
c     ubnd_out
f     UBND_OUT( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the output grid along each dimension.
*
c        Note that "lbnd_out" and "ubnd_out" together define the
f        Note that LBND_OUT and UBND_OUT together define the
*        shape, size and coordinate system of the output grid in the
c        same way as "lbnd_in" and "ubnd_in" define the shape, size
f        same way as LBND_IN and UBND_IN define the shape, size
*        and coordinate system of the input grid.
c     lbnd
f     LBND( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the first pixel in the region
*        of the output grid for which a resampled value is to be
*        calculated.
c     ubnd
f     UBND( NDIM_OUT ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_out" elements,
f        An array
*        containing the coordinates of the last pixel in the region of
*        the output grid for which a resampled value is to be
*        calculated.
*
c        Note that "lbnd" and "ubnd" together define the shape and
f        Note that LBND and UBND together define the shape and
*        position of a (hyper-)rectangular region of the output grid
*        for which resampled values should be produced. This region
*        should lie wholly within the extent of the output grid (as
c        defined by the "lbnd_out" and "ubnd_out" arrays). Regions of
f        defined by the LBND_OUT and UBND_OUT arrays). Regions of
*        the output grid lying outside this region will not be
*        modified.
c     out
f     OUT( * ) = <Xtype> (Returned)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        output grid, into which the resampled data values will be
*        returned. The numerical type of this array should match that
c        of the "in" array, and the data storage order should be such
f        of the IN array, and the data storage order should be such
*        that the index of the first grid dimension varies most
*        rapidly and that of the final dimension least rapidly
c        (i.e. Fortran array indexing is used).
f        (i.e. normal Fortran array storage order).
c     out_var
f     OUT_VAR( * ) = <Xtype> (Returned)
c        An optional pointer to an array with the same type and size
c        as the "out" array. If given, this array will be used to
c        return variance estimates for the resampled data values. This
c        array will only be used if the "in_var" array has also been
c        supplied.
f        An optional array with the same type and size as the OUT
f        array. If the AST__USEVAR flag is set via the FLAGS argument,
f        this array will be used to return variance estimates for the
f        resampled data values.
*
*        The output variance values will be calculated on the
*        assumption that errors on the input data values are
*        statistically independent and that their variance estimates
*        may simply be summed (with appropriate weighting factors)
*        when several input pixels contribute to an output data
*        value. If this assumption is not valid, then the output error
*        estimates may be biased. In addition, note that the
*        statistical errors on neighbouring output data values (as
*        well as the estimates of those errors) may often be
*        correlated, even if the above assumption about the input data
*        is correct, because of the sub-pixel interpolation schemes
*        employed.
*
c        If no output variance estimates are required, a NULL pointer
c        should be given.
f        If the AST__USEVAR flag is not set, no output variance
f        estimates will be calculated and this array will not be
f        used. A dummy (e.g. one-element) array may then be supplied.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astResample<X>()
f     AST_RESAMPLE<X> = INTEGER
*        The number of output pixels for which no valid resampled value
*        could be obtained. Thus, in the absence of any error, a returned
*        value of zero indicates that all the required output pixels
*        received valid resampled data values (and variances). See the
c        "badval" and "flags" parameters.
f        BADVAL and FLAGS arguments.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.

*  Data Type Codes:
*     To select the appropriate resampling function, you should
c     replace <X> in the generic function name astResample<X> with a
f     replace <X> in the generic function name AST_RESAMPLE<X> with a
*     1- or 2-character data type code, so as to match the numerical
*     type <Xtype> of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - L: long int (may be 32 or 64 bit)
c     - K: 64 bit int
c     - UL: unsigned long int (may be 32 or 64 bit)
c     - UK: unsigned 64 bit int
c     - I: int
c     - UI: unsigned int
c     - S: short int
c     - US: unsigned short int
c     - B: byte (signed char)
c     - UB: unsigned byte (unsigned char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - UI: INTEGER (treated as unsigned)
f     - S: INTEGER*2 (short integer)
f     - US: INTEGER*2 (short integer, treated as unsigned)
f     - B: BYTE (treated as signed)
f     - UB: BYTE (treated as unsigned)
*
c     For example, astResampleD would be used to process "double"
c     data, while astResampleS would be used to process "short int"
c     data, etc.
f     For example, AST_RESAMPLED would be used to process DOUBLE
f     PRECISION data, while AST_RESAMPLES would be used to process
f     short integer data (stored in an INTEGER*2 array), etc.
f
f     For compatibility with other Starlink facilities, the codes W
f     and UW are provided as synonyms for S and US respectively (but
f     only in the Fortran interface to AST).

*  Sub-Pixel Interpolation Schemes:
*     There is no such thing as a perfect sub-pixel interpolation
*     scheme and, in practice, all resampling will result in some
*     degradation of gridded data.  A range of schemes is therefore
*     provided, from which you can choose the one which best suits
*     your needs.
*
*     In general, a balance must be struck between schemes which tend
*     to degrade sharp features in the data by smoothing them, and
*     those which attempt to preserve sharp features. The latter will
*     often tend to introduce unwanted oscillations, typically visible
*     as "ringing" around sharp features and edges, especially if the
*     data are under-sampled (i.e. if the sharpest features are less
*     than about two pixels across). In practice, a good interpolation
*     scheme is likely to be a compromise and may exhibit some aspects
*     of both these features.
*
*     For under-sampled data, some interpolation schemes may appear to
*     preserve data resolution because they transform single input
*     pixels into single output pixels, rather than spreading their
*     data between several output pixels. While this may look
*     better cosmetically, it can result in a geometrical shift of
*     sharp features in the data. You should beware of this if you
*     plan to use such features (e.g.) for image alignment.
*
*     The following are two easy-to-use sub-pixel interpolation
*     schemes which are generally applicable. They are selected by
c     supplying the appropriate value (defined in the "ast.h" header
c     file) via the "interp" parameter. In these cases, the "finterp"
c     and "params" parameters are not used:
f     supplying the appropriate value (defined in the AST_PAR include
f     file) via the INTERP argument. In these cases, the FINTERP
f     and PARAMS arguments are not used:
*
*     - AST__NEAREST: This is the simplest possible scheme, in which
*     the value of the input pixel with the nearest centre to the
*     interpolation point is used. This is very quick to execute and
*     will preserve single-pixel features in the data, but may
*     displace them by up to half their width along each dimension. It
*     often gives a good cosmetic result, so is useful for quick-look
*     processing, but is unsuitable if accurate geometrical
*     transformation is required.
*     - AST__LINEAR: This is the default scheme, which uses linear
*     interpolation between the nearest neighbouring pixels in the
*     input grid (there are two neighbours in one dimension, four
*     neighbours in two dimensions, eight in three dimensions,
*     etc.). It is superior to the nearest-pixel scheme (above) in not
*     displacing features in the data, yet it still executes fairly
*     rapidly. It is generally a safe choice if you do not have any
*     particular reason to favour another scheme, since it cannot
*     introduce oscillations. However, it does introduce some spatial
*     smoothing which varies according to the distance of the
*     interpolation point from the neighbouring pixels. This can
*     degrade the shape of sharp features in the data in a
*     position-dependent way. It may also show in the output variance
*     grid (if used) as a pattern of stripes or fringes.
*
*     An alternative set of interpolation schemes is based on forming
*     the interpolated value from the weighted sum of a set of
*     surrounding pixel values (not necessarily just the nearest
*     neighbours). This approach has its origins in the theory of
*     digital filtering, in which interpolated values are obtained by
*     conceptually passing the sampled data (represented by a grid of
*     delta functions) through a linear filter which implements a
*     convolution. Because the convolution kernel is continuous, the
*     convolution yields a continuous function which may then be
*     evaluated at fractional pixel positions. The (possibly
*     multi-dimensional) kernel is usually regarded as "separable" and
*     formed from the product of a set of identical 1-dimensional
*     kernel functions, evaluated along each dimension. Different
*     interpolation schemes are then distinguished by the choice of
*     this 1-dimensional interpolation kernel. The number of
*     surrounding pixels which contribute to the result may also be
*     varied.
*
*     From a practical standpoint, it is useful to divide the weighted
*     sum of pixel values by the sum of the weights when determining
*     the interpolated value.  Strictly, this means that a true
*     convolution is no longer being performed. However, the
*     distinction is rarely important in practice because (for
*     slightly subtle reasons) the sum of weights is always
*     approximately constant for good interpolation kernels. The
*     advantage of this technique, which is used here, is that it can
*     easily accommodate missing data and tends to minimise unwanted
*     oscillations at the edges of the data grid.
*
*     In the following schemes, which are based on a 1-dimensional
c     interpolation kernel, the first element of the "params" array
f     interpolation kernel, the first element of the PARAMS array
*     should be used to specify how many pixels are to contribute to the
*     interpolated result on either side of the interpolation point in
*     each dimension (the nearest integer value is used). Execution time
*     increases rapidly with this number. Typically, a value of 2 is
*     appropriate and the minimum value used will be 1 (i.e. two pixels
*     altogether, one on either side of the interpolation point).
c     A value of zero or less may be given for "params[0]"
f     A value of zero or less may be given for PARAMS(1)
*     to indicate that a suitable number of pixels should be calculated
*     automatically.
*
c     In each of these cases, the "finterp" parameter is not used:
f     In each of these cases, the FINTERP argument is not used:
*
*     - AST__GAUSS: This scheme uses a kernel of the form exp(-k*x*x), with
*     k a positive constant. The full-width at half-maximum (FWHM) is
*     given by
c     "params[1]"
f     PARAMS(2)
f     value, which should be at least 0.1 (in addition, setting PARAMS(1)
*     to zero will select the number of contributing pixels so as to utilise
*     the width of the kernel out to where the envelope declines to 1% of its
*     maximum value). This kernel suppresses noise at the expense of
*     smoothing the output array.
*     - AST__SINC: This scheme uses a sinc(pi*x) kernel, where x is the
*     pixel offset from the interpolation point and sinc(z)=sin(z)/z. This
*     sometimes features as an "optimal" interpolation kernel in books on
*     image processing. Its supposed optimality depends on the assumption
*     that the data are band-limited (i.e. have no spatial frequencies above
*     a certain value) and are adequately sampled. In practice, astronomical
*     data rarely meet these requirements. In addition, high spatial
*     frequencies are often present due (e.g.) to image defects and cosmic
*     ray events. Consequently, substantial ringing can be experienced with
*     this kernel. The kernel also decays slowly with distance, so that
*     many surrounding pixels are required, leading to poor performance.
*     Abruptly truncating it, by using only a few neighbouring pixels,
c     improves performance and may reduce ringing (if "params[0]" is set to
f     improves performance and may reduce ringing (if PARAMS(1) is set to
*     zero, then only two pixels will be used on either side). However, a
*     more gradual truncation, as implemented by other kernels, is generally
*     to be preferred. This kernel is provided mainly so that you can
*     convince yourself not to use it!
*     - AST__SINCSINC: This scheme uses an improved kernel, of the form
*     sinc(pi*x).sinc(k*pi*x), with k a constant, out to the point where
*     sinc(k*pi*x) goes to zero, and zero beyond. The second sinc() factor
*     provides an "envelope" which gradually rolls off the normal sinc(pi*x)
*     kernel at large offsets. The width of this envelope is specified by
*     giving the number of pixels offset at which it goes to zero by means
c     of the "params[1]" value, which should be at least 1.0 (in addition,
c     setting "params[0]" to zero will select the number of contributing
f     of the PARAMS(2) value, which should be at least 1.0 (in addition,
f     setting PARAMS(1) to zero will select the number of contributing
*     pixels so as to utilise the full width of the kernel, out to where it
c     reaches zero). The case given by "params[0]=2, params[1]=2" is typically
f     reaches zero). The case given by PARAMS(1)=2, PARAMS(2)=2 is typically
*     a good choice and is sometimes known as the Lanczos kernel. This is a
*     valuable general-purpose interpolation scheme, intermediate in its
*     visual effect on images between the AST__NEAREST and AST__LINEAR
*     schemes. Although the kernel is slightly oscillatory, ringing is
*     adequately suppressed if the data are well sampled.
*     - AST__SINCCOS: This scheme uses a kernel of the form
*     sinc(pi*x).cos(k*pi*x), with k a constant, out to the point where
*     cos(k*pi*x) goes to zero, and zero beyond. As above, the cos() factor
*     provides an envelope which gradually rolls off the sinc() kernel
*     at large offsets. The width of this envelope is specified by giving
*     the number of pixels offset at which it goes to zero by means
c     of the "params[1]" value, which should be at least 1.0 (in addition,
c     setting "params[0]" to zero will select the number of contributing
f     of the PARAMS(2) value, which should be at least 1.0 (in addition,
f     setting PARAMS(1) to zero will select the number of contributing
*     pixels so as to utilise the full width of the kernel, out to where it
*     reaches zero). This scheme gives similar results to the
*     AST__SINCSINC scheme, which it resembles.
*     - AST__SINCGAUSS: This scheme uses a kernel of the form
*     sinc(pi*x).exp(-k*x*x), with k a positive constant. Here, the sinc()
*     kernel is rolled off using a Gaussian envelope which is specified by
c     giving its full-width at half-maximum (FWHM) by means of the "params[1]"
c     value, which should be at least 0.1 (in addition, setting "params[0]"
f     giving its full-width at half-maximum (FWHM) by means of the PARAMS(2)
f     value, which should be at least 0.1 (in addition, setting PARAMS(1)
*     to zero will select the number of contributing pixels so as to utilise
*     the width of the kernel out to where the envelope declines to 1% of its
*     maximum value). On astronomical images and spectra, good results are
*     often obtained by approximately matching the FWHM of the
c     envelope function, given by "params[1]", to the point spread function
f     envelope function, given by PARAMS(2), to the point spread function
*     of the input data. However, there does not seem to be any theoretical
*     reason for this.
*     - AST__SOMB: This scheme uses a somb(pi*x) kernel (a "sombrero"
*     function), where x is the pixel offset from the interpolation point
*     and somb(z)=2*J1(z)/z  (J1 is a Bessel function of the first kind of
*     order 1). It is similar to the AST__SINC kernel, and has the same
*     parameter usage.
*     - AST__SOMBCOS: This scheme uses a kernel of the form
*     somb(pi*x).cos(k*pi*x), with k a constant, out to the point where
*     cos(k*pi*x) goes to zero, and zero beyond. It is similar to the
*     AST__SINCCOS kernel, and has the same parameter usage.
*
*     In addition, the following schemes are provided which are not based
*     on a 1-dimensional kernel:
*
*     - AST__BLOCKAVE: This scheme simply takes an average of all the
*     pixels on the input grid in a cube centred on the interpolation
*     point.  The number of pixels in the cube is determined by the
c     value of the first element of the "params" array, which gives
f     value of the first element of the PARAMS array, which gives
*     the number of pixels in each dimension on either side of the
c     central point.  Hence a block of (2 * params[0])^ndim_in
f     central point.  Hence a block of (2 * PARAMS(1))**NDIM_IN
*     pixels in the input grid will be examined to determine the
*     value of the output pixel.  If the variance is not being used
c     (var_in or var_out = NULL) then all valid pixels in this cube
f     (USEVAR = .FALSE.) then all valid pixels in this cube
*     will be averaged in to the result with equal weight.
*     If variances are being used, then each input pixel will be
*     weighted proportionally to the reciprocal of its variance; any
*     pixel without a valid variance will be discarded.  This scheme
*     is suitable where the output grid is much coarser than the
*     input grid; if the ratio of pixel sizes is R then a suitable
c     value of params[0] may be R/2.
f     value of PARAMS(1) may be R/2.
*
c     Finally, supplying the following values for "interp" allows you
c     to implement your own sub-pixel interpolation scheme by means of
c     your own function. You should supply a pointer to this function
c     via the "finterp" parameter:
f     Finally, supplying the following values for INTERP allows you to
f     implement your own sub-pixel interpolation scheme by means of
f     your own routine. You should supply the name of this routine via
f     the FINTERP argument:
*
c     - AST__UKERN1: In this scheme, you supply a function to evaluate
c     your own 1-dimensional interpolation kernel, which is then used
c     to perform sub-pixel interpolation (as described above). The
c     function you supply should have the same interface as the
c     fictitious astUkern1 function (q.v.).  In addition, a value
c     should be given via "params[0]" to specify the number of
c     neighbouring pixels which are to contribute to each interpolated
c     value (in the same way as for the pre-defined interpolation
c     schemes described above). Other elements of the "params" array
c     are available to pass values to your interpolation function.
f     - AST__UKERN1: In this scheme, you supply a routine to evaluate
f     your own 1-dimensional interpolation kernel, which is then used
f     to perform sub-pixel interpolation (as described above). The
f     routine you supply should have the same interface as the
f     fictitious AST_UKERN1 routine (q.v.).  In addition, a value
f     should be given via PARAMS(1) to specify the number of
f     neighbouring pixels which are to contribute to each interpolated
f     value (in the same way as for the pre-defined interpolation
f     schemes described above). Other elements of the PARAMS array
f     are available to pass values to your interpolation routine.
*
c     - AST__UINTERP: This is a completely general scheme, in which
c     your interpolation function has access to all of the input
c     data. This allows you to implement any interpolation algorithm
c     you choose, which could (for example) be non-linear, or
c     adaptive. In this case, the astResample<X> functions play no
c     role in the sub-pixel interpolation process and simply handle
c     the geometrical transformation of coordinates and other
c     housekeeping. The function you supply should have the same
c     interface as the fictitious astUinterp function (q.v.). In this
c     case, the "params" parameter is not used by astResample<X>, but
c     is available to pass values to your interpolation function.
f     - AST__UINTERP: This is a completely general scheme, in which
f     your interpolation routine has access to all of the input
f     data. This allows you to implement any interpolation algorithm
f     you choose, which could (for example) be non-linear, or
f     adaptive. In this case, the AST_RESAMPLE<X> functions play no
f     role in the sub-pixel interpolation process and simply handle
f     the geometrical transformation of coordinates and other
f     housekeeping. The routine you supply should have the same
f     interface as the fictitious AST_UINTERP routine (q.v.). In this
f     case, the PARAMS argument is not used by AST_RESAMPLE<X>, but
f     is available to pass values to your interpolation routine.

*  Control Flags:
c     The following flags are defined in the "ast.h" header file and
f     The following flags are defined in the AST_PAR include file and
*     may be used to provide additional control over the resampling
*     process. Having selected a set of flags, you should supply the
c     bitwise OR of their values via the "flags" parameter:
f     sum of their values via the FLAGS argument:
*
*     - AST__NOBAD: Indicates that any output array elements for which no
*     resampled value could be obtained should be left set to the value
*     they had on entry to this function. If this flag is not supplied,
*     such output array elements are set to the value supplied for
c     parameter "badval". Note, this flag cannot be used in conjunction
f     argument BADVAL. Note, this flag cannot be used in conjunction
*     with the AST__CONSERVEFLUX flag (an error will be reported if both
*     flags are specified).
*     - AST__URESAMP1, 2, 3 & 4: A set of four flags which are
*     reserved for your own use. They may be used to pass private
c     information to any sub-pixel interpolation function which you
f     information to any sub-pixel interpolation routine which you
*     implement yourself. They are ignored by all the pre-defined
*     interpolation schemes.
*     - AST__USEBAD: Indicates that there may be bad pixels in the
*     input array(s) which must be recognised by comparing with the
c     value given for "badval" and propagated to the output array(s).
f     value given for BADVAL and propagated to the output array(s).
*     If this flag is not set, all input values are treated literally
c     and the "badval" value is only used for flagging output array
f     and the BADVAL value is only used for flagging output array
*     values.
f     - AST__USEVAR: Indicates that variance information should be
f     processed in order to provide estimates of the statistical error
f     associated with the resampled values. If this flag is not set,
f     no variance processing will occur and the IN_VAR and OUT_VAR
f     arrays will not be used. (Note that this flag is only available
f     in the Fortran interface to AST.)
*     - AST__CONSERVEFLUX: Indicates that the output pixel values should
*     be scaled in such a way as to preserve (approximately) the total data
*     value in a feature on the sky. Without this flag, each output pixel
*     value represents an instantaneous sample of the input data values at
*     the corresponding input position. This is appropriate if the input
*     data represents the spatial density of some quantity (e.g. surface
*     brightness in Janskys per square arc-second) because the output
*     pixel values will have the same normalisation and units as the
*     input pixel values. However, if the input data values represent
*     flux (or some other physical quantity) per pixel, then the
*     AST__CONSERVEFLUX flag could be used. This causes each output
*     pixel value to be scaled by the ratio of the output pixel size to
*     the input pixel size.
*
*     This flag can only be used if the Mapping is successfully approximated
*     by one or more linear transformations. Thus an error will be reported
*     if it used when the
c     "tol" parameter
f     TOL argument
*     is set to zero (which stops the use of linear approximations), or
*     if the Mapping is too non-linear to be approximated by a piece-wise
*     linear transformation. The ratio of output to input pixel size is
*     evaluated once for each panel of the piece-wise linear approximation to
*     the Mapping, and is assumed to be constant for all output pixels in the
*     panel. The scaling factors for adjacent panels will in general
*     differ slightly, and so the joints between panels may be visible when
*     viewing the output image at high contrast. If this is a problem,
*     reduce the value of the
c     "tol" parameter
f     TOL argument
*     until the difference between adjacent panels is sufficiently small
*     to be insignificant.
*
*     Note, this flag cannot be used in conjunction with the AST__NOBAD
*     flag (an error will be reported if both flags are specified).

*  Propagation of Missing Data:
*     Unless the AST__NOBAD flag is specified, instances of missing data
*     (bad pixels) in the output grid are
c     identified by occurrences of the "badval" value in the "out"
f     identified by occurrences of the BADVAL value in the OUT
*     array. These may be produced if any of the following happen:
*
*     - The input position (the transformed position of the output
*     pixel's centre) lies outside the boundary of the grid of input
*     pixels.
*     - The input position lies inside the boundary of a bad input
*     pixel. In this context, an input pixel is considered bad if its
c     data value is equal to "badval" and the AST__USEBAD flag is
c     set via the "flags" parameter.
f     data value is equal to BADVAL and the AST__USEBAD flag is
f     set via the FLAGS argument.
*     (Positions which have half-integral coordinate values, and
*     therefore lie on a pixel boundary, are regarded as lying within
*     the pixel with the larger, i.e. more positive, index.)
*     - The set of neighbouring input pixels (excluding those which
*     are bad) is unsuitable for calculating an interpolated
*     value. Whether this is true may depend on the sub-pixel
*     interpolation scheme in use.
*     - The interpolated value lies outside the range which can be
c     represented using the data type of the "out" array.
f     represented using the data type of the OUT array.
*
*     In addition, associated output variance estimates (if
c     calculated) may be declared bad and flagged with the "badval"
c     value in the "out_var" array under any of the following
f     calculated) may be declared bad and flagged with the BADVAL
f     value in the OUT_VAR array under any of the following
*     circumstances:
*
c     - The associated resampled data value (in the "out" array) is bad.
f     - The associated resampled data value (in the OUT array) is bad.
*     - The set of neighbouring input pixels which contributed to the
*     output data value do not all have valid variance estimates
*     associated with them. In this context, an input variance
*     estimate may be regarded as bad either because it has the value
c     "badval" (and the AST__USEBAD flag is set), or because it is
f     BADVAL (and the AST__USEBAD flag is set), or because it is
*     negative.
*     - The set of neighbouring input pixels for which valid variance
*     values are available is unsuitable for calculating an overall
*     variance value. Whether this is true may depend on the sub-pixel
*     interpolation scheme in use.
*     - The variance value lies outside the range which can be
c     represented using the data type of the "out_var" array.
f     represented using the data type of the OUT_VAR array.
*
*     If the AST__NOBAD flag is specified via
c     parameter "flags",
f     argument FLAGS,
*     then output array elements that would otherwise be set to
c     "badval"
f     BADVAL
*     are instead left holding the value they had on entry to this
*     function. The number of such array elements is returned as
*     the function value.
*--
*/
/* Define a macro to implement the function for a specific data
   type. */
#define MAKE_RESAMPLE(X,Xtype) \
static int Resample##X( AstMapping *this, int ndim_in, \
                        const int lbnd_in[], const int ubnd_in[], \
                        const Xtype in[], const Xtype in_var[], \
                        int interp, void (* finterp)( void ), \
                        const double params[], int flags, double tol, \
                        int maxpix, Xtype badval, \
                        int ndim_out, const int lbnd_out[], \
                        const int ubnd_out[], const int lbnd[], \
                        const int ubnd[], Xtype out[], Xtype out_var[], int *status ) { \
\
/* Local Variables: */ \
   astDECLARE_GLOBALS            /* Thread-specific data */ \
   AstMapping *simple;           /* Pointer to simplified Mapping */ \
   int idim;                     /* Loop counter for coordinate dimensions */ \
   int nin;                      /* Number of Mapping input coordinates */ \
   int nout;                     /* Number of Mapping output coordinates */ \
   int npix;                     /* Number of pixels in output region */ \
   int result;                   /* Result value to return */ \
   int64_t mpix;                 /* Number of pixels for testing */ \
\
/* Initialise. */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Get a pointer to a structure holding thread-specific global data values */ \
   astGET_GLOBALS(this); \
\
/* Obtain values for the Nin and Nout attributes of the Mapping. */ \
   nin = astGetNin( this ); \
   nout = astGetNout( this ); \
\
/* If OK, check that the number of input grid dimensions matches the \
   number required by the Mapping and is at least 1. Report an error \
   if necessary. */ \
   if ( astOK && ( ( ndim_in != nin ) || ( ndim_in < 1 ) ) ) { \
      astError( AST__NGDIN, "astResample"#X"(%s): Bad number of input grid " \
                "dimensions (%d).", status, astGetClass( this ), ndim_in ); \
      if ( ndim_in != nin ) { \
         astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \
                   "to specify an input position.", status, \
                   astGetClass( this ), nin, ( nin == 1 ) ? "" : "s" ); \
      } \
   } \
\
/* If OK, also check that the number of output grid dimensions matches \
   the number required by the Mapping and is at least 1. Report an \
   error if necessary. */ \
   if ( astOK && ( ( ndim_out != nout ) || ( ndim_out < 1 ) ) ) { \
      astError( AST__NGDIN, "astResample"#X"(%s): Bad number of output grid " \
                "dimensions (%d).", status, astGetClass( this ), ndim_out ); \
      if ( ndim_out != nout ) { \
         astError( AST__NGDIN, "The %s given generates %s%d coordinate " \
                   "value%s for each output position.", status, astGetClass( this ), \
                   ( nout < ndim_out ) ? "only " : "", nout, \
                   ( nout == 1 ) ? "" : "s" ); \
      } \
   } \
\
/* Check that the lower and upper bounds of the input grid are \
   consistent. Report an error if any pair is not. Also get the number \
   of pixels in the input grid. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_in; idim++ ) { \
         if ( lbnd_in[ idim ] > ubnd_in[ idim ] ) { \
            astError( AST__GBDIN, "astResample"#X"(%s): Lower bound of " \
                      "input grid (%d) exceeds corresponding upper bound " \
                      "(%d).", status, astGetClass( this ), \
                      lbnd_in[ idim ], ubnd_in[ idim ] ); \
            astError( AST__GBDIN, "Error in input dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } else { \
            mpix *= ubnd_in[ idim ] - lbnd_in[ idim ] + 1; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the input. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astResample"#X"(%s): Supplied input array " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* Check that the positional accuracy tolerance supplied is valid and \
   report an error if necessary. */ \
   if ( astOK && ( tol < 0.0 ) ) { \
      astError( AST__PATIN, "astResample"#X"(%s): Invalid positional " \
                "accuracy tolerance (%.*g pixel).", status, \
                astGetClass( this ), AST__DBL_DIG, tol ); \
      astError( AST__PATIN, "This value should not be less than zero." , status); \
   } \
\
/* Check that the initial scale size in pixels supplied is valid and \
   report an error if necessary. */ \
   if ( astOK && ( maxpix < 0 ) ) { \
      astError( AST__SSPIN, "astResample"#X"(%s): Invalid initial scale " \
                "size in pixels (%d).", status, astGetClass( this ), maxpix ); \
      astError( AST__SSPIN, "This value should not be less than zero." , status); \
   } \
\
/* Check that the lower and upper bounds of the output grid are \
   consistent. Report an error if any pair is not. Also get the \
   number of pixels in the output array. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         if ( lbnd_out[ idim ] > ubnd_out[ idim ] ) { \
            astError( AST__GBDIN, "astResample"#X"(%s): Lower bound of " \
                      "output grid (%d) exceeds corresponding upper bound " \
                      "(%d).", status, astGetClass( this ), \
                      lbnd_out[ idim ], ubnd_out[ idim ] ); \
            astError( AST__GBDIN, "Error in output dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } else { \
            mpix *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the output. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astResample"#X"(%s): Supplied output array " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* Similarly check the bounds of the output region. */ \
   mpix = 1; \
   if ( astOK ) { \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         if ( lbnd[ idim ] > ubnd[ idim ] ) { \
            astError( AST__GBDIN, "astResample"#X"(%s): Lower bound of " \
                      "output region (%d) exceeds corresponding upper " \
                      "bound (%d).", status, astGetClass( this ), \
                      lbnd[ idim ], ubnd[ idim ] ); \
\
/* Also check that the output region lies wholly within the output \
   grid. */ \
         } else if ( lbnd[ idim ] < lbnd_out[ idim ] ) { \
            astError( AST__GBDIN, "astResample"#X"(%s): Lower bound of " \
                      "output region (%d) is less than corresponding " \
                      "bound of output grid (%d).", status, astGetClass( this ), \
                      lbnd[ idim ], lbnd_out[ idim ] ); \
         } else if ( ubnd[ idim ] > ubnd_out[ idim ] ) { \
            astError( AST__GBDIN, "astResample"#X"(%s): Upper bound of " \
                      "output region (%d) exceeds corresponding " \
                      "bound of output grid (%d).", status, astGetClass( this ), \
                      ubnd[ idim ], ubnd_out[ idim ] ); \
         } else { \
            mpix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
         } \
\
/* Say which dimension produced the error. */ \
         if ( !astOK ) { \
            astError( AST__GBDIN, "Error in output dimension %d.", status, \
                      idim + 1 ); \
            break; \
         } \
      } \
   } \
\
/* Report an error if there are too many pixels in the output region. */ \
   if ( astOK && (int) mpix != mpix ) { \
      astError( AST__EXSPIX, "astResample"#X"(%s): Supplied output region " \
                "contains too many pixels (%g): must be fewer than %d.", \
                status, astGetClass( this ), (double) mpix, INT_MAX ); \
   } \
\
/* If we are conserving flux, check "tol" is not zero. */ \
   if( ( flags & AST__CONSERVEFLUX ) && astOK ) { \
      if( tol == 0.0 ) { \
         astError( AST__CNFLX, "astResample"#X"(%s): Flux conservation was " \
                   "requested but cannot be performed because zero tolerance " \
                   "was also specified.", status, astGetClass( this ) ); \
\
/* Also check "nin" and "nout" are equal. */ \
      } else if( nin != nout ) { \
         astError( AST__CNFLX, "astResample"#X"(%s): Flux conservation was " \
                "requested but cannot be performed because the Mapping " \
                "has different numbers of inputs and outputs.", status, \
                astGetClass( this ) ); \
      } \
   } \
\
/* If OK, loop to determine how many pixels require resampled values. */ \
   simple = NULL; \
   if ( astOK ) { \
      npix = 1; \
      for ( idim = 0; idim < ndim_out; idim++ ) { \
         npix *= ubnd[ idim ] - lbnd[ idim ] + 1; \
      } \
\
/* If there are sufficient pixels to make it worthwhile, simplify the \
   Mapping supplied to improve performance. Otherwise, just clone the \
   Mapping pointer. Note we save a pointer to the original Mapping so \
   that lower-level functions can use it if they need to report an \
   error. */ \
      unsimplified_mapping = this; \
      if ( npix > 1024 ) { \
         simple = astSimplify( this ); \
      } else { \
         simple = astClone( this ); \
      } \
   } \
\
/* Report an error if the inverse transformation of this simplified \
   Mapping is not defined. */ \
   if ( !astGetTranInverse( simple ) && astOK ) { \
      astError( AST__TRNND, "astResample"#X"(%s): An inverse coordinate " \
                "transformation is not defined by the %s supplied.", status, \
                astGetClass( unsimplified_mapping ), \
                astGetClass( unsimplified_mapping ) ); \
   } \
\
/* Perform the resampling. Note that we pass all gridded data, the \
   interpolation function and the bad pixel value by means of pointer \
   types that obscure the underlying data type. This is to avoid \
   having to replicate functions unnecessarily for each data \
   type. However, we also pass an argument that identifies the data \
   type we have obscured. */ \
   result = ResampleAdaptively( simple, ndim_in, lbnd_in, ubnd_in, \
                                (const void *) in, (const void *) in_var, \
                                TYPE_##X, interp, finterp, \
                                params, flags, tol, maxpix, \
                                (const void *) &badval, \
                                ndim_out, lbnd_out, ubnd_out, \
                                lbnd, ubnd, \
                                (void *) out, (void *) out_var, status ); \
\
/* Annul the pointer to the simplified/cloned Mapping. */ \
   simple = astAnnul( simple ); \
\
/* If an error occurred, clear the returned result. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
}

/* Expand the above macro to generate a function for each required
   data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_RESAMPLE(LD,long double)
#endif
MAKE_RESAMPLE(D,double)
MAKE_RESAMPLE(F,float)
MAKE_RESAMPLE(L,long int)
MAKE_RESAMPLE(UL,unsigned long int)
MAKE_RESAMPLE(K,INT_BIG)
MAKE_RESAMPLE(UK,UINT_BIG)
MAKE_RESAMPLE(I,int)
MAKE_RESAMPLE(UI,unsigned int)
MAKE_RESAMPLE(S,short int)
MAKE_RESAMPLE(US,unsigned short int)
MAKE_RESAMPLE(B,signed char)
MAKE_RESAMPLE(UB,unsigned char)

/* Undefine the macro. */
#undef MAKE_RESAMPLE

static int ResampleAdaptively( AstMapping *this, int ndim_in,
                               const int *lbnd_in, const int *ubnd_in,
                               const void *in, const void *in_var,
                               DataType type, int interp, void (* finterp)( void ),
                               const double *params, int flags, double tol,
                               int maxpix, const void *badval_ptr,
                               int ndim_out, const int *lbnd_out,
                               const int *ubnd_out, const int *lbnd,
                               const int *ubnd, void *out, void *out_var, int *status ) {
/*
*  Name:
*     ResampleAdaptively

*  Purpose:
*     Resample a section of a data grid adaptively.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int ResampleAdaptively( AstMapping *this, int ndim_in,
*                             const int *lbnd_in, const int *ubnd_in,
*                             const void *in, const void *in_var,
*                             DataType type, int interp, void (* finterp)( void ),
*                             const double *params, int flags, double tol,
*                             int maxpix, const void *badval_ptr,
*                             int ndim_out, const int *lbnd_out,
*                             const int *ubnd_out, const int *lbnd,
*                             const int *ubnd, void *out, void *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function resamples a rectangular grid of data (with any
*     number of dimensions) into a specified section of another
*     rectangular grid (with a possibly different number of
*     dimensions). The coordinate transformation used to convert
*     output pixel coordinates into positions in the input grid is
*     given by the inverse transformation of the Mapping which is
*     supplied.  Any pixel interpolation scheme may be specified for
*     interpolating between the pixels of the input grid.
*
*     This function is very similar to ResampleWithBlocking and
*     ResampleSection which lie below it in the calling
*     hierarchy. However, this function also attempts to adapt to the
*     Mapping supplied and to sub-divide the section being resampled
*     into smaller sections within which a linear approximation to the
*     Mapping may be used.  This reduces the number of Mapping
*     evaluations, thereby improving efficiency particularly when
*     complicated Mappings are involved.

*  Parameters:
*     this
*        Pointer to a Mapping, whose inverse transformation may be
*        used to transform the coordinates of pixels in the output
*        grid into associated positions in the input grid, from which
*        the output pixel values should be derived (by interpolation
*        if necessary).
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be resampled (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the resampled data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     interp
*        A value selected from a set of pre-defined macros to identify
*        which sub-pixel interpolation algorithm should be used.
*     finterp
*        If "interp" is set to a value which requires a user-supplied
*        function, then a pointer to that function shoild be given
*        here. Otherwise, this value is not used and may be a NULL
*        pointer.
*     params
*        Pointer to an optional array of parameters that may be passed
*        to the interpolation algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     flags
*        The bitwise OR of a set of flag values which provide
*        additional control over the resampling operation.
*     tol
*        The maximum permitted positional error in transforming output
*        pixel positions into the input grid in order to resample
*        it. This should be expressed as a displacement in pixels in
*        the input grid's coordinate system. If the Mapping's inverse
*        transformation can be approximated by piecewise linear
*        functions to this accuracy, then such functions may be used
*        instead of the Mapping in order to improve
*        performance. Otherwise, every output pixel position will be
*        transformed individually using the Mapping.
*
*        If linear approximation is not required, a "tol" value of
*        zero may be given. This will ensure that the Mapping is used
*        without any approximation.
*     maxpix
*        A value which specifies the largest scale size on which to
*        search for non-linearities in the Mapping supplied. This
*        value should be expressed as a number of pixels in the output
*        grid. The function will break the output section specified
*        into smaller sub-sections (if necessary), each no larger than
*        "maxpix" pixels in any dimension, before it attempts to
*        approximate the Mapping by a linear function over each
*        sub-section.
*
*        If the value given is larger than the largest dimension of
*        the output section (the normal recommendation), the function
*        will initially search for non-linearity on a scale determined
*        by the size of the output section.  This is almost always
*        satisfactory. Very occasionally, however, a Mapping may
*        appear linear on this scale but nevertheless have smaller
*        irregularities (e.g. "holes") in it.  In such cases, "maxpix"
*        may be set to a suitably smaller value so as to ensure this
*        non-linearity is not overlooked. Typically, a value of 50 to
*        100 pixels might be suitable and should have little effect on
*        performance.
*
*        If too small a value is given, however, it will have the
*        effect of preventing linear approximation occurring at all
*        (equivalent to setting "tol" to zero).  Although this may
*        degrade performance, accurate results will still be obtained.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. Unless the AST__NOBAD flag is set, the same value will
*        also be used to flag any output array elements for which
*        resampled values could not be obtained.  The output arrays(s)
*        may be flagged with this value whether or not the AST__USEBAD
*        flag is set (the function return value indicates whether any
*        such values have been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the first pixel in the
*        section of the output data grid for which a value is
*        required.
*     ubnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the last pixel in the
*        section of the output data grid for which a value is
*        required.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the output grid for which resampled values are
*        required. This section should lie wholly within the extent of
*        the output grid (as defined by the "lbnd_out" and "ubnd_out"
*        arrays). Regions of the output grid lying outside this section
*        will not be modified.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.

*  Returned Value:
*     The number of output grid points for which no valid output value
*     could be obtained.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   double *flbnd;                /* Array holding floating point lower bounds */
   double *fubnd;                /* Array holding floating point upper bounds */
   double *linear_fit;           /* Pointer to array of fit coefficients */
   int *hi;                      /* Pointer to array of section upper bounds */
   int *lo;                      /* Pointer to array of section lower bounds */
   int coord_out;                /* Loop counter for output coordinates */
   int dim;                      /* Output section dimension size */
   int dimx;                     /* Dimension with maximum section extent */
   int divide;                   /* Sub-divide the output section? */
   int i;                        /* Loop count */
   int isLinear;                 /* Is the transformation linear? */
   int mxdim;                    /* Largest output section dimension size */
   int npix;                     /* Number of pixels in output section */
   int npoint;                   /* Number of points for obtaining a fit */
   int nvertex;                  /* Number of vertices of output section */
   int result;                   /* Result value to return */
   int toobig;                   /* Section too big (must sub-divide)? */
   int toosmall;                 /* Section too small to sub-divide? */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialisation. */
   npix = 1;
   mxdim = 0;
   dimx = 1;
   nvertex = 1;

/* Loop through the output grid dimensions. */
   for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {

/* Obtain the extent in each dimension of the output section which is
   to receive resampled values, and calculate the total number of
   pixels it contains. */
      dim = ubnd[ coord_out ] - lbnd[ coord_out ] + 1;
      npix *= dim;

/* Find the maximum dimension size of this output section and note
   which dimension has this size. */
      if ( dim > mxdim ) {
         mxdim = dim;
         dimx = coord_out;
      }

/* Calculate how many vertices the output section has. */
      nvertex *= 2;
   }

/* Calculate how many sample points will be needed (by the
   astLinearApprox function) to obtain a linear fit to the Mapping's
   inverse transformation. */
   npoint = 1 + 4 * ndim_out + 2 * nvertex;

/* If the number of pixels in the output section is not at least 4
   times this number, we will probably not save significant time by
   attempting to obtain a linear fit, so note that the output section
   is too small. */
   toosmall = ( npix < ( 4 * npoint ) );

/* Note if the maximum dimension of the output section exceeds the
   user-supplied scale factor. */
   toobig = ( maxpix < mxdim );

/* Assume the Mapping is significantly non-linear before deciding
   whether to sub-divide the output section. */
   linear_fit = NULL;

/* If the output section is too small to be worth obtaining a linear
   fit, or if the accuracy tolerance is zero, we will not
   sub-divide. This means that the Mapping will be used to transform
   each pixel's coordinates and no linear approximation will be
   used. */
   if ( toosmall || ( tol == 0.0 ) ) {
      divide = 0;

/* Otherwise, if the largest output section dimension exceeds the
   scale length given, we will sub-divide. This offers the possibility
   of obtaining a linear approximation to the Mapping over a reduced
   range of output coordinates (which will be handled by a recursive
   invocation of this function). */
   } else if ( toobig ) {
      divide = 1;

/* If neither of the above apply, then attempt to fit a linear
   approximation to the Mapping's inverse transformation over the
   range of coordinates covered by the output section. We need to
   temporarily copy the integer bounds into floating point arrays to
   use astLinearApprox. */
   } else {

/* Allocate memory for floating point bounds and for the coefficient array */
      flbnd = astMalloc( sizeof( double )*(size_t) ndim_out );
      fubnd = astMalloc( sizeof( double )*(size_t) ndim_out );
      linear_fit = astMalloc( sizeof( double )*
                              (size_t) ( ndim_in*( ndim_out + 1 ) ) );
      if( astOK ) {

/* Copy the bounds into these arrays, and change them so that they refer
   to the lower and upper edges of the cell rather than the centre. This
   is essential if one of the axes is spanned by a single cell, since
   otherwise the upper and lower bounds would be identical. */
         for( i = 0; i < ndim_out; i++ ) {
            flbnd[ i ] = (double) lbnd[ i ] - 0.5;
            fubnd[ i ] = (double) ubnd[ i ] + 0.5;
         }

/* Get the linear approximation to the inverse transformation. The
   astLinearApprox function fits the forward transformation so temporarily
   invert the Mapping in order to get a fit to the inverse transformation. */
         astInvert( this );
         isLinear = astLinearApprox( this, flbnd, fubnd, tol, linear_fit );
         astInvert( this );

/* Free the coeff array if the inverse transformation is not linear. */
         if( !isLinear ) linear_fit = astFree( linear_fit );

      } else {
         linear_fit = astFree( linear_fit );
      }

/* Free resources */
      flbnd = astFree( flbnd );
      fubnd = astFree( fubnd );

/* If a linear fit was obtained, we will use it and therefore do not
   wish to sub-divide further. Otherwise, we sub-divide in the hope
   that this may result in a linear fit next time. */
      divide = !linear_fit;
   }

/* If no sub-division is required, perform resampling (in a
   memory-efficient manner, since the section we are resampling might
   still be very large). This will use the linear fit, if obtained
   above. */
   if ( astOK ) {
      if ( !divide ) {
         result = ResampleWithBlocking( this, linear_fit,
                                        ndim_in, lbnd_in, ubnd_in,
                                        in, in_var, type, interp, finterp,
                                        params, flags, badval_ptr,
                                        ndim_out, lbnd_out, ubnd_out,
                                        lbnd, ubnd, out, out_var, status );

/* Otherwise, allocate workspace to perform the sub-division. */
      } else {
         lo = astMalloc( sizeof( int ) * (size_t) ndim_out );
         hi = astMalloc( sizeof( int ) * (size_t) ndim_out );
         if ( astOK ) {

/* Initialise the bounds of a new output section to match the original
   output section. */
            for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
               lo[ coord_out ] = lbnd[ coord_out ];
               hi[ coord_out ] = ubnd[ coord_out ];
            }

/* Replace the upper bound of the section's largest dimension with the
   mid-point of the section along this dimension, rounded
   downwards. */
            hi[ dimx ] =
               (int) floor( 0.5 * (double) ( lbnd[ dimx ] + ubnd[ dimx ] ) );

/* Resample the resulting smaller section using a recursive invocation
   of this function. */
            result = ResampleAdaptively( this, ndim_in, lbnd_in, ubnd_in,
                                         in, in_var, type, interp, finterp,
                                         params, flags, tol, maxpix,
                                         badval_ptr, ndim_out,
                                         lbnd_out, ubnd_out,
                                         lo, hi, out, out_var, status );

/* Now set up a second section which covers the remaining half of the
   original output section. */
            lo[ dimx ] = hi[ dimx ] + 1;
            hi[ dimx ] = ubnd[ dimx ];

/* If this section contains pixels, resample it in the same way,
   summing the returned values. */
            if ( lo[ dimx ] <= hi[ dimx ] ) {
               result += ResampleAdaptively( this, ndim_in, lbnd_in, ubnd_in,
                                             in, in_var, type, interp, finterp,
                                             params, flags, tol, maxpix,
                                             badval_ptr,  ndim_out,
                                             lbnd_out, ubnd_out,
                                             lo, hi, out, out_var, status );
            }
         }

/* Free the workspace. */
         lo = astFree( lo );
         hi = astFree( hi );
      }
   }

/* If coefficients for a linear fit were obtained, then free the space
   they occupy. */
   if ( linear_fit ) linear_fit = astFree( linear_fit );

/* If an error occurred, clear the returned result. */
   if ( !astOK ) result = 0;

/* Return the result. */
   return result;
}

static int ResampleSection( AstMapping *this, const double *linear_fit,
                            int ndim_in,
                            const int *lbnd_in, const int *ubnd_in,
                            const void *in, const void *in_var,
                            DataType type, int interp, void (* finterp)( void ),
                            const double *params, double factor, int flags,
                            const void *badval_ptr, int ndim_out,
                            const int *lbnd_out, const int *ubnd_out,
                            const int *lbnd, const int *ubnd,
                            void *out, void *out_var, int *status ) {
/*
*  Name:
*     ResampleSection

*  Purpose:
*     Resample a section of a data grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int ResampleSection( AstMapping *this, const double *linear_fit,
*                          int ndim_in, const int *lbnd_in, const int *ubnd_in,
*                          const void *in, const void *in_var,
*                          DataType type, int interp, void (* finterp)( void ),
*                          const double *params, double factor, int flags,
*                          const void *badval_ptr, int ndim_out,
*                          const int *lbnd_out, const int *ubnd_out,
*                          const int *lbnd, const int *ubnd,
*                          void *out, void *out_var )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function resamples a rectangular grid of data (with any
*     number of dimensions) into a specified section of another
*     rectangular grid (with a possibly different number of
*     dimensions). The coordinate transformation used is given by the
*     inverse transformation of the Mapping which is supplied or,
*     alternatively, by a linear approximation fitted to a Mapping's
*     inverse transformation. Any pixel interpolation scheme may be
*     specified for interpolating between the pixels of the input
*     grid.

*  Parameters:
*     this
*        Pointer to a Mapping, whose inverse transformation may be
*        used to transform the coordinates of pixels in the output
*        grid into associated positions in the input grid, from which
*        the output pixel values should be derived (by interpolation
*        if necessary).
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's inverse coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        inverse transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be resampled (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the resampled data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     interp
*        A value selected from a set of pre-defined macros to identify
*        which sub-pixel interpolation algorithm should be used.
*     finterp
*        If "interp" is set to a value which requires a user-supplied
*        function, then a pointer to that function shoild be given
*        here. Otherwise, this value is not used and may be a NULL
*        pointer.
*     params
*        Pointer to an optional array of parameters that may be passed
*        to the interpolation algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     factor
*        A factor by which to scale the resampled output data values before
*        returning them. If flux is being conserved this should be set to
*        the ratio of the output pixel size to the input pixel size in the
*        section. Otherwise it should be set to 1.0.
*     flags
*        The bitwise OR of a set of flag values which provide
*        additional control over the resampling operation.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. Unless the AST__NOBAD flag is set, the same value will
*        also be used to flag any output array elements for which
*        resampled values could not be obtained.  The output arrays(s)
*        may be flagged with this value whether or not the AST__USEBAD
*        flag is set (the function return value indicates whether any
*        such values have been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the first pixel in the
*        section of the output data grid for which a value is
*        required.
*     ubnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the last pixel in the
*        section of the output data grid for which a value is
*        required.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the output grid for which resampled values are
*        required. This section should lie wholly within the extent of
*        the output grid (as defined by the "lbnd_out" and "ubnd_out"
*        arrays). Regions of the output grid lying outside this section
*        will not be modified.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.

*  Returned Value:
*       The number of output grid points for which no valid output value
*       could be obtained.

*  Notes:
*     - This function does not take steps to limit memory usage if the
*     grids supplied are large. To resample large grids in a more
*     memory-efficient way, the ResampleWithBlocking function should
*     be used.
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Thread-specific data */
   AstPointSet *pset_in;         /* Input PointSet for transformation */
   AstPointSet *pset_out;        /* Output PointSet for transformation */
   const double *grad;           /* Pointer to gradient matrix of linear fit */
   const double *par;            /* Pointer to parameter array */
   const double *zero;           /* Pointer to zero point array of fit */
   double **ptr_in;              /* Pointer to input PointSet coordinates */
   double **ptr_out;             /* Pointer to output PointSet coordinates */
   double *accum;                /* Pointer to array of accumulated sums */
   double fwhm;                  /* Full width half max. of gaussian */
   double lpar[ 1 ];             /* Local parameter array */
   double x1;                    /* Interim x coordinate value */
   double y1;                    /* Interim y coordinate value */
   int *dim;                     /* Pointer to array of output pixel indices */
   int *offset;                  /* Pointer to array of output pixel offsets */
   int *stride;                  /* Pointer to array of output grid strides */
   int conserve;                 /* Conserve flux? */
   int coord_in;                 /* Loop counter for input dimensions */
   int coord_out;                /* Loop counter for output dimensions */
   int done;                     /* All pixel indices done? */
   int i1;                       /* Interim offset into "accum" array */
   int i2;                       /* Final offset into "accum" array */
   int idim;                     /* Loop counter for dimensions */
   int ix;                       /* Loop counter for output x coordinate */
   int iy;                       /* Loop counter for output y coordinate */
   int nbad;                     /* Number of pixels assigned a bad value */
   int neighb;                   /* Number of neighbouring pixels */
   int npoint;                   /* Number of output points (pixels) */
   int off1;                     /* Interim pixel offset into output array */
   int off;                      /* Final pixel offset into output array */
   int point;                    /* Counter for output points (pixels ) */
   int result;                   /* Result value to be returned */
   int s;                        /* Temporary variable for strides */
   int usevar;                   /* Process variance array? */
   void (* gifunc)( void );      /* General interpolation function */
   void (* kernel)( double, const double [], int, double *, int * ); /* Kernel fn. */
   void (* fkernel)( double, const double [], int, double * ); /* User kernel fn. */

/* Initialise. */
   result = 0;

/* Get a pointer to a structure holding thread-specific global data values */
   astGET_GLOBALS(this);

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialisation. */
   pset_in = NULL;
   ptr_in = NULL;
   neighb = 0;
   gifunc = NULL;
   kernel = NULL;
   fkernel = NULL;

/* See if we are conserving flux */
   conserve = flags & AST__CONSERVEFLUX;

/* If we are conserving flux, then we need some way to tell which output
   array elements have been assigned a value and which have not. If the
   AST__NOBAD flag has been specified then this is not possible to report
   an error. */
   if( ( flags & AST__NOBAD ) && conserve ) {
      astError( AST__BADFLG, "astResample: Cannot use the AST__NOBAD and "
                "AST__CONSERVEFLUX flags together (programming error)." , status);
   }

/* Calculate the number of output points, as given by the product of
   the output grid dimensions. */
   for ( npoint = 1, coord_out = 0; coord_out < ndim_out; coord_out++ ) {
      npoint *= ubnd[ coord_out ] - lbnd[ coord_out ] + 1;
   }

/* Allocate workspace. */
   offset = astMalloc( sizeof( int ) * (size_t) npoint );
   stride = astMalloc( sizeof( int ) * (size_t) ndim_out );
   if ( astOK ) {

/* Calculate the stride for each output grid dimension. */
      off = 0;
      s = 1;
      for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
         stride[ coord_out ] = s;
         s *= ubnd_out[ coord_out ] - lbnd_out[ coord_out ] + 1;
      }

/* A linear fit to the Mapping is available. */
/* ========================================= */
      if ( linear_fit ) {

/* If a linear fit to the Mapping has been provided, then obtain
   pointers to the array of gradients and zero-points comprising the
   fit. */
         grad = linear_fit + ndim_in;
         zero = linear_fit;

/* Create a PointSet to hold the input grid coordinates and obtain an
   array of pointers to its coordinate data. */
         pset_in = astPointSet( npoint, ndim_in, "", status );
         ptr_in = astGetPoints( pset_in );
         if ( astOK ) {

/* Initialise the count of output points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ( ndim_in == 1 ) && ( ndim_out == 1 ) ) {

/* Loop through the pixels of the output grid and transform their x
   coordinates into the input grid's coordinate system using the
   linear fit supplied. Store the results in the PointSet created
   above. */
               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_in[ 0 ][ point ] = zero[ 0 ] + grad[ 0 ] * (double) ix;

/* Calculate the offset of each pixel within the output array. */
                  offset[ point ] = ix - lbnd_out[ 0 ];
                  point++;
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ( ndim_in == 2 ) && ( ndim_out == 2 ) ) {

/* Loop through the range of y coordinates in the output grid and
   calculate interim values of the input coordinates using the linear
   fit supplied. */
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  x1 = zero[ 0 ] + grad[ 1 ] * (double) iy;
                  y1 = zero[ 1 ] + grad[ 3 ] * (double) iy;

/* Also calculate an interim pixel offset into the output array. */
                  off1 = stride[ 1 ] * ( iy - lbnd_out[ 1 ] ) - lbnd_out[ 0 ];

/* Now loop through the range of output x coordinates and calculate
   the final values of the input coordinates, storing the results in
   the PointSet created above. */
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_in[ 0 ][ point ] = x1 + grad[ 0 ] * (double) ix;
                     ptr_in[ 1 ][ point ] = y1 + grad[ 2 ] * (double) ix;

/* Also calculate final pixel offsets into the output array. */
                     offset[ point ] = off1 + ix;
                     point++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               accum = astMalloc( sizeof( double ) *
                                 (size_t) ( ndim_in * ndim_out ) );
               dim = astMalloc( sizeof( int ) * (size_t) ndim_out );
               if ( astOK ) {

/* Initialise an array of pixel indices for the output grid which
   refer to the first pixel for which we require a value. Also
   calculate the offset of this pixel within the output array. */
                  off = 0;
                  for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                     dim[ coord_out ] = lbnd[ coord_out ];
                     off += stride[ coord_out ] *
                            ( dim[ coord_out ] - lbnd_out[ coord_out ] );
                  }

/* To calculate each input grid coordinate we must perform a matrix
   multiply on the output grid coordinates (using the gradient matrix)
   and then add the zero points. However, since we will usually only
   be altering one output coordinate at a time (the least
   significant), we can avoid the full matrix multiply by accumulating
   partial sums for the most significant output coordinates and only
   altering those sums which need to change each time. The zero points
   never change, so we first fill the "most significant" end of the
   "accum" array with these. */
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     accum[ ( coord_in + 1 ) * ndim_out - 1 ] =
                                                              zero[ coord_in ];
                  }
                  coord_out = ndim_out - 1;

/* Now loop to process each output pixel. */
                  for ( done = 0; !done; point++ ) {

/* To generate the input coordinate that corresponds to the current
   output pixel, we work down from the most significant dimension
   whose index has changed since the previous pixel we considered
   (given by "coord_out"). For each affected dimension, we accumulate
   in "accum" the matrix sum (including the zero point) for that
   dimension and all higher output dimensions. We must accumulate a
   separate set of sums for each input coordinate we wish to
   produce. (Note that for the first pixel we process, all dimensions
   are considered "changed", so we start by initialising the whole
   "accum" array.) */
                     for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                        i1 = coord_in * ndim_out;
                        for ( idim = coord_out; idim >= 1; idim-- ) {
                           i2 = i1 + idim;
                           accum[ i2 - 1 ] = accum[ i2 ] +
                                             dim[ idim ] * grad[ i2 ];
                        }

/* The input coordinate for each dimension is given by the accumulated
   sum for output dimension zero (giving the sum over all output
   dimensions). We do not store this in the "accum" array, but assign
   the result directly to the coordinate array of the PointSet created
   earlier. */
                        ptr_in[ coord_in ][ point ] = accum[ i1 ] +
                                                      dim[ 0 ] * grad[ i1 ];
                     }

/* Store the offset of the current pixel in the output array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next output
   pixel. */
                     coord_out = 0;
                     do {

/* The least significant index which currently has less than its
   maximum value is incremented by one. The offset into the output
   array is updated accordingly. */
                        if ( dim[ coord_out ] < ubnd[ coord_out ] ) {
                           dim[ coord_out ]++;
                           off += stride[ coord_out ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the output pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_out ] = lbnd[ coord_out ];
                           off -= stride[ coord_out ] *
                                  ( ubnd[ coord_out ] - lbnd[ coord_out ] );

/* All the output pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_out == ndim_out );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               accum = astFree( accum );
               dim = astFree( dim );
            }
         }

/* No linear fit to the Mapping is available. */
/* ========================================== */
      } else {

/* If flux conseravtion was requested, report an error, since we can only
   conserve flux if a linear approximation is available. */
         if( conserve && astOK ) {
            astError( AST__CNFLX, "astResampleSection(%s): Flux conservation "
                "was requested but cannot be performed because either the Mapping "
                "is too non-linear, or the requested tolerance is too small.", status,
                 astGetClass( this ) );
         }

/* Create a PointSet to hold the coordinates of the output pixels and
   obtain a pointer to its coordinate data. */
         pset_out = astPointSet( npoint, ndim_out, "", status );
         ptr_out = astGetPoints( pset_out );
         if ( astOK ) {

/* Initialise the count of output points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ndim_out == 1 && ndim_in == 1 ) {

/* Loop through the required range of output x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   pixel offset into the output array. */
               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_out[ 0 ][ point ] = (double) ix;
                  offset[ point ] = ix - lbnd_out[ 0 ];

/* Increment the count of output pixels. */
                  point++;
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ndim_out == 2 && ndim_in == 2 ) {

/* Loop through the required range of output y coordinates,
   calculating an interim pixel offset into the output array. */
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  off1 = stride[ 1 ] * ( iy - lbnd_out[ 1 ] ) - lbnd_out[ 0 ];

/* Loop through the required range of output x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   final pixel offset into the output array. */
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_out[ 0 ][ point ] = (double) ix;
                     ptr_out[ 1 ][ point ] = (double) iy;
                     offset[ point ] = off1 + ix;

/* Increment the count of output pixels. */
                     point++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               dim = astMalloc( sizeof( int ) * (size_t) ndim_out );
               if ( astOK ) {

/* Initialise an array of pixel indices for the output grid which
   refer to the first pixel for which we require a value. Also
   calculate the offset of this pixel within the output array. */
                  off = 0;
                  for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                     dim[ coord_out ] = lbnd[ coord_out ];
                     off += stride[ coord_out ] *
                            ( dim[ coord_out ] - lbnd_out[ coord_out ] );
                  }

/* Loop to generate the coordinates of each output pixel. */
                  for ( done = 0; !done; point++ ) {

/* Copy each pixel's coordinates into the PointSet created above. */
                     for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                        ptr_out[ coord_out ][ point ] =
                                                     (double) dim[ coord_out ];
                     }

/* Store the offset of the pixel in the output array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next output
   pixel. */
                     coord_out = 0;
                     do {

/* The least significant index which currently has less than its
   maximum value is incremented by one. The offset into the output
   array is updated accordingly. */
                        if ( dim[ coord_out ] < ubnd[ coord_out ] ) {
                           dim[ coord_out ]++;
                           off += stride[ coord_out ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the output pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_out ] = lbnd[ coord_out ];
                           off -= stride[ coord_out ] *
                                  ( ubnd[ coord_out ] - lbnd[ coord_out ] );

/* All the output pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_out == ndim_out );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               dim = astFree( dim );
            }

/* When all the output pixel coordinates have been generated, use the
   Mapping's inverse transformation to generate the input coordinates
   from them. Obtain an array of pointers to the resulting coordinate
   data. */
            pset_in = astTransform( this, pset_out, 0, NULL );
            ptr_in = astGetPoints( pset_in );
         }

/* Annul the PointSet containing the output coordinates. */
         pset_out = astAnnul( pset_out );
      }
   }

/* Resample the input grid. */
/* ------------------------ */
/* Determine if a variance array is to be processed. */
   usevar = ( in_var && out_var );

/* If the input coordinates have been produced successfully, identify
   the input grid resampling method to be used. */
   if ( astOK ) {

/* Nearest pixel. */
/* -------------- */
      switch ( interp ) {
         case AST__NEAREST:

/* Define a macro to use a "case" statement to invoke the
   nearest-pixel interpolation function appropriate to a given data
   type. */
#define CASE_NEAREST(X,Xtype) \
               case ( TYPE_##X ): \
                  result = \
                  InterpolateNearest##X( ndim_in, lbnd_in, ubnd_in, \
                                         (Xtype *) in, (Xtype *) in_var, \
                                         npoint, offset, \
                                         (const double *const *) ptr_in, \
                                         flags, *( (Xtype *) badval_ptr ), \
                                         (Xtype *) out, (Xtype *) out_var, status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_NEAREST(LD,long double)
#endif
               CASE_NEAREST(D,double)
               CASE_NEAREST(F,float)
               CASE_NEAREST(L,long int)
               CASE_NEAREST(UL,unsigned long int)
               CASE_NEAREST(K,INT_BIG)
               CASE_NEAREST(UK,UINT_BIG)
               CASE_NEAREST(I,int)
               CASE_NEAREST(UI,unsigned int)
               CASE_NEAREST(S,short int)
               CASE_NEAREST(US,unsigned short int)
               CASE_NEAREST(B,signed char)
               CASE_NEAREST(UB,unsigned char)
            }
            break;

/* Undefine the macro. */
#undef CASE_NEAREST

/* Linear interpolation. */
/* --------------------- */
/* Note this is also the default if zero is given. */
         case AST__LINEAR:
         case 0:

/* Define a macro to use a "case" statement to invoke the linear
   interpolation function appropriate to a given data type. */
#define CASE_LINEAR(X,Xtype) \
               case ( TYPE_##X ): \
                  result = \
                  InterpolateLinear##X( ndim_in, lbnd_in, ubnd_in,\
                                        (Xtype *) in, (Xtype *) in_var, \
                                        npoint, offset, \
                                        (const double *const *) ptr_in, \
                                        flags, *( (Xtype *) badval_ptr ), \
                                        (Xtype *) out, (Xtype *) out_var, status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_LINEAR(LD,long double)
#endif
               CASE_LINEAR(D,double)
               CASE_LINEAR(F,float)
               CASE_LINEAR(L,long int)
               CASE_LINEAR(UL,unsigned long int)
               CASE_LINEAR(K,INT_BIG)
               CASE_LINEAR(UK,UINT_BIG)
               CASE_LINEAR(I,int)
               CASE_LINEAR(UI,unsigned int)
               CASE_LINEAR(S,short int)
               CASE_LINEAR(US,unsigned short int)
               CASE_LINEAR(B,signed char)
               CASE_LINEAR(UB,unsigned char)
            }
            break;

/* Undefine the macro. */
#undef CASE_LINEAR

/* Interpolation using a 1-d kernel. */
/* --------------------------------- */
         case AST__GAUSS:
         case AST__SINC:
         case AST__SINCCOS:
         case AST__SINCGAUSS:
         case AST__SINCSINC:
         case AST__SOMB:
         case AST__SOMBCOS:
         case AST__UKERN1:       /* User-supplied 1-d kernel function */

/* Obtain a pointer to the appropriate 1-d kernel function (either
   internal or user-defined) and set up any parameters it may
   require. */
            par = NULL;
            switch ( interp ) {

/* sinc(pi*x) interpolation. */
/* ------------------------- */
/* Assign the kernel function. */
               case AST__SINC:
                  kernel = Sinc;

/* Calculate the number of neighbouring pixels to use. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) {
                     neighb = 2;
                  } else {
                     neighb = MaxI( 1, neighb, status );
                  }
                  break;

/* sinc(pi*x)*cos(k*pi*x) interpolation. */
/* ------------------------------------- */
/* Assign the kernel function. */
               case AST__SINCCOS:
                  kernel = SincCos;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;

/* somb(pi*x) interpolation. */
/* ------------------------- */
/* Assign the kernel function. */
               case AST__SOMB:
                  kernel = Somb;

/* Calculate the number of neighbouring pixels to use. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) {
                     neighb = 2;
                  } else {
                     neighb = MaxI( 1, neighb, status );
                  }
                  break;

/* somb(pi*x)*cos(k*pi*x) interpolation. */
/* ------------------------------------- */
/* Assign the kernel function. */
               case AST__SOMBCOS:
                  kernel = SombCos;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;

/* sinc(pi*x)*exp(-k*x*x) interpolation. */
/* ------------------------------------- */
/* Assign the kernel function. */
               case AST__SINCGAUSS:
                  kernel = SincGauss;

/* Constrain the full width half maximum of the gaussian factor. */
                  fwhm = MaxD( 0.1, params[ 1 ], status );

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 4.0 * log( 2.0 ) / ( fwhm * fwhm );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, use the number of neighbouring pixels required by the width
   of the kernel (out to where the gaussian term falls to 1% of its
   peak value). */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = (int) ceil( sqrt( -log( 0.01 ) /
                                                                lpar[ 0 ] ) );
                  break;

/* exp(-k*x*x) interpolation. */
/* -------------------------- */
/* Assign the kernel function. */
               case AST__GAUSS:
                  kernel = Gauss;

/* Constrain the full width half maximum of the gaussian. */
                  fwhm = MaxD( 0.1, params[ 1 ], status );

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 4.0 * log( 2.0 ) / ( fwhm * fwhm );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, use the number of neighbouring pixels required by the width
   of the kernel (out to where the gaussian term falls to 1% of its
   peak value). */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = (int) ceil( sqrt( -log( 0.01 ) /
                                                                lpar[ 0 ] ) );
                  break;

/* sinc(pi*x)*sinc(k*pi*x) interpolation. */
/* -------------------------------------- */
/* Assign the kernel function. */
               case AST__SINCSINC:
                  kernel = SincSinc;

/* Store the required value of "k" in a local parameter array and pass
   this array to the kernel function. */
                  lpar[ 0 ] = 0.5 / MaxD( 1.0, params[ 1 ], status );
                  par = lpar;

/* Obtain the number of neighbouring pixels to use. If this is zero or
   less, the number will be calculated automatically below. */
                  neighb = (int) floor( params[ 0 ] + 0.5 );
                  if ( neighb <= 0 ) neighb = INT_MAX;

/* Calculate the maximum number of neighbouring pixels required by the
   width of the kernel, and use this value if preferable. */
                  neighb = MinI( neighb,
                                 (int) ceil( MaxD( 1.0, params[ 1 ], status ) ), status );
                  break;

/* User-supplied kernel. */
/* --------------------- */
/* Assign the kernel function. */
               case AST__UKERN1:
                  fkernel = (void (*)( double, const double [],
                                       int, double * )) finterp;

/* Calculate the number of neighbouring pixels to use. */
                  neighb = MaxI( 1, (int) floor( params[ 0 ] + 0.5 ), status );

/* Pass a pointer to the "params" array. */
                  par = params;
                  break;
            }

/* Define a macro to use a "case" statement to invoke the 1-d kernel
   interpolation function appropriate to a given data type, passing it
   the pointer to the kernel function obtained above. */
#define CASE_KERNEL1(X,Xtype) \
               case ( TYPE_##X ): \
                  result = \
                  InterpolateKernel1##X( this, ndim_in, lbnd_in, ubnd_in, \
                                         (Xtype *) in, (Xtype *) in_var, \
                                         npoint, offset, \
                                         (const double *const *) ptr_in, \
                                         kernel, fkernel, neighb, par, flags, \
                                         *( (Xtype *) badval_ptr ), \
                                         (Xtype *) out, (Xtype *) out_var, status ); \
                  break;

/* Use the above macro to invoke the appropriate function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_KERNEL1(LD,long double)
#endif
               CASE_KERNEL1(D,double)
               CASE_KERNEL1(F,float)
               CASE_KERNEL1(L,long int)
               CASE_KERNEL1(UL,unsigned long int)
               CASE_KERNEL1(K,INT_BIG)
               CASE_KERNEL1(UK,UINT_BIG)
               CASE_KERNEL1(I,int)
               CASE_KERNEL1(UI,unsigned int)
               CASE_KERNEL1(S,short int)
               CASE_KERNEL1(US,unsigned short int)
               CASE_KERNEL1(B,signed char)
               CASE_KERNEL1(UB,unsigned char)
            }
            break;

/* Undefine the macro. */
#undef CASE_KERNEL1

/* General sub-pixel interpolation function. */
/* ----------------------------------------- */
         case AST__BLOCKAVE:
         case AST__UINTERP:

/* Define a macro to use a "case" statement to invoke the general
   sub-pixel interpolation function appropriate to a given type and
   the selected value of the interp variable. */
#define CASE_GINTERP(X,Xtype) \
               case ( TYPE_##X ): \
\
/* Obtain a pointer to the appropriate general interpolation function \
   (either internal or user-defined) and set up any parameters it may \
   require. */ \
                  switch ( interp ) { \
\
/* Block averaging interpolation. */ \
/* ------------------------------ */ \
                     case AST__BLOCKAVE: \
                        gifunc = (void (*)( void )) InterpolateBlockAverage##X; \
                        break; \
\
/* User-supplied sub-pixel interpolation function. */ \
/* ----------------------------------------------- */ \
                     case AST__UINTERP: \
                        gifunc = (void (*)( void )) finterp; \
                        break; \
                  } \
\
/* Invoke the general interpolation function.  It has to be cast to the \
   right type (i.e. a function with the correctly typed arguments) \
   to prevent default promotion (to int or double) of its arguments. \
   The cast here corresponds to the declaration of
   ast_resample_uinterp##Xtype. */ \
                  ( *( (void (*)( int, const int[], const int[], \
                                  const Xtype[], \
                                  const Xtype[], \
                                  int, const int[], \
                                  const double *const[], \
                                  const double[], int, \
                                  Xtype, \
                                  Xtype *, \
                                  Xtype *, \
                                  int * )) \
                       gifunc ) )( ndim_in, lbnd_in, ubnd_in, \
                                   (Xtype *) in, \
                                   (Xtype *) ( usevar ? in_var : NULL ), \
                                   npoint, offset, \
                                   (const double *const *) ptr_in, \
                                   params, flags, \
                                   *( (Xtype *) badval_ptr ), \
                                   (Xtype *) out, \
                                   (Xtype *) ( usevar ? out_var : NULL ), \
                                   &nbad ); \
                  if ( astOK ) { \
                     result += nbad; \
                  } else { \
                     astError( astStatus, "astResample"#X"(%s): Error " \
                               "signalled by user-supplied sub-pixel " \
                               "interpolation function.", status, \
                               astGetClass( unsimplified_mapping ) ); \
                  } \
                  break;

/* Use the above macro to invoke the function. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_GINTERP(LD,long double)
#endif
               CASE_GINTERP(D,double)
               CASE_GINTERP(F,float)
               CASE_GINTERP(L,long int)
               CASE_GINTERP(UL,unsigned long int)
               CASE_GINTERP(K,INT_BIG)
               CASE_GINTERP(UK,UINT_BIG)
               CASE_GINTERP(I,int)
               CASE_GINTERP(UI,unsigned int)
               CASE_GINTERP(S,short int)
               CASE_GINTERP(US,unsigned short int)
               CASE_GINTERP(B,signed char)
               CASE_GINTERP(UB,unsigned char)
            }
            break;

/* Undefine the macro. */
#undef CASE_GINTERP

/* Error: invalid interpolation scheme specified. */
/* ---------------------------------------------- */
         default:

/* Define a macro to report an error message appropriate to a given
   data type. */
#define CASE_ERROR(X) \
            case TYPE_##X: \
               astError( AST__SISIN, "astResample"#X"(%s): Invalid " \
                         "sub-pixel interpolation scheme (%d) specified.", status, \
                         astGetClass( unsimplified_mapping ), interp ); \
               break;

/* Use the above macro to report an appropriate error message. */
            switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
               CASE_ERROR(LD)
#endif
               CASE_ERROR(D)
               CASE_ERROR(F)
               CASE_ERROR(L)
               CASE_ERROR(UL)
               CASE_ERROR(K)
               CASE_ERROR(UK)
               CASE_ERROR(I)
               CASE_ERROR(UI)
               CASE_ERROR(S)
               CASE_ERROR(US)
               CASE_ERROR(B)
               CASE_ERROR(UB)
            }
            break;

/* Undefine the macro. */
#undef CASE_ERROR
      }
   }

/* Now scale the output values to conserve flux if required. */
   if( conserve ) {

/* Define a macro to use a "case" statement to invoke the function
   appropriate to a given data type. These simply multiple the output data
   value by the factor, and the output variance by the square of the
   factor. */
#define CASE_CONSERVE(X,Xtype) \
      case ( TYPE_##X ): \
         ConserveFlux##X( factor, npoint, offset, *( (Xtype *) badval_ptr ), \
                          (Xtype *) out, \
                          (Xtype *) ( usevar ? out_var : NULL ), status ); \
         break;

/* Use the above macro to invoke the appropriate function. */
      switch ( type ) {
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
         CASE_CONSERVE(LD,long double)
#endif
         CASE_CONSERVE(D,double)
         CASE_CONSERVE(F,float)
         CASE_CONSERVE(L,long int)
         CASE_CONSERVE(UL,unsigned long int)
         CASE_CONSERVE(K,INT_BIG)
         CASE_CONSERVE(UK,UINT_BIG)
         CASE_CONSERVE(I,int)
         CASE_CONSERVE(UI,unsigned int)
         CASE_CONSERVE(S,short int)
         CASE_CONSERVE(US,unsigned short int)
         CASE_CONSERVE(B,signed char)
         CASE_CONSERVE(UB,unsigned char)
      }

/* Undefine the macro. */
#undef CASE_CONSERVE
   }

/* Annul the PointSet used to hold input coordinates. */
   pset_in = astAnnul( pset_in );

/* Free the workspace. */
   offset = astFree( offset );
   stride = astFree( stride );

/* If an error occurred, clear the returned value. */
   if ( !astOK ) result = 0;

/* Return the result. */
   return result;
}

static int ResampleWithBlocking( AstMapping *this, const double *linear_fit,
                                 int ndim_in,
                                 const int *lbnd_in, const int *ubnd_in,
                                 const void *in, const void *in_var,
                                 DataType type, int interp, void (* finterp)( void ),
                                 const double *params, int flags,
                                 const void *badval_ptr, int ndim_out,
                                 const int *lbnd_out, const int *ubnd_out,
                                 const int *lbnd, const int *ubnd,
                                 void *out, void *out_var, int *status ) {
/*
*  Name:
*     ResampleWithBlocking

*  Purpose:
*     Resample a section of a data grid in a memory-efficient way.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int ResampleWithBlocking( AstMapping *this, const double *linear_fit,
*                               int ndim_in,
*                               const int *lbnd_in, const int *ubnd_in,
*                               const void *in, const void *in_var,
*                               DataType type, int interp, void (* finterp)( void ),
*                               const double *params, int flags,
*                               const void *badval_ptr, int ndim_out,
*                               const int *lbnd_out, const int *ubnd_out,
*                               const int *lbnd, const int *ubnd,
*                               void *out, void *out_var, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function resamples a rectangular grid of data (with any
*     number of dimensions) into a specified section of another
*     rectangular grid (with a possibly different number of
*     dimensions). The coordinate transformation used is given by the
*     inverse transformation of the Mapping which is supplied or,
*     alternatively, by a linear approximation fitted to a Mapping's
*     inverse transformation. Any pixel interpolation scheme may be
*     specified for interpolating between the pixels of the input
*     grid.
*
*     This function is very similar to ResampleSection, except that in
*     order to limit memory usage and to ensure locality of reference,
*     it divides the output grid up into "blocks" which have a limited
*     extent along each output dimension. Each block, which will not
*     contain more than a pre-determined maximum number of pixels, is
*     then passed to ResampleSection for resampling.

*  Parameters:
*     this
*        Pointer to a Mapping, whose inverse transformation may be
*        used to transform the coordinates of pixels in the output
*        grid into associated positions in the input grid, from which
*        the output pixel values should be derived (by interpolation
*        if necessary).
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's inverse coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        inverse transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     in
*        Pointer to the input array of data to be resampled (with one
*        element for each pixel in the input grid). The numerical type
*        of these data should match the "type" value (below). The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and data type as the "in" array),
*        which represent estimates of the statistical variance
*        associated with each element of the "in" array. If this
*        second array is given (along with the corresponding "out_var"
*        array), then estimates of the variance of the resampled data
*        will also be returned.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     type
*        A value taken from the "DataType" enum, which specifies the
*        data type of the input and output arrays containing the
*        gridded data (and variance) values.
*     interp
*        A value selected from a set of pre-defined macros to identify
*        which sub-pixel interpolation algorithm should be used.
*     finterp
*        If "interp" is set to a value which requires a user-supplied
*        function, then a pointer to that function shoild be given
*        here. Otherwise, this value is not used and may be a NULL
*        pointer.
*     params
*        Pointer to an optional array of parameters that may be passed
*        to the interpolation algorithm, if required. If no parameters
*        are required, a NULL pointer should be supplied.
*     flags
*        The bitwise OR of a set of flag values which provide
*        additional control over the resampling operation.
*     badval_ptr
*        If the AST__USEBAD flag is set (above), this parameter is a
*        pointer to a value which is used to identify bad data and/or
*        variance values in the input array(s). The referenced value's
*        data type must match that of the "in" (and "in_var")
*        arrays. Unless the AST__NOBAD flag is set, the same value will
*        also be used to flag any output array elements for which
*        resampled values could not be obtained.  The output arrays(s)
*        may be flagged with this value whether or not the AST__USEBAD
*        flag is set (the function return value indicates whether any
*        such values have been produced).
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output data grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output data grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output data grid in the same way as "lbnd_in"
*        and "ubnd_in" define the shape and size of the input grid
*        (see above).
*     lbnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the first pixel in the
*        section of the output data grid for which a value is
*        required.
*     ubnd
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the last pixel in the
*        section of the output data grid for which a value is
*        required.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the output grid for which resampled values are
*        required. This section should lie wholly within the extent of
*        the output grid (as defined by the "lbnd_out" and "ubnd_out"
*        arrays). Regions of the output grid lying outside this section
*        will not be modified.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the resampled data will be returned.  The
*        storage order should be such that the coordinate of the first
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order is used).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the resampled values may be returned. This array will only be
*        used if the "in_var" array has been given.
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The number of output grid points for which no valid output value
*     could be obtained.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Constants: */
   const int mxpix = 2 * 1024;   /* Maximum number of pixels in a block (this
                                    relatively small number seems to give best
                                    performance) */

/* Local Variables: */
   double factor;                /* Flux conservation factor */
   int *dim_block;               /* Pointer to array of block dimensions */
   int *lbnd_block;              /* Pointer to block lower bound array */
   int *ubnd_block;              /* Pointer to block upper bound array */
   int dim;                      /* Dimension size */
   int done;                     /* All blocks resampled? */
   int hilim;                    /* Upper limit on maximum block dimension */
   int idim;                     /* Loop counter for dimensions */
   int lolim;                    /* Lower limit on maximum block dimension */
   int mxdim_block;              /* Maximum block dimension */
   int npix;                     /* Number of pixels in block */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Allocate workspace. */
   lbnd_block = astMalloc( sizeof( int ) * (size_t) ndim_out );
   ubnd_block = astMalloc( sizeof( int ) * (size_t) ndim_out );
   dim_block = astMalloc( sizeof( int ) * (size_t) ndim_out );
   if ( astOK ) {

/* Find the optimum block size. */
/* ---------------------------- */
/* We first need to find the maximum extent which a block of output
   pixels may have in each dimension. We determine this by taking the
   output grid extent in each dimension and then limiting the maximum
   dimension size until the resulting number of pixels is sufficiently
   small. This approach allows the block shape to approximate (or
   match) the output grid shape when appropriate. */

/* First loop to calculate the total number of output pixels and the
   maximum output dimension size. */
      npix = 1;
      mxdim_block = 0;
      for ( idim = 0; idim < ndim_out; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         npix *= dim;
         if ( mxdim_block < dim ) mxdim_block = dim;
      }

/* If the number of output pixels is too large for a single block, we
   perform iterations to determine the optimum upper limit on a
   block's dimension size. Initialise the limits on this result. */
      if ( npix > mxpix ) {
         lolim = 1;
         hilim = mxdim_block;

/* Loop to perform a binary chop, searching for the best result until
   the lower and upper limits on the result converge to adjacent
   values. */
         while ( ( hilim - lolim ) > 1 ) {

/* Form a new estimate from the mid-point of the previous limits. */
            mxdim_block = ( hilim + lolim ) / 2;

/* See how many pixels a block contains if its maximum dimension is
   limited to this new value. */
            for ( npix = 1, idim = 0; idim < ndim_out ; idim++ ) {
               dim = ubnd[ idim ] - lbnd[ idim ] + 1;
               npix *= ( dim < mxdim_block ) ? dim : mxdim_block;
            }

/* Update the appropriate limit, according to whether the number of
   pixels is too large or too small. */
            *( ( npix <= mxpix ) ? &lolim : &hilim ) = mxdim_block;
         }

/* When iterations have converged, obtain the maximum limit on the
   dimension size of a block which results in no more than the maximum
   allowed number of pixels per block. However, ensure that all block
   dimensions are at least 2. */
            mxdim_block = lolim;
      }
      if ( mxdim_block < 2 ) mxdim_block = 2;

/* Calculate the block dimensions by applying this limit to the output
   grid dimensions. */
      for ( idim = 0; idim < ndim_out ; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         dim_block[ idim ] = ( dim < mxdim_block ) ? dim : mxdim_block;

/* Also initialise the lower and upper bounds of the first block of
   output grid pixels to be resampled, ensuring that this does not
   extend outside the grid itself. */
         lbnd_block[ idim ] = lbnd[ idim ];
         ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                    ubnd[ idim ], status );
      }

/* Determine the flux conservation constant if needed. */
/* --------------------------------------------------- */
   if( ( flags & AST__CONSERVEFLUX ) && linear_fit ) {
      factor = MatrixDet( ndim_in, ndim_out, linear_fit + ndim_in, status );
   } else {
      factor = 1.0;
   }

/* Resample each block of output pixels. */
/* ------------------------------------- */
/* Loop to generate the extent of each block of output pixels and to
   resample them. */
      done = 0;
      while ( !done && astOK ) {

/* Resample the current block, accumulating the sum of bad pixels
   produced. */
         result += ResampleSection( this, linear_fit,
                                    ndim_in, lbnd_in, ubnd_in,
                                    in, in_var, type, interp, finterp, params,
                                    factor, flags, badval_ptr,
                                    ndim_out, lbnd_out, ubnd_out,
                                    lbnd_block, ubnd_block, out, out_var, status );

/* Update the block extent to identify the next block of output
   pixels. */
         idim = 0;
         do {

/* We find the least significant dimension where the upper bound of
   the block has not yet reached the upper bound of the region of the
   output grid which we are resampling. The block's position is then
   incremented by one block extent along this dimension, checking that
   the resulting extent does not go outside the region being
   resampled. */
            if ( ubnd_block[ idim ] < ubnd[ idim ] ) {
               lbnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ], ubnd[ idim ], status );
               ubnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );
               break;

/* If any less significant dimensions are found where the upper bound
   of the block has reached its maximum value, we reset the block to
   its lowest position. */
            } else {
               lbnd_block[ idim ] = lbnd[ idim ];
               ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );

/* All the blocks have been processed once the position along the most
   significant dimension has been reset. */
               done = ( ++idim == ndim_out );
            }
         } while ( !done );
      }
   }

/* Free the workspace. */
   lbnd_block = astFree( lbnd_block );
   ubnd_block = astFree( ubnd_block );
   dim_block = astFree( dim_block );

/* If an error occurred, clear the returned value. */
   if ( !astOK ) result = 0;

/* Return the result. */
   return result;
}

static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
/*
*  Name:
*     SetAttrib

*  Purpose:
*     Set an attribute value for a Mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SetAttrib( AstObject *this, const char *setting )

*  Class Membership:
*     Mapping member function (over-rides the astSetAttrib protected
*     method inherited from the Object class).

*  Description:
*     This function assigns an attribute value for a Mapping, the
*     attribute and its value being specified by means of a string of
*     the form:
*
*        "attribute= value "
*
*     Here, "attribute" specifies the attribute name and should be in
*     lower case with no white space present. The value to the right
*     of the "=" should be a suitable textual representation of the
*     value to be assigned and this will be interpreted according to
*     the attribute's data type.  White space surrounding the value is
*     only significant for string attributes.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     setting
*        Pointer to a null terminated string specifying the new attribute
*        value.
*/

/* Local Variables: */
   AstMapping *this;             /* Pointer to the Mapping structure */
   int invert;                   /* Invert attribute value */
   int len;                      /* Length of setting string */
   int nc;                       /* Number of characters read by astSscanf */
   int report;                   /* Report attribute value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Mapping structure. */
   this = (AstMapping *) this_object;

/* Obtain the length of the setting string. */
   len = (int) strlen( setting );

/* Test for each recognised attribute in turn, using "astSscanf" to parse
   the setting string and extract the attribute value (or an offset to
   it in the case of string values). In each case, use the value set
   in "nc" to check that the entire string was matched. Once a value
   has been obtained, use the appropriate method to set it. */

/* Invert. */
/* ------- */
   if ( nc = 0,
        ( 1 == astSscanf( setting, "invert= %d %n", &invert, &nc ) )
        && ( nc >= len ) ) {
      astSetInvert( this, invert );

/* Report. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "report= %d %n", &report, &nc ) )
        && ( nc >= len ) ) {
      astSetReport( this, report );

/* Define a macro to see if the setting string matches any of the
   read-only attributes of this class. */
#define MATCH(attrib) \
        ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
                  ( nc >= len ) )

/* If the attribute was not recognised, use this macro to report an error
   if a read-only attribute has been specified. */
   } else if ( MATCH( "nin" ) ||
        MATCH( "nout" ) ||
        MATCH( "islinear" ) ||
        MATCH( "issimple" ) ||
        MATCH( "tranforward" ) ||
        MATCH( "traninverse" ) ) {
      astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
                setting, astGetClass( this ) );
      astError( AST__NOWRT, "This is a read-only attribute." , status);

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_setattrib)( this_object, setting, status );
   }

/* Undefine macros local to this function. */
#undef MATCH
}

static void Sinc( double offset, const double params[], int flags,
                  double *value, int *status ) {
/*
*  Name:
*     Sinc

*  Purpose:
*     1-dimensional sinc(pi*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void Sinc( double offset, const double params[], int flags,
*                double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is sinc(pi*x), where
*     sinc(z)=sin(z)/z.

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        Not used.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise a local value for pi. Do this
   only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      init = 1;
   }

/* Scale the offset. */
   offset *= pi;

/* Evaluate the function. */
   *value = ( offset != 0.0 ) ? ( sin( offset ) / offset ) : 1.0;
}

static void SincCos( double offset, const double params[], int flags,
                     double *value, int *status ) {
/*
*  Name:
*     SincCos

*  Purpose:
*     1-dimensional sinc(pi*x)*cos(k*pi*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SincCos( double offset, const double params[], int flags,
*                   double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is sinc(pi*x)*cos(k*pi*x)
*     out to the point where cos(k*pi*x) = 0, and zero beyond. Here,
*     sinc(z)=sin(z)/z.

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        The first element of this array should give a value for "k"
*        in the cos(k*pi*x) term.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   double offset_k;              /* Scaled offset */
   static double halfpi;         /* Value of pi/2 */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise local values for pi and
   pi/2. Do this only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      halfpi = 0.5 * pi;
      init = 1;
   }

/* Multiply the offset by pi and remove its sign. */
   offset = pi * fabs( offset );

/* Find the offset scaled by the "k" factor. */
   offset_k = offset * params[ 0 ];

/* If the cos(k*pi*x) term has not reached zero, calculate the
   result. */
   if ( offset_k < halfpi ) {
      *value = ( ( offset != 0.0 ) ? ( sin( offset ) / offset ) : 1.0 ) *
               cos( offset_k );

/* Otherwise, the result is zero. */
   } else {
      *value = 0.0;
   }
}

static void SincGauss( double offset, const double params[], int flags,
                       double *value, int *status ) {
/*
*  Name:
*     SincGauss

*  Purpose:
*     1-dimensional sinc(pi*x)*exp(-k*x*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SincGauss( double offset, const double params[], int flags,
*                     double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is sinc(pi*x)*exp(-k*x*x),
*     where sinc(z)=sin(z)/z.

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        The first element of this array should give a value for "k"
*        in the exp(-k*x*x) term.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   double offset_pi;             /* Offset multiplied by pi */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise a local value for pi. Do this
   only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      init = 1;
   }

/* Find the offset scaled by pi. */
   offset_pi = pi * offset;

/* Calculate the result. */
   *value = ( ( offset_pi != 0.0 ) ? ( sin( offset_pi ) / offset_pi ) : 1.0 ) *
            exp( -params[ 0 ] * offset * offset );
}

static void SincSinc( double offset, const double params[], int flags,
                      double *value, int *status ) {
/*
*  Name:
*     SincSinc

*  Purpose:
*     1-dimensional sinc(pi*x)*sinc(k*pi*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SincSinc( double offset, const double params[], int flags,
*                    double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is sinc(pi*x)*sinc(k*pi*x),
*     out to the point where sinc(k*pi*x)=0, and zero beyond. Here,
*     sinc(z)=sin(z)/z.

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        The first element of this array should give a value for "k"
*        in the sinc(k*pi*x) term.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   double offset_k;              /* Scaled offset */
   static double halfpi;         /* Value of pi/2 */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise local values for pi and
   pi/2. Do this only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      halfpi = 0.5 * pi;
      init = 1;
   }

/* Multiply the offset by pi and remove its sign. */
   offset = pi * fabs( offset );

/* Find the offset scaled by the "k" factor. */
   offset_k = offset * params[ 0 ];

/* If the sinc(k*pi*x) term has not reached zero, calculate the
   result. */
   if ( offset_k < halfpi ) {
      *value = ( ( offset != 0.0 ) ? ( sin( offset ) / offset ) : 1.0 ) *
               ( ( offset_k != 0.0 ) ? ( sin( offset_k ) / offset_k ) : 1.0 );

/* Otherwise, the result is zero. */
   } else {
      *value = 0.0;
   }
}

static AstMapping *Simplify( AstMapping *this, int *status ) {
/*
*++
*  Name:
c     astSimplify
f     AST_SIMPLIFY

*  Purpose:
*     Simplify a Mapping.

*  Type:
*     Public function.

*  Synopsis:
c     #include "mapping.h"
c     AstMapping *astSimplify( AstMapping *this )
f     RESULT = AST_SIMPLIFY( THIS, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function simplifies a Mapping (which may be a compound
*     Mapping such as a CmpMap) to eliminate redundant computational
*     steps, or to merge separate steps which can be performed more
*     efficiently in a single operation.
*
*     As a simple example, a Mapping which multiplied coordinates by
*     5, and then multiplied the result by 10, could be simplified to
*     a single step which multiplied by 50. Similarly, a Mapping which
*     multiplied by 5, and then divided by 5, could be reduced to a
*     simple copying operation.
*
*     This function should typically be applied to Mappings which have
*     undergone substantial processing or have been formed by merging
*     other Mappings. It is of potential benefit, for example, in
*     reducing execution time if applied before using a Mapping to
*     transform a large number of coordinates.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the original Mapping.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astSimplify()
f     AST_SIMPLIFY = INTEGER
*        A new pointer to the (possibly simplified) Mapping.

*  Applicability:
*     Mapping
*        This function applies to all Mappings.
*     FrameSet
*        If the supplied Mapping is a FrameSet, the returned Mapping
*        will be a copy of the supplied FrameSet in which all the
*        inter-Frame Mappings have been simplified.

*  Notes:
*     - Mappings that have a set value for their Ident attribute are
*     left unchanged after simplification. This is so that their
*     individual identity is preserved. This restriction does not
*     apply to the simplification of Frames.
*     - This function can safely be applied even to Mappings which
*     cannot be simplified. If no simplification is possible, it
c     behaves exactly like astClone and returns a pointer to the
f     behaves exactly like AST_CLONE and returns a pointer to the
*     original Mapping.
*     - The Mapping returned by this function may not be independent
*     of the original (even if simplification was possible), and
*     modifying it may therefore result in indirect modification of
*     the original. If a completely independent result is required, a
c     copy should be made using astCopy.
f     copy should be made using AST_COPY.
*     - A null Object pointer (AST__NULL) will be returned if this
c     function is invoked with the AST error status set, or if it
f     function is invoked with STATUS set to an error value, or if it
*     should fail for any reason.
*--
*/

/* Local Variables: */
   AstMapping **map_list;        /* Pointer to array of Mapping pointers */
   AstMapping *map;              /* Cloned pointer to nominated Mapping */
   AstMapping *result;           /* Pointer to result Mapping */
   int *invert_list;             /* Pointer to array of invert flags */
   int imap;                     /* Loop counter for Mappings */
   int modified;                 /* Index of first modified element */
   int nmap;                     /* Number of Mappings */
   int simpler;                  /* Simplification achieved? */

/* Initialise. */
   result = NULL;

/* Check the inherited status. */
   if ( !astOK ) return result;

/* Initialise dynamic arrays of Mapping pointers and associated invert
   flags. */
   nmap = 0;
   map_list = NULL;
   invert_list = NULL;

/* Build a Mapping list to contain this Mapping (the list should only
   have 1 element). */
   astMapList( this, 1, astGetInvert( this ), &nmap, &map_list, &invert_list );

/* Pass the list repeatedly to the "astMapMerge" method for
   simplification. */
   simpler = 0;
   while ( astOK ) {
      map = astClone( map_list[ 0 ] );
      modified = astMapMerge( map, 0, 1, &nmap, &map_list, &invert_list );
      map = astAnnul( map );

/* Quit looping if the number of Mappings increases above 1, or if no
   further change occurs. Note if any simplification was achieved. */
      if ( ( nmap > 1 ) || ( modified < 0 ) ) break;
      simpler = 1;
   }

/* Check whether simplification has occurred. If not, simply clone the
   original Mapping pointer. This is what will normally happen for
   Mapping classes which inherit the default (null) "astMapMerge"
   method from this class and do not define one of their own. */
   if ( astOK ) {
      if ( !simpler || ( nmap > 1 ) ) {
         result = astClone( this );

/* If simplification occurred, test if the resulting Mapping has the
   Invert attribute value we want. If so, we can simply clone a
   pointer to it. */
      } else {
         if ( invert_list[ 0 ] == astGetInvert( map_list[ 0 ] ) ) {
            result = astClone( map_list[ 0 ] );

/* If not, we must make a copy. */
         } else {
            result = astCopy( map_list[ 0 ] );

/* Either clear the copy's Invert attribute, or set it to 1, as
   required. */
            if ( invert_list[ 0 ] ) {
               astSetInvert( result, 1 );
            } else {
               astClearInvert( result );
            }
         }
      }
   }

/* Loop to annul all the pointers in the Mapping list. */
   for ( imap = 0; imap < nmap; imap++ ) {
      map_list[ imap ] = astAnnul( map_list[ imap ] );
   }

/* Free the dynamic arrays. */
   map_list = astFree( map_list );
   invert_list = astFree( invert_list );

/* If an error occurred, annul the returned Mapping. */
   if ( !astOK ) result = astAnnul( result );

/* Return the result. */
   return result;
}

static void Somb( double offset, const double params[], int flags,
                  double *value, int *status ) {
/*
*  Name:
*     Somb

*  Purpose:
*     1-dimensional somb(pi*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void Somb( double offset, const double params[], int flags,
*                double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is somb(pi*x), where
*     somb(z)=2*J1(z)/z  (J1 is a Bessel function of the first kind of
*     order 1).

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        Not used.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise a local value for pi. Do this
   only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      init = 1;
   }

/* Scale the offset. */
   offset *= pi;

/* Evaluate the function. */
   *value = ( offset != 0.0 ) ? ( 2.0*J1Bessel( offset, status ) / offset ) : 1.0;
}

static void SombCos( double offset, const double params[], int flags,
                     double *value, int *status ) {
/*
*  Name:
*     SombCos

*  Purpose:
*     1-dimensional somb(pi*x)*cos(k*pi*x) interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SombCos( double offset, const double params[], int flags,
*                   double *value, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. The function used is somb(pi*x)*cos(k*pi*x)
*     out to the point where cos(k*pi*x) = 0, and zero beyond. Here,
*     somb(z)=2*J1(z)/z  (J1 is a Bessel function of the first kind of
*     order 1).

*  Parameters:
*     offset
*        The offset of a pixel from the interpolation point, measured
*        in pixels.
*     params
*        The first element of this array should give a value for "k"
*        in the cos(k*pi*x) term.
*     flags
*        Not used.
*     value
*        Pointer to a double to receive the calculated kernel value.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function does not perform error checking and does not
*     generate errors.
*/

/* Local Variables: */
   double offset_k;              /* Scaled offset */
   static double halfpi;         /* Value of pi/2 */
   static double pi;             /* Value of pi */
   static int init = 0;          /* Initialisation flag */

/* On the first invocation, initialise local values for pi and
   pi/2. Do this only once. */
   if ( !init ) {
      pi = acos( -1.0 );
      halfpi = 0.5 * pi;
      init = 1;
   }

/* Multiply the offset by pi and remove its sign. */
   offset = pi * fabs( offset );

/* Find the offset scaled by the "k" factor. */
   offset_k = offset * params[ 0 ];

/* If the cos(k*pi*x) term has not reached zero, calculate the
   result. */
   if ( offset_k < halfpi ) {
      *value = ( ( offset != 0.0 ) ? ( J1Bessel( offset, status ) / offset ) : 1.0 ) *
               cos( offset_k );

/* Otherwise, the result is zero. */
   } else {
      *value = 0.0;
   }
}

static int SpecialBounds( const MapData *mapdata, double *lbnd, double *ubnd,
                          double xl[], double xu[], int *status ) {
/*
*  Name:
*     SpecialBounds

*  Purpose:
*     Estimate coordinate bounds using special points.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int SpecialBounds( const MapData *mapdata, double *lbnd, double *ubnd,
*                        double xl[], double xu[], int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function makes a rough estimate of the lower and upper
*     bounds of a Mapping function over a constrained region of its
*     input coordinate space by transforming a set of special test
*     points. The points used lie at the corners of the constrained
*     region, at the centre of each of its faces, at its centroid, and
*     (if within the coordinate constraints) the origin.
*
*     In many practical cases, the true extrema may actually lie at
*     one or other of these points, in which case the true bounds will
*     be found. In other cases, this function only provides an
*     approximate limit on each bound (there is no way of telling if
*     this is the case, however). In either case, having these initial
*     estimates can speed subsequent searches to find the global
*     extrema as well as making that search more secure

*  Parameters:
*     mapdata
*        Pointer to a MapData structure describing the Mapping
*        function, its coordinate constraints, etc.
*     lbnd
*        Pointer to a double.  On entry, this should contain a
*        previously-obtained upper limit on the lower bound, or
*        AST__BAD if no such limit is available. On exit, it will be
*        updated with a new estimate of the lower bound, if a better
*        one has been found.
*     ubnd
*        Pointer to a double.  On entry, this should contain a
*        previously-obtained lower limit on the upper bound, or
*        AST__BAD if no such limit is available. On exit, it will be
*        updated with a new estimate of the upper bound, if a better
*        one has been found.
*     xl
*        Pointer to an array of double, with one element for each
*        input coordinate, in which to return the position of a (not
*        necessarily unique) input point at which the lower output
*        bound is reached. This array is not altered if an improved
*        estimate of the lower bound cannot be found.
*     xu
*        Pointer to an array of double, with one element for each
*        input coordinate, in which to return the position of a (not
*        necessarily unique) input point at which the upper output
*        bound is reached. This array is not altered if an improved
*        estimate of the upper bound cannot be found.
*     status
*        Pointer to the inherited status variable.

*  Returned:
*     A flag indicating if the returned values can be refined.

*/

/* Local Variables: */
   AstPointSet *pset_in;         /* PointSet for input coordinates */
   AstPointSet *pset_out;        /* PointSet for output coordinates */
   double **ptr_in;              /* Pointer to input coordinates */
   double **ptr_out;             /* Pointer to output coordinates */
   double *sxl;                  /* Secondary xl values */
   double *sxu;                  /* Secondary xu values */
   double f;                     /* Output coordinate value */
   double slbnd;                 /* Secondary lbnd value */
   double subnd;                 /* Secondary lbnd value */
   int *limit;                   /* Workspace for lower/upper limit flags */
   int bad;                      /* Output coordinate bad? */
   int coord;                    /* Loop counter for coordinates */
   int done;                     /* All corners done? */
   int face;                     /* Loop counter for faces */
   int ic;                       /* Index of corner */
   int icen;                     /* Index of centroid point */
   int ncorner;                  /* Number of corners */
   int ncoord;                   /* Number of input coordinates */
   int npoint;                   /* Number of points */
   int origin;                   /* Origin lies within bounds? */
   int point;                    /* Loop counter for points */
   int result;                   /* Returned flag */

/* Initialise */
   result = 1;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   pset_out = NULL;

/* Obtain the number of coordinate axes and calculate the number of
   points required in order to place one at every corner of the
   constrained region of the coordinate space. */
   ncoord = mapdata->nin;
   for ( npoint = 1, coord = 0; coord < ncoord; coord++ ) npoint *= 2;

/* Also include a second point at each corner,offset slightly from the
   corner towards the centroid */
   ncorner = npoint;
   npoint *= 2;

/* Also include placing one at the centre of every face and one at the
   centroid of the constrained coordinate space. */
   npoint += 2 * ncoord + 1;

/* Determine if the origin lies within the bounds. If so, include it
   as a further point. */
   origin = 1;
   for ( coord = 0; coord < ncoord; coord++ ) {
      if ( ( mapdata->lbnd[ coord ] > 0.0 ) ||
           ( mapdata->ubnd[ coord ] < 0.0 ) ) {
         origin = 0;
         break;
      }
   }
   if ( origin ) npoint++;

/* Initialise secondary bounds to be the supplied primary bounds */
   slbnd = *lbnd;
   subnd = *ubnd;

/* Create workspace for ssecondary xl xu values */
   sxl = astMalloc( sizeof(double)*(size_t) ncoord );
   sxu = astMalloc( sizeof(double)*(size_t) ncoord );

/* Create a PointSet to hold the coordinates and obtain a pointer to
   its coordinate values. Also allocate workspace for calculating the
   corner coordinates. */
   pset_in = astPointSet( npoint, ncoord, "", status );
   ptr_in = astGetPoints( pset_in );
   limit = astMalloc( sizeof( int ) * (size_t) ncoord );
   if ( astOK ) {

/* Initialise the workspace. */
      for ( coord = 0; coord < ncoord; coord++ ) limit[ coord ] = 0;

/* Loop to visit every corner. */
      point = 0;
      done = 0;
      do {

/* At each corner, translate the contents of the "limit" array
   (containing zeros and ones) into the lower or upper bound on the
   corresponding axis. This gives the coordinates of the corner, which
   we store in the input PointSet. */
         for ( coord = 0; coord < ncoord; coord++ ) {
            ptr_in[ coord ][ point ] = limit[ coord ] ?
                                       mapdata->ubnd[ coord ] :
                                       mapdata->lbnd[ coord ];
         }

/* Increment the count of points (i.e. corners). */
         point++;

/* Now update the limit array to identify the next corner. */
         coord = 0;
         do {

/* Flip the first zero found to become a one. This gives a new
   corner. */
            if ( !limit[ coord ] ) {
               limit[ coord ] = 1;
               break;

/* However, first flip any previous ones to become zeros and then
   examine the next element. We have processed all corners once the
   array is entirely filled with ones. */
            } else {
               limit[ coord ] = 0;
               done = ( ++coord == ncoord );
            }
         } while ( !done );
      } while ( !done );

/* Once the corners have been processed, loop to consider the centre
   of each face. */
      for ( face = 0; face < ( 2 * ncoord ); face++ ) {

/* First calculate the centroid value for each coordinate.  Then set
   one of these coordinates to the bound where the face lies. */
         for ( coord = 0; coord < ncoord; coord++ ) {
            ptr_in[ coord ][ point ] = 0.5 * ( mapdata->lbnd[ coord ] +
                                               mapdata->ubnd[ coord ] );
         }
         ptr_in[ face / 2 ][ point ] = ( face % 2 ) ?
                                       mapdata->lbnd[ face / 2 ] :
                                       mapdata->ubnd[ face / 2 ];

/* Increment the count of points. */
         point++;
      }

/* Place a point at the centroid of the constrained coordinate
   space. */
      for ( coord = 0; coord < ncoord; coord++ ) {
         ptr_in[ coord ][ point ] = 0.5 * ( mapdata->lbnd[ coord ] +
                                            mapdata->ubnd[ coord ] );
      }
      icen = point++;

/* Add a set of positions which are offset slightly from each corner
   towards the centroid. */
      for ( ic = 0; ic < ncorner; ic++ ) {
         for ( coord = 0; coord < ncoord; coord++ ) {
            ptr_in[ coord ][ point ] = 0.999*ptr_in[ coord ][ ic ] +
                                       0.001*ptr_in[ coord ][ icen ];
         }
         point++;
      }

/* Finally, add the origin, if it lies within the constraints. */
      if ( origin ) {
         for ( coord = 0; coord < ncoord; coord++ ) {
            ptr_in[ coord ][ point ] = 0.0;
         }
      }

/* Once all the input coordinates have been calculated, transform them
   and obtain a pointer to the resulting coordinate values. */
      pset_out = astTransform( mapdata->mapping, pset_in, mapdata->forward,
                               NULL );
      ptr_out = astGetPoints( pset_out );
      if ( astOK ) {

/* Loop through each point and test if any of its transformed
   coordinates is bad. */
         for ( point = 0; point < npoint; point++ ) {
            bad = 0;
            for ( coord = 0; coord < mapdata->nout; coord++ ) {
               if ( ptr_out[ coord ][ point ] == AST__BAD ) {
                  bad = 1;
                  break;
               }
            }

/* If so, we ignore the point. Otherwise, extract the required
   coordinate. */
            f = ptr_out[ mapdata->coord ][ point ];
            if ( !bad ) {

/* Use this to update the lower and upper bounds we are seeking. If
   either bound is updated, also store the coordinates of the
   corresponding input point. */
               if ( ( *lbnd == AST__BAD ) || ( f < *lbnd ) ) {
                  *lbnd = f;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xl[ coord ] = ptr_in[ coord ][ point ];
                  }
               }
               if ( ( *ubnd == AST__BAD ) || ( f > *ubnd ) ) {
                  *ubnd = f;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     xu[ coord ] = ptr_in[ coord ][ point ];
                  }
               }

/* If this point has a bad coord value, it may still be useful if the
   required coord value is not bad. In this case, extract the required
   coordinate. */
            } else if ( f != AST__BAD ) {

/* Use this to update secondary lower and upper bounds we are seeking.
   These will be returned if no primary values are found via the previous
   code block. */
               if ( ( slbnd == AST__BAD ) || ( f < slbnd ) ) {
                  slbnd = f;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     sxl[ coord ] = ptr_in[ coord ][ point ];
                  }
               }
               if ( ( subnd == AST__BAD ) || ( f > subnd ) ) {
                  subnd = f;
                  for ( coord = 0; coord < ncoord; coord++ ) {
                     sxu[ coord ] = ptr_in[ coord ][ point ];
                  }
               }
            }
         }

/* If no primary values could be found, use secondary values. */
         if( *lbnd == AST__BAD && *ubnd == AST__BAD ) {
            *lbnd = slbnd;
            *ubnd = subnd;
            for ( coord = 0; coord < ncoord; coord++ ) {
               xu[ coord ] = sxu[ coord ];
               xl[ coord ] = sxl[ coord ];
            }
            result = ( slbnd == AST__BAD || subnd == AST__BAD );
         }
      }
   }

/* Free workspace */
   sxl = astFree( sxl );
   sxu = astFree( sxu );

/* Annul the temporary PointSets and free the workspace. */
   pset_in = astAnnul( pset_in );
   pset_out = astAnnul( pset_out );
   limit = astFree( limit );

   return result;
}

/*
*  Name:
*     SpreadKernel1<X>

*  Purpose:
*     Rebin a data grid, using a 1-d interpolation kernel.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SpreadKernel1<X>( AstMapping *this, int ndim_out,
*                           const int *lbnd_out, const int *ubnd_out,
*                           const <Xtype> *in, const <Xtype> *in_var,
*                           double infac, int npoint, const int *offset,
*                           const double *const *coords,
*                           void (* kernel)( double, const double [], int,
*                                            double *, int * ),
*                           int neighb, const double *params, double conwgt,
*                           int flags, <Xtype> badval, int npix_out, <Xtype> *out,
*                           <Xtype> *out_var, double *work, int64_t *nused,
*                           int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which rebins a rectangular region of an
*     input grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each input
*     grid point may be mapped on to a position in the output grid in
*     an arbitrary way. The input and output grids may have any number
*     of dimensions, not necessarily equal.
*
*     Where the input positions given do not correspond with a pixel centre
*     in the output grid, the each input pixel value is spread out between the
*     surrounding output pixels using weights determined by a separable kernel
*     which is the product of a 1-dimensional kernel function evaluated along
*     each output dimension. A pointer should be supplied to the 1-dimensional
*     kernel function to be used.

*  Parameters:
*     this
*        Pointer to the Mapping being used in the rebinning operation
*        (this is only used for constructing error messages).
*     ndim_out
*        The number of dimensions in the output grid. This should be at
*        least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output grid, its extent along a particular
*        (i'th) dimension being ubnd_out[i]-lbnd_out[i]+1 (assuming "i"
*        is zero-based). They also define the output grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be rebinned. The numerical type
*        of these data should match the function used, as given by the
*        suffix on the function name. Note that details of how the input
*        grid maps on to this array (e.g. the storage order, number of
*        dimensions, etc.) is arbitrary and is specified entirely by means
*        of the "offset" array. The "in" array should therefore contain
*        sufficient elements to accommodate the "offset" values supplied.
*        There is no requirement that all elements of the "in" array
*        should be rebinned, and any which are not addressed by the
*        contents of the "offset" array will be ignored.
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned. It is addressed in exactly the same way (via the
*        "offset" array) as the "in" array.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     infac
*        A factor by which to multiply the input data values before use.
*     npoint
*        The number of input points which are to be rebinned.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each input point, this array should contain the zero-based
*        offset in the input array(s) (i.e. the "in" and, optionally,
*        the "in_var" arrays) from which the value to be rebinned should
*        be obtained.
*     coords
*        An array of pointers to double, with "ndim_out" elements.
*        Element "coords[coord]" should point at the first element of
*        an array of double (with "npoint" elements) which contains the
*        values of coordinate number "coord" for each point being
*        rebinned. The value of coordinate number "coord" for
*        rebinning point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices are
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding input data (and
*        variance) value will be ignored.
*     kernel
*        Pointer to the 1-dimensional kernel function to be used.
*     neighb
*        The number of neighbouring pixels in each dimension (on each
*        side of the interpolation position) which are to receive
*        contributions from the input pixel value. This value should be at
*        least 1.
*     params
*        Pointer to an optional array of parameter values to be passed
*        to the kernel function. If no parameters are required by this
*        function, then a NULL pointer may be supplied.
*     conwgt
*        The initial weight to use for all pixels (typically 1.0). Other
*        weights (e.g. interpolation weights, variance weights, etc) are
*        applied as factors to this initial value.
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function. These are chosend from:
*
*        - AST__USEBAD: indicates whether there are "bad" (i.e. missing) data
*        in the input array(s) which must be recognised.  If this flag is not
*        set, all input values are treated literally.
*        - AST__GENVAR: Indicates that output variances should be generated
*        from the spread of values contributing to each output pixel.
*        - AST__USEVAR: Indicates that output variances should be generated
*        by rebinning the input variances.
*        - AST__VARWGT: Indicates that input variances should be used to
*        create weights for the input data values.
*
*        Only one of AST__GENVAR and AST__USEVAR should be supplied.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which resampled values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     npix_out
*        Number of pixels in output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned. The
*        storage order should be such that the index of the first grid
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given. The values returned
*        are estimates of the statistical variance of the corresponding
*        values in the "out" array, on the assumption that all errors in
*        input grid values (in the "in" array) are statistically independent
*        and that their variance estimates (in the "in_var" array) may
*        simply be summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        A pointer to an array with the same data type and size as the "out"
*        array which is used as work space. The values in the supplied
*        array are incremented on exit by the sum of the weights used
*        with each output pixel.
*     nused
*        An optional pointer to a int64_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*/
/* Define macros to implement the function for a specific data
   type. */
#define MAKE_SPREAD_KERNEL1(X,Xtype,IntType) \
static void SpreadKernel1##X( AstMapping *this, int ndim_out, \
                              const int *lbnd_out, const int *ubnd_out, \
                              const Xtype *in, const Xtype *in_var, \
                              double infac, int npoint, const int *offset, \
                              const double *const *coords, \
                              void (* kernel)( double, const double [], \
                                               int, double *, int * ), \
                              int neighb, const double *params, \
                              double conwgt, int flags, Xtype badval, int npix_out, \
                              Xtype *out, Xtype *out_var, double *work, \
                              int64_t *nused, int *status ) { \
\
/* Local Variables: */ \
   astDECLARE_GLOBALS            /* Thread-specific data */ \
   Xtype c; \
   Xtype in_val;                 /* Input pixel value */ \
   double **wtptr;               /* Pointer to array of weight pointers */ \
   double **wtptr_last;          /* Array of highest weight pointer values */ \
   double *filter;               /* Pointer to Nd array of filter values */ \
   double *kp;                   /* Pointer to next weight values */ \
   double *kstart;               /* Pointer to next kernel value */ \
   double *kval;                 /* Pointer to 1d array of kernel values */ \
   double *wtprod;               /* Accumulated weight value array pointer */ \
   double *xfilter;              /* Pointer to 1d array of x axis filter values */ \
   double *xnl;                  /* Pointer to previous ofset array (n-d) */ \
   double pfac;                  /* Input weight with extra supplied factor */ \
   double pixwt;                 /* Weight to apply to individual pixel */ \
   double sum;                   /* Sum of all filter values */ \
   double wgt;                   /* Weight for input value */ \
   double x;                     /* x coordinate value */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double xx;                    /* X offset */ \
   double xxl;                   /* Previous X offset */ \
   double xxn; \
   double y;                     /* y coordinate value */ \
   double yy;                    /* Y offset */ \
   double yyl;                   /* Previous Y offset */ \
   int *hi;                      /* Pointer to array of upper indices */ \
   int *jhi;                     /* Pointer to array of filter upper indices */ \
   int *jlo;                     /* Pointer to array of filter lower indices */ \
   int *lo;                      /* Pointer to array of lower indices */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int done;                     /* All pixel indices done? */ \
   int genvar;                   /* Generate output variances? */ \
   int hi_ix;                    /* Upper output pixel index (x dimension) */ \
   int hi_iy;                    /* Upper output pixel index (y dimension) */ \
   int hi_jx;                    /* Upper filter pixel index (x dimension) */ \
   int hi_jy;                    /* Upper filter pixel index (y dimension) */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ii;                       /* Loop counter for dimensions */ \
   int ix;                       /* Pixel index in output grid x dimension */ \
   int iy;                       /* Pixel index in output grid y dimension */ \
   int jjx;                      /* Reflected pixel index in filter grid x dimension */ \
   int jjy;                      /* Reflected pixel index in filter grid y dimension */ \
   int jx;                       /* Pixel index in filter grid x dimension */ \
   int jxn; \
   int jy;                       /* Pixel index in filter grid y dimension */ \
   int kerror;                   /* Error signalled by kernel function? */ \
   int lo_ix;                    /* Lower output pixel index (x dimension) */ \
   int lo_iy;                    /* Lower output pixel index (y dimension) */ \
   int lo_jx;                    /* Lower filter pixel index (x dimension) */ \
   int lo_jy;                    /* Lower filter pixel index (y dimension) */ \
   int nb2;                      /* The total number of neighbouring pixels */ \
   int nf;                       /* Number of pixels in filter array */ \
   int nwx;                      /* Used X width of kernel function (*2) */ \
   int nwy;                      /* Used Y width of kernel function (*2) */ \
   int off1;                     /* Input pixel offset due to y index */ \
   int off_in;                   /* Offset to input pixel */ \
   int off_out;                  /* Offset to output pixel */ \
   int off_xedge;                /* Does filter box overlap array edge on the X axis? */ \
   int off_yedge;                /* Does filter box overlap array edge on the Y axis? */ \
   int point;                    /* Loop counter for output points */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int varwgt;                   /* Use input variances as weights? */ \
   int ystride;                  /* Stride along input grid y dimension */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Get a pointer to a structure holding thread-specific global data values */ \
   astGET_GLOBALS(this); \
\
/* Further initialisation. */ \
   kerror = 0; \
   sum = 0.0; \
   bad = 0; \
\
/* Find the total number of pixels in the filter used to spread a single \
   input pixel into the output image. */ \
   nb2 = 2*neighb; \
   nf = 1; \
   for ( idim = 0; idim < ndim_out; idim++ ) nf *= nb2; \
\
/* Allocate workspace to hold the filter values. */ \
   filter = astMalloc( sizeof( double ) * (size_t) nf ); \
   if ( astOK ) { \
\
/* Determine if we are processing bad pixels or variances. */ \
      usebad = flags & AST__USEBAD; \
      usevar = 0; \
      genvar = 0; \
      if( flags & AST__GENVAR ) { \
         genvar = out_var && work; \
      } else if( flags & AST__USEVAR ) { \
         usevar = in_var && out_var; \
      } \
      varwgt = ( flags & AST__VARWGT ) && in_var && work; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
      if ( ndim_out == 1 ) { \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
         if( varwgt ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  KERNEL_1D(X,Xtype,1,1,0,IntType,1) \
               } else if ( genvar ) { \
                  KERNEL_1D(X,Xtype,1,0,1,IntType,1) \
               } else { \
                  KERNEL_1D(X,Xtype,1,0,0,IntType,1) \
               } \
            } else { \
               if ( usevar ) { \
                  KERNEL_1D(X,Xtype,0,1,0,IntType,1) \
               } else if ( genvar ) { \
                  KERNEL_1D(X,Xtype,0,0,1,IntType,1) \
               } else { \
                  KERNEL_1D(X,Xtype,0,0,0,IntType,1) \
               } \
            } \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  KERNEL_1D(X,Xtype,1,1,0,IntType,0) \
               } else if ( genvar ) { \
                  KERNEL_1D(X,Xtype,1,0,1,IntType,0) \
               } else { \
                  KERNEL_1D(X,Xtype,1,0,0,IntType,0) \
               } \
            } else { \
               if ( usevar ) { \
                  KERNEL_1D(X,Xtype,0,1,0,IntType,0) \
               } else if ( genvar ) { \
                  KERNEL_1D(X,Xtype,0,0,1,IntType,0) \
               } else { \
                  KERNEL_1D(X,Xtype,0,0,0,IntType,0) \
               } \
            } \
         } \
\
/* Exit point on error in kernel function */ \
         Kernel_SError_1d: ; \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
      } else if ( ndim_out == 2 ) { \
\
/* Allocate workspace to hold the X axis filter values. */ \
         xfilter = astMalloc( sizeof( double ) * (size_t) nb2 ); \
\
/* Calculate the stride along the y dimension of the output grid. */ \
         ystride = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1; \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
         if( varwgt ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  KERNEL_2D(X,Xtype,1,1,0,IntType,1) \
               } else if ( genvar ) { \
                  KERNEL_2D(X,Xtype,1,0,1,IntType,1) \
               } else { \
                  KERNEL_2D(X,Xtype,1,0,0,IntType,1) \
               } \
            } else { \
               if ( usevar ) { \
                  KERNEL_2D(X,Xtype,0,1,0,IntType,1) \
               } else if ( genvar ) { \
                  KERNEL_2D(X,Xtype,0,0,1,IntType,1) \
               } else { \
                  KERNEL_2D(X,Xtype,0,0,0,IntType,1) \
               } \
            } \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  KERNEL_2D(X,Xtype,1,1,0,IntType,0) \
               } else if ( genvar ) { \
                  KERNEL_2D(X,Xtype,1,0,1,IntType,0) \
               } else { \
                  KERNEL_2D(X,Xtype,1,0,0,IntType,0) \
               } \
            } else { \
               if ( usevar ) { \
                  KERNEL_2D(X,Xtype,0,1,0,IntType,0) \
               } else if ( genvar ) { \
                  KERNEL_2D(X,Xtype,0,0,1,IntType,0) \
               } else { \
                  KERNEL_2D(X,Xtype,0,0,0,IntType,0) \
               } \
            } \
         } \
\
/* Free work space */ \
         xfilter = astFree( xfilter ); \
\
/* Exit point on error in kernel function */ \
         Kernel_SError_2d: ; \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
      } else { \
\
/* Allocate workspace. */ \
         hi = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
         lo = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
         jhi = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
         jlo = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
         stride = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
         xnl = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
         kval = astMalloc( sizeof( double ) * (size_t) \
                                           ( nb2 * ndim_out ) ); \
         wtprod = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
         wtptr = astMalloc( sizeof( double * ) * (size_t) ndim_out ); \
         wtptr_last = astMalloc( sizeof( double * ) * (size_t) ndim_out ); \
         if ( astOK ) { \
\
/* Calculate the stride along each dimension of the output grid. */ \
            for ( s = 1, idim = 0; idim < ndim_out; idim++ ) { \
               stride[ idim ] = s; \
               s *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
               xnl[ idim ] = AST__BAD; \
            } \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
            if( varwgt ) { \
               if ( usebad ) { \
                  if ( usevar ) { \
                     KERNEL_ND(X,Xtype,1,1,0,IntType,1) \
                  } else if ( genvar ) { \
                     KERNEL_ND(X,Xtype,1,0,1,IntType,1) \
                  } else { \
                     KERNEL_ND(X,Xtype,1,0,0,IntType,1) \
                  } \
               } else { \
                  if ( usevar ) { \
                     KERNEL_ND(X,Xtype,0,1,0,IntType,1) \
                  } else if ( genvar ) { \
                     KERNEL_ND(X,Xtype,0,0,1,IntType,1) \
                  } else { \
                     KERNEL_ND(X,Xtype,0,0,0,IntType,1) \
                  } \
               } \
            } else { \
               if ( usebad ) { \
                  if ( usevar ) { \
                     KERNEL_ND(X,Xtype,1,1,0,IntType,0) \
                  } else if ( genvar ) { \
                     KERNEL_ND(X,Xtype,1,0,1,IntType,0) \
                  } else { \
                     KERNEL_ND(X,Xtype,1,0,0,IntType,0) \
                  } \
               } else { \
                  if ( usevar ) { \
                     KERNEL_ND(X,Xtype,0,1,0,IntType,0) \
                  } else if ( genvar ) { \
                     KERNEL_ND(X,Xtype,0,0,1,IntType,0) \
                  } else { \
                     KERNEL_ND(X,Xtype,0,0,0,IntType,0) \
                  } \
               } \
            } \
\
/* Exit point on error in kernel function */ \
            Kernel_SError_Nd: ;\
         } \
\
/* Free the workspace. */ \
         hi = astFree( hi ); \
         lo = astFree( lo ); \
         jhi = astFree( jhi ); \
         jlo = astFree( jlo ); \
         stride = astFree( stride ); \
         xnl = astFree( xnl ); \
         kval = astFree( kval ); \
         wtprod = astFree( wtprod ); \
         wtptr = astFree( wtptr ); \
         wtptr_last = astFree( wtptr_last ); \
      } \
      filter = astFree( filter ); \
   }\
\
/* If an error occurred in the kernel function, then report a \
   contextual error message. */ \
   if ( kerror ) { \
      astError( astStatus, "astRebin"#X"(%s): Error signalled by " \
                "user-supplied 1-d interpolation kernel.", status, \
                astGetClass( unsimplified_mapping ) ); \
   } \
\
}




#define KERNEL_1D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* We do not yet have a previous filter position. */ \
   xxl = AST__BAD; \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Obtain the x coordinate of the current point and test if it is bad. \
   Also test that the central point falls within the output array. */ \
      x = coords[ 0 ][ point ]; \
      ix = (int) floor( x + 0.5 ); \
      if( ix < lbnd_out[ 0 ] || ix > ubnd_out[ 0 ] ) bad = 1; \
      bad = bad || ( x == AST__BAD ); \
\
/* If OK, calculate the lowest and highest indices (in the x \
   dimension) of the region of neighbouring output pixels that will \
   receive contributions from the current input pixel. Constrain these \
   values to lie within the output grid. */ \
      if ( !bad ) { \
         ix = (int) floor( x ) - neighb + 1; \
         lo_ix = MaxI( ix, lbnd_out[ 0 ], status ); \
         hi_ix = MinI( ix + nb2 - 1, ubnd_out[ 0 ], status ); \
\
/* Skip to the next input point if the current input point makes no \
   contribution to any output pixel. */ \
         if( lo_ix <= hi_ix ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
            if( nused ) (*nused)++; \
\
/* Convert these output indices to the corresponding indices \
   within a box [ 0, 2*neighb ] holding the kernel values. */ \
            lo_jx = lo_ix - ix; \
            hi_jx = hi_ix - ix; \
\
/* See if the kernel extends off the edge of the output array. */ \
            nwx =  hi_jx - lo_jx + 1; \
            off_xedge = ( nwx < nb2 ); \
\
/* Use the kernel function to fill the work array with weights for all output \
   pixels whether or not they fall within the output array. At the same \
   time find the sum of all the factors. */ \
            xx = (double) ix - x; \
            if( xx != xxl || off_xedge ) { \
               sum = 0.0; \
\
/* First handle cases where the kernel box overlaps an edge of the output \
   array. In these cases, in order to conserve flux, the bit of the \
   kernel function that is off the edge is reflected back onto the array. \
   Care must be taken since the reflected part of the kernel may itself \
   overlap the opposite edge of the array, in which case the overlapping \
   part must again be reflected back onto the array. This iterative \
   reflection is implemented using a fractional division (%) operator. */ \
               if( off_xedge ) { \
                  nwx *= 2; \
                  xxl = AST__BAD; \
                  for( jx = 0; jx < nb2; jx++ ) filter[ jx ] = 0.0; \
\
                  for ( jx = 0; jx < nb2; jx++ ) { \
                     ( *kernel )( xx, params, flags, &pixwt, status ); \
                     if ( !astOK ) { \
                        kerror = 1; \
                        goto Kernel_SError_1d; \
                     } \
\
                     jjx =  ( jx - lo_jx ) % nwx + lo_jx; \
                     if( jjx < lo_jx ) jjx += nwx; \
                     if( jjx > hi_jx ) jjx = 2*hi_jx - jjx + 1; \
\
                     filter[ jjx ] += pixwt; \
                     sum += pixwt; \
                     xx += 1.0; \
                  } \
\
/* Now handle cases where the kernel box is completely within the output \
   array. */ \
               } else { \
                  xxl = xx; \
\
                  for ( jx = 0; jx < nb2; jx++ ) { \
                     ( *kernel )( xx, params, flags, &pixwt, status ); \
\
/* Check for errors arising in the kernel function. */ \
                     if ( !astOK ) { \
                        kerror = 1; \
                        goto Kernel_SError_1d; \
                     } \
\
/* Store the kernel factor and increment the sum of all factors. */ \
                     filter[ jx ] = pixwt; \
                     sum += pixwt; \
                     xx += 1.0; \
                  } \
\
               } \
\
/* Ensure we do not divide by zero. */ \
               if( sum == 0.0 ) sum = 1.0; \
            } \
\
/* If we are using the input data variances as weights, calculate the \
   total weight, incorporating the normalisation factor for the kernel. */ \
            if( Varwgt ) { \
               wgt = conwgt/(sum*in_var[ off_in ]); \
\
/* If we are not using input variances as weights, the weight is just the \
   kernel normalisation factor. */ \
            } else { \
               wgt = conwgt/sum; \
            } \
\
/* Loop round all the output pixels which receive contributions from this \
   input pixel, calculating the offset of each pixel from the start of the \
   input array. */ \
            off_out = lo_ix - lbnd_out[ 0 ]; \
            for ( jx = lo_jx; jx <= hi_jx; jx++, off_out++ ) { \
\
/* Retrieve the weight for the current output pixel and normalise it. */ \
               pixwt = wgt*filter[ jx ]; \
               pfac = pixwt*infac; \
\
/* Update the output pixel with the required fraction of the input pixel \
   value. */ \
               c = CONV(IntType,pfac*in_val); \
\
               if( work ) { \
                  out[ off_out ] += c; \
                  work[ off_out ] += pixwt; \
               } else {\
                  out[ off_out ] += c; \
               } \
\
               if ( Usevar ) { \
                  out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
               } else if ( Genvar && pixwt != 0.0 ) { \
                  out_var[ off_out ] += c*c/pixwt; \
                  work[ off_out + npix_out ] += pixwt*pixwt; \
               } \
\
            } \
         } \
      } \
   }




#define KERNEL_2D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* We do not yet have a previous filter position. */ \
   xxl = AST__BAD; \
   yyl = AST__BAD; \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Obtain the x coordinate of the current point and test if it is bad. \
   Also test that the central point falls within the output array. */ \
      x = coords[ 0 ][ point ]; \
      ix = (int) floor( x + 0.5 ); \
      if( ix < lbnd_out[ 0 ] || ix > ubnd_out[ 0 ] ) bad = 1; \
      bad = bad || ( x == AST__BAD ); \
      if ( !bad ) { \
\
/* Similarly obtain and test the y coordinate. */ \
         y = coords[ 1 ][ point ]; \
         iy = (int) floor( y + 0.5 ); \
         if( iy < lbnd_out[ 1 ] || iy > ubnd_out[ 1 ] ) bad = 1; \
         bad = bad || ( y == AST__BAD ); \
         if ( !bad ) { \
\
/* If OK, calculate the lowest and highest indices (in each dimension) \
   of the region of neighbouring output pixels which will receive \
   contributions from the current input pixel. Constrain these values \
   to lie within the input grid. */ \
            ix = (int) floor( x ) - neighb + 1; \
            lo_ix = MaxI( ix, lbnd_out[ 0 ], status ); \
            hi_ix = MinI( ix + nb2 - 1, ubnd_out[ 0 ], status ); \
            iy = (int) floor( y ) - neighb + 1; \
            lo_iy = MaxI( iy, lbnd_out[ 1 ], status ); \
            hi_iy = MinI( iy + nb2 - 1, ubnd_out[ 1 ], status ); \
\
/* Skip to the next input point if the current input point makes no \
   contribution to any output pixel. */ \
            if( lo_ix <= hi_ix && lo_iy <= hi_iy ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
               if( nused ) (*nused)++; \
\
/* Convert these output indices to the corresponding indices \
   within a box [ 0:2*neighb, 0:2*neighb ] holding the kernel values. */ \
               lo_jx = lo_ix - ix; \
               hi_jx = hi_ix - ix; \
               lo_jy = lo_iy - iy; \
               hi_jy = hi_iy - iy; \
\
/* See if the kernel extends off the edge of the output array on either \
   axis. */ \
               nwx =  hi_jx - lo_jx + 1; \
               nwy =  hi_jy - lo_jy + 1; \
               off_xedge = ( nwx < nb2 ); \
               off_yedge = ( nwy < nb2 ); \
\
/* Loop to evaluate the kernel function along the y dimension, storing \
   the resulting weight values in all elements of each associated row \
   in the kvar array. The function's argument is the offset of the \
   output pixel (along this dimension) from the central output \
   position. */ \
               yy = (double) iy - y; \
               xx = (double) ix - x; \
               if( xx != xxl || yy != yyl || off_xedge || off_yedge ) { \
\
/* First handle cases where the kernel box extends beyond the top or \
   bottom edge of the output array. In these cases, in order to conserve \
   flux, the bit of the kernel function that is off the edge is reflected \
   back onto the array. Care must be taken since the reflected part of the \
   kernel may itself overlap the opposite edge of the array, in which \
   case the overlapping part must again be reflected back onto the \
   array. This iterative reflection is implemented using a fractional \
   division (%) operator. */ \
                  if( off_yedge ) { \
                     nwy *= 2; \
                     xxl = AST__BAD; \
                     yyl = AST__BAD; \
                     for( jy = 0; jy < nb2*nb2; jy++ ) filter[ jy ] = 0.0; \
\
                     for ( jy = 0; jy < nb2; jy++ ) { \
                        ( *kernel )( yy, params, flags, &pixwt, status ); \
                        if ( !astOK ) { \
                           kerror = 1; \
                           goto Kernel_SError_2d; \
                        } \
\
                        jjy =  ( jy - lo_jy ) % nwy + lo_jy; \
                        if( jjy < lo_jy ) jjy += nwy; \
                        if( jjy > hi_jy ) jjy = 2*hi_jy - jjy + 1; \
\
                        kp = filter + jjy*nb2; \
                        for( jx = 0; jx < nb2; jx++ ) *(kp++) += pixwt; \
                        yy += 1.0; \
                     } \
\
/* Now handles cases where the kernel does not overlap the top or bottom edge \
   of the output array. */ \
                  } else { \
                     xxl = xx; \
                     yyl = yy; \
                     kp = filter; \
                     for ( jy = 0; jy < nb2; jy++ ) { \
                        ( *kernel )( yy, params, flags, &pixwt, status ); \
\
/* Check for errors arising in the kernel function. */ \
                        if ( !astOK ) { \
                           kerror = 1; \
                           goto Kernel_SError_2d; \
                        } \
\
/* Store the kernel factor in all elements of the current row. */ \
                        for( jx = 0; jx < nb2; jx++ ) *(kp++) = pixwt; \
\
/* Move on to the next row. */ \
                        yy += 1.0; \
                     } \
                  } \
\
/* Loop to evaluate the kernel function along the x dimension, multiplying \
   the resulting weight values by the values already stored in the the \
   associated column in the kvar array. The function's argument is the \
   offset of the output pixel (along this dimension) from the central output \
   position. Also form the total data sum in the filter array. First \
   handle cases where the kernel overlaps the left or right edge of the \
   output array. */ \
                  sum = 0.0; \
\
/* First deal with cases where the kernel extends beyond the left or \
   right edge of the output array. */ \
                  if( off_xedge ) { \
                     nwx *= 2; \
                     xxl = AST__BAD; \
                     for( jx = 0; jx < nb2; jx++ ) xfilter[ jx ] = 0.0; \
\
                     for ( jx = 0; jx < nb2; jx++ ) { \
                        ( *kernel )( xx, params, flags, &pixwt, status ); \
                        if ( !astOK ) { \
                           kerror = 1; \
                           goto Kernel_SError_2d; \
                        } \
\
                        jjx =  ( jx - lo_jx ) % nwx + lo_jx; \
                        if( jjx < lo_jx ) jjx += nwx; \
                        if( jjx > hi_jx ) jjx = 2*hi_jx - jjx + 1; \
\
                        xfilter[ jjx ] += pixwt; \
                        xx += 1.0; \
                     } \
\
                     for ( jx = 0; jx < nb2; jx++ ) { \
                        kp = filter + jx; \
                        for( jy = 0; jy < nb2; jy++, kp += nb2 ) { \
                           *kp *= xfilter[ jx ]; \
                           sum += *kp; \
                        } \
                     } \
\
/* Now deal with cases where the kernel does not extends beyond the left or \
   right edge of the output array. */ \
                  } else { \
\
                     for ( jx = 0; jx < nb2; jx++ ) { \
                        ( *kernel )( xx, params, flags, &pixwt, status ); \
\
/* Check for errors arising in the kernel function. */ \
                        if ( !astOK ) { \
                           kerror = 1; \
                           goto Kernel_SError_2d; \
                        } \
\
/* Multiply the kernel factor by all elements of the current column. */ \
                        kp = filter + jx; \
                        for( jy = 0; jy < nb2; jy++, kp += nb2 ) { \
                           *kp *= pixwt; \
                           sum += *kp; \
                        } \
\
/* Move on to the next column. */ \
                        xx += 1.0; \
                     } \
                  } \
\
/* Ensure we do not divide by zero. */ \
                  if( sum == 0.0 ) sum = 1.0; \
               } \
\
/* If we are using the input data variances as weights, calculate the \
   total weight, incorporating the normalisation factor for the kernel. */ \
               if( Varwgt ) { \
                  wgt = conwgt/(sum*in_var[ off_in ]); \
\
/* If we are not using input variances as weights, the weight is just the \
   kernel normalisation factor. */ \
               } else { \
                  wgt = conwgt/sum; \
               } \
\
/* Find the offset into the output array at the first modified output pixel \
   in the first modified row. */ \
               off1 = lo_ix - lbnd_out[ 0 ] + ystride * ( lo_iy - lbnd_out[ 1 ] ); \
\
/* Loop over the affected output rows again. */ \
               for ( jy = lo_jy; jy <= hi_jy; jy++, off1 += ystride ) { \
\
/* Save the offset of the first output pixel to be modified in the \
   current row. */ \
                  off_out = off1; \
\
/* Get a pointer to the first weight value which will be used. */ \
                  kp = filter + lo_jx + jy*nb2; \
\
/* Loop over the affected output columns again. */ \
                  for ( jx = lo_jx; jx <= hi_jx; jx++, off_out++, kp++ ) { \
\
/* Calculate the weight for this output pixel and normalise it. */ \
                     pixwt = wgt*( *kp ); \
\
/* Update the output pixel with the required fraction of the input pixel \
   value. */ \
                     pfac = pixwt*infac; \
                     c = CONV(IntType,pfac*in_val); \
\
                     out[ off_out ] += c; \
                     if( work ) work[ off_out ] += pixwt; \
\
                     if ( Usevar ) { \
                        out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
                     } else if ( Genvar && pixwt != 0.0 ) { \
                        out_var[ off_out ] += c*c/pixwt; \
                        work[ off_out + npix_out ] += pixwt*pixwt; \
                     } \
                  } \
               } \
            } \
         } \
      } \
   }




#define KERNEL_ND(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* We do not yet have a normalising factor */ \
   sum = AST__BAD; \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Initialise offsets into the output array. Then loop to obtain each \
   coordinate associated with the current output point. Set a flag \
   indicating if any output pixel will be modified. */ \
      if( !bad ) { \
         off_out = 0; \
         for ( idim = 0; idim < ndim_out; idim++ ) { \
            xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate is bad. If true, the corresponding output pixel \
   value will be bad, so give up on this point. */ \
            ix = (int) floor( xn + 0.5 ); \
            if( ix < lbnd_out[ idim ] || ix > ubnd_out[ idim ] ) bad = 1; \
            bad = bad || ( xn == AST__BAD ); \
            if ( bad ) break; \
\
/* Calculate the lowest and highest indices (in the current dimension) \
   of the region of neighbouring output pixels that will be modified. \
   Constrain these values to lie within the output grid. */ \
            ix = (int) floor( xn ) - neighb + 1; \
            lo[ idim ] = MaxI( ix, lbnd_out[ idim ], status ); \
            hi[ idim ] = MinI( ix + nb2 - 1, ubnd_out[ idim ], status ); \
            jlo[ idim ] = lo[ idim ] - ix; \
            jhi[ idim ] = hi[ idim ] - ix; \
\
/* Check there is some overlap with the output array on this axis. */ \
            if( lo[ idim ] > hi[ idim ] ) { \
               bad = 1; \
               break; \
            } \
\
/* Accumulate the offset (from the start of the output array) of the \
   modified output pixel which has the lowest index in each dimension. */ \
            off_out += stride[ idim ] * ( lo[ idim ] - lbnd_out[ idim ] ); \
\
/* Set up an array of pointers to locate the first filter pixel (stored in the \
   "kval" array) for each dimension. */ \
            wtptr[ idim ] = kval + nb2*idim; \
            wtptr_last[ idim ] = wtptr[ idim ] + nb2 - 1; \
\
/* See if the kernel extends off the edge of the output array on the current \
   axis. */ \
            lo_jx = jlo[ idim ]; \
            hi_jx = jhi[ idim ]; \
            nwx =  hi_jx - lo_jx + 1; \
            off_xedge = ( nwx < nb2 ); \
\
/* Loop to evaluate the kernel function along each dimension, storing \
   the resulting values. The function's argument is the offset of the \
   output pixel (along the relevant dimension) from the central output \
   point. */ \
            xxn = (double) ix - xn; \
            if( xxn != xnl[ idim ] || off_xedge ) { \
               sum = AST__BAD; \
\
/* First handle cases where the kernel box overlaps an edge of the output \
   array. In these cases, in order to conserve flux, the bit of the \
   kernel function that is off the edge is reflected back onto the array. \
   Care must be taken since the reflected part of the kernel may itself \
   overlap the opposite edge of the array, in which case the overlapping \
   part must again be reflected back onto the array. This iterative \
   reflection is implemented using a fractional division (%) operator. */ \
               if( off_xedge ) { \
                  nwx *= 2; \
                  xnl[ idim ] = AST__BAD; \
                  kp = wtptr[ idim ]; \
                  for( jx = 0; jx < nb2; jx++ ) *(kp++) = 0.0; \
\
                  kp = wtptr[ idim ]; \
                  for ( jx = 0; jx < nb2; jx++ ) { \
                     ( *kernel )( xxn, params, flags, &pixwt, status ); \
                     if ( !astOK ) { \
                        kerror = 1; \
                        goto Kernel_SError_1d; \
                     } \
\
                     jjx =  ( jx - lo_jx ) % nwx + lo_jx; \
                     if( jjx < lo_jx ) jjx += nwx; \
                     if( jjx > hi_jx ) jjx = 2*hi_jx - jjx + 1; \
\
                     kp[ jjx ] += pixwt; \
                     xxn += 1.0; \
                  } \
\
/* Now handle cases where the kernel box is completely within the output \
   array. */ \
               } else { \
                  xnl[ idim ] = xxn; \
                  for ( jxn = 0; jxn < nb2; jxn++ ) { \
                     ( *kernel )( xxn, params, flags, wtptr[ idim ] + jxn, status ); \
\
/* Check for errors arising in the kernel function. */ \
                     if ( !astOK ) { \
                        kerror = 1; \
                        goto Kernel_SError_Nd; \
                     } \
\
/* Increment the kernel position. */ \
                     xxn += 1.0; \
                  } \
               } \
            } \
         } \
\
/* If OK... */ \
         if ( !bad ) { \
\
/* We only need to modify the normalising factor if the weight values \
   have changed. */ \
            if( sum == AST__BAD ) { \
\
/* The kernel value to use for each output pixel is the product of the \
   kernel values for each individual axis at that point. To conserve \
   flux we need to make sure that the sum of these kernel products is unity. \
   So loop over the values now to find the total sum of all kernel values. */ \
               idim = ndim_out - 1; \
               wtprod[ idim ] = 1.0; \
               done = 0; \
               sum = 0; \
               do { \
\
/* Each modified output pixel has a weight equal to the product of the kernel \
   weight factors evaluated along each input dimension. However, since \
   we typically only change the index of one dimension at a time, we \
   can avoid forming this product repeatedly by retaining an array of \
   accumulated products for all higher dimensions. We need then only \
   update the lower elements in this array, corresponding to those \
   dimensions whose index has changed. We do this here, "idim" being \
   the index of the most significant dimension to have changed. Note \
   that on the first pass, all dimensions are considered changed, \
   causing this array to be initialised. */ \
                  for ( ii = idim; ii >= 1; ii-- ) { \
                     wtprod[ ii - 1 ] = wtprod[ ii ] * *( wtptr[ ii ] ); \
                  } \
\
/* Obtain the weight of each pixel from the accumulated product of \
   weights. Also multiply by the weight for dimension zero, which is not \
   included in the "wtprod" array). Increment the sum of all weights. */ \
                  sum += wtprod[ 0 ] * *( wtptr[ 0 ] ); \
\
/* Now update the weight value pointers and pixel offset to refer to \
   the next output pixel to be considered. */ \
                  idim = 0; \
                  do { \
\
/* The first input dimension whose weight value pointer has not yet \
   reached its final value has this pointer incremented. */ \
                     if ( wtptr[ idim ] != wtptr_last[ idim ] ) { \
                        wtptr[ idim ]++; \
                        break; \
\
/* Any earlier dimensions (which have reached the final pointer value) \
   have this pointer returned to its lowest value. */ \
                     } else { \
                        wtptr[ idim ] -= nb2 - 1; \
                        done = ( ++idim == ndim_out ); \
                     } \
                  } while ( !done ); \
               } while ( !done ); \
\
/* Ensure we do not divide by zero. */ \
               if( sum == 0.0 ) sum = 1.0; \
            } \
\
/* Re-initialise the weights pointers to refer to the first and last \
   filter pixels which overlaps the output array. */ \
            kstart = kval; \
            for ( idim = 0; idim < ndim_out; idim++ ) { \
               wtptr[ idim ] = kstart + jlo[ idim ]; \
               wtptr_last[ idim ] = kstart + jhi[ idim ]; \
               kstart += nb2; \
            } \
\
/* If we are using the input data variances as weights, calculate the \
   total weight, incorporating the normalisation factor for the kernel. */ \
            if( Varwgt ) { \
               wgt = conwgt/(sum*in_var[ off_in ]); \
\
/* If we are not using input variances as weights, the weight is just the \
   kernel normalisation factor. */ \
            } else { \
               wgt = conwgt/sum; \
            } \
\
/* Increment the number of input pixels pasted into the output array. */ \
            if( nused ) (*nused)++; \
\
/* Initialise, and loop over the neighbouring output pixels to divide up \
   the input pixel value between them. */ \
            idim = ndim_out - 1; \
            wtprod[ idim ] = 1.0; \
            done = 0; \
            do { \
\
/* Each modified output pixel has a weight equal to the product of the kernel \
   weight factors evaluated along each input dimension. However, since \
   we typically only change the index of one dimension at a time, we \
   can avoid forming this product repeatedly by retaining an array of \
   accumulated products for all higher dimensions. We need then only \
   update the lower elements in this array, corresponding to those \
   dimensions whose index has changed. We do this here, "idim" being \
   the index of the most significant dimension to have changed. Note \
   that on the first pass, all dimensions are considered changed, \
   causing this array to be initialised. */ \
               for ( ii = idim; ii >= 1; ii-- ) { \
                  wtprod[ ii - 1 ] = wtprod[ ii ] * *( wtptr[ ii ] ); \
               } \
\
/* Obtain the weight of each pixel from the accumulated \
   product of weights. Also multiply by the weight for dimension zero, \
   which is not included in the "wtprod" array). */ \
               pixwt = ( wtprod[ 0 ] * *( wtptr[ 0 ] ) )*wgt; \
\
/* Update the output pixel with the required fraction of the input pixel \
   value. */ \
               pfac = pixwt*infac; \
               c = CONV(IntType,pfac*in_val); \
\
               if( work ) { \
                  out[ off_out ] += c; \
                  work[ off_out ] += pixwt; \
               } else {\
                  out[ off_out ] += c; \
               } \
\
               if ( Usevar ) { \
                  out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
               } else if ( Genvar && pixwt != 0.0 ) { \
                  out_var[ off_out ] += c*c/pixwt; \
                  work[ off_out + npix_out ] += pixwt*pixwt; \
               } \
\
/* Now update the weight value pointers and pixel offset to refer to \
   the next output pixel to be considered. */ \
               idim = 0; \
               do { \
\
/* The first input dimension whose weight value pointer has not yet \
   reached its final value has this pointer incremented, and the pixel \
   offset into the input array is updated accordingly. */ \
                  if ( wtptr[ idim ] != wtptr_last[ idim ] ) { \
                     wtptr[ idim ]++; \
                     off_out += stride[ idim ]; \
                     break; \
\
/* Any earlier dimensions (which have reached the final pointer value) \
   have this pointer returned to its lowest value. Again, the pixel \
   offset into the input image is updated accordingly. */ \
                  } else { \
                     wtptr[ idim ] -= ( hi[ idim ] - lo[ idim ] ); \
                     off_out -= stride[ idim ] * \
                                     ( hi[ idim ] - lo[ idim ] ); \
                     done = ( ++idim == ndim_out ); \
                  } \
               } while ( !done ); \
            } while ( !done ); \
         } \
      } \
   }


/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_SPREAD_KERNEL1(LD,long double,0)
#endif
MAKE_SPREAD_KERNEL1(D,double,0)
MAKE_SPREAD_KERNEL1(F,float,0)
MAKE_SPREAD_KERNEL1(I,int,1)
MAKE_SPREAD_KERNEL1(B,signed char,1)
MAKE_SPREAD_KERNEL1(UB,unsigned char,1)

/* Undefine the macros used above. */
#undef KERNEL_ND
#undef KERNEL_2D
#undef KERNEL_1D
#undef MAKE_SPREAD_KERNEL1

/*
*  Name:
*     SpreadLinear<X>

*  Purpose:
*     Rebin a data grid, using the linear spreading scheme.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SpreadLinear<X>( int ndim_out,
*                           const int *lbnd_out, const int *ubnd_out,
*                           const <Xtype> *in, const <Xtype> *in_var,
*                           double infac, int npoint, const int *offset,
*                           const double *const *coords, double conwgt, int flags,
*                           <Xtype> badval, int npix_out, <Xtype> *out,
*                           <Xtype> *out_var, double *work, int64_t *nused  )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which rebins a rectangular region of an
*     input grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each input
*     grid point may be mapped on to a position in the output grid in
*     an arbitrary way. Where the positions given do not correspond
*     with a pixel centre in the input grid, the spreading scheme
*     used divides the input pixel value up linearly between the
*     nearest neighbouring output pixels in each dimension (there are 2
*     nearest neighbours in 1 dimension, 4 in 2 dimensions, 8 in 3
*     dimensions, etc.).

*  Parameters:
*     ndim_out
*        The number of dimensions in the output grid. This should be at
*        least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output grid, its extent along a particular
*        (i'th) dimension being ubnd_out[i]-lbnd_out[i]+1 (assuming "i"
*        is zero-based). They also define the output grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be rebinned. The numerical type
*        of these data should match the function used, as given by the
*        suffix on the function name. Note that details of how the input
*        grid maps on to this array (e.g. the storage order, number of
*        dimensions, etc.) is arbitrary and is specified entirely by means
*        of the "offset" array. The "in" array should therefore contain
*        sufficient elements to accommodate the "offset" values supplied.
*        There is no requirement that all elements of the "in" array
*        should be rebinned, and any which are not addressed by the
*        contents of the "offset" array will be ignored.
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned. It is addressed in exactly the same way (via the
*        "offset" array) as the "in" array.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     infac
*        A factor by which to multiply the input data values before use.
*     npoint
*        The number of input points which are to be rebinned.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each input point, this array should contain the zero-based
*        offset in the input array(s) (i.e. the "in" and, optionally,
*        the "in_var" arrays) from which the value to be rebinned should
*        be obtained.
*     coords
*        An array of pointers to double, with "ndim_out" elements.
*        Element "coords[coord]" should point at the first element of
*        an array of double (with "npoint" elements) which contains the
*        values of coordinate number "coord" for each point being
*        rebinned. The value of coordinate number "coord" for
*        rebinning point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices are
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding input data (and
*        variance) value will be ignored.
*        The bitwise OR of a set of flag values which control the
*        operation of the function. These are chosend from:
*
*        - AST__USEBAD: indicates whether there are "bad" (i.e. missing) data
*        in the input array(s) which must be recognised.  If this flag is not
*        set, all input values are treated literally.
*        - AST__GENVAR: Indicates that any input variances are to be
*        ignored, and that the output variances should be generated from
*        the spread of values contributing to each output pixel.
*     conwgt
*        The initial weight to use for all pixels (typically 1.0). Other
*        weights (e.g. interpolation weights, variance weights, etc) are
*        applied as factors to this initial value.
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which resampled values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     npix_out
*        Number of pixels in output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned. The
*        storage order should be such that the index of the first grid
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given. The values returned
*        are estimates of the statistical variance of the corresponding
*        values in the "out" array, on the assumption that all errors in
*        input grid values (in the "in" array) are statistically independent
*        and that their variance estimates (in the "in_var" array) may
*        simply be summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        An optional pointer to a double array with the same size as
*        the "out" array. The contents of this array (if supplied) are
*        incremented by the accumulated weights assigned to each output pixel.
*        If no accumulated weights are required, a NULL pointer should be
*        given.
*     nused
*        An optional pointer to a int64_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*/
/* Define macros to implement the function for a specific data
   type. */
#define MAKE_SPREAD_LINEAR(X,Xtype,IntType) \
static void SpreadLinear##X( int ndim_out, \
                            const int *lbnd_out, const int *ubnd_out, \
                            const Xtype *in, const Xtype *in_var, \
                            double infac, int npoint, const int *offset, \
                            const double *const *coords, double conwgt, int flags, \
                            Xtype badval, int npix_out, Xtype *out, \
                            Xtype *out_var, double *work, int64_t *nused, \
                            int *status ) { \
\
/* Local Variables: */ \
   Xtype c;                      /* Contribution to output value */ \
   Xtype in_val;                 /* Input value */ \
   double *frac_hi;              /* Pointer to array of weights */ \
   double *frac_lo;              /* Pointer to array of weights */ \
   double *wt;                   /* Pointer to array of weights */ \
   double *wtprod;               /* Array of accumulated weights pointer */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double frac_hi_x;             /* Pixel weight (x dimension) */ \
   double frac_hi_y;             /* Pixel weight (y dimension) */ \
   double frac_lo_x;             /* Pixel weight (x dimension) */ \
   double frac_lo_y;             /* Pixel weight (y dimension) */ \
   double pfac;                  /* Scaled pixel weight */ \
   double pixwt;                 /* Total pixel weight */ \
   double wgt;                   /* Weight for input value */ \
   double x;                     /* x coordinate value */ \
   double xmax;                  /* x upper limit */ \
   double xmin;                  /* x lower limit */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   double ymax;                  /* y upper limit */ \
   double ymin;                  /* y lower limit */ \
   int *dim;                     /* Pointer to array of pixel indices */ \
   int *hi;                      /* Pointer to array of upper indices */ \
   int *lo;                      /* Pointer to array of lower indices */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int done;                     /* All pixel indices done? */ \
   int genvar;                   /* Generate output variances? */ \
   int hi_x;                     /* Upper pixel index (x dimension) */ \
   int hi_y;                     /* Upper pixel index (y dimension) */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ii;                       /* Loop counter for weights */ \
   int ixn;                      /* Pixel index (n-d) */ \
   int lo_x;                     /* Lower pixel index (x dimension) */ \
   int lo_y;                     /* Lower pixel index (y dimension) */ \
   int off;                      /* Total offset to input pixel */ \
   int off_in;                   /* Offset to input pixel */ \
   int off_lo;                   /* Offset to "first" input pixel */ \
   int off_out;                  /* Offset to output pixel */ \
   int point;                    /* Loop counter for output points */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int varwgt;                   /* Use input variances as weights? */ \
   int ystride;                  /* Stride along input grid y dimension */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Initialise variables to avoid "used of uninitialised variable" \
   messages from dumb compilers. */ \
   bad = 0; \
\
/* Determine if we are processing bad pixels or variances. */ \
   usebad = flags & AST__USEBAD; \
   usevar = 0; \
   genvar = 0; \
   if( flags & AST__GENVAR ) { \
      genvar = out_var && work; \
   } else if( flags & AST__USEVAR ) { \
      usevar = in_var && out_var; \
   } \
   varwgt = ( flags & AST__VARWGT ) && in_var && work; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_out == 1 ) { \
\
/* Calculate the coordinate limits of the input grid. */ \
      xmin = (double) lbnd_out[ 0 ] - 0.5; \
      xmax = (double) ubnd_out[ 0 ] + 0.5; \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
      if( varwgt ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               LINEAR_1D(X,Xtype,1,1,0,IntType,1) \
            } else if ( genvar ) { \
               LINEAR_1D(X,Xtype,1,0,1,IntType,1) \
            } else { \
               LINEAR_1D(X,Xtype,1,0,0,IntType,1) \
            } \
         } else { \
            if ( usevar ) { \
               LINEAR_1D(X,Xtype,0,1,0,IntType,1) \
            } else if ( genvar ) { \
               LINEAR_1D(X,Xtype,0,0,1,IntType,1) \
            } else { \
               LINEAR_1D(X,Xtype,0,0,0,IntType,1) \
            } \
         } \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               LINEAR_1D(X,Xtype,1,1,0,IntType,0) \
            } else if ( genvar ) { \
               LINEAR_1D(X,Xtype,1,0,1,IntType,0) \
            } else { \
               LINEAR_1D(X,Xtype,1,0,0,IntType,0) \
            } \
         } else { \
            if ( usevar ) { \
               LINEAR_1D(X,Xtype,0,1,0,IntType,0) \
            } else if ( genvar ) { \
               LINEAR_1D(X,Xtype,0,0,1,IntType,0) \
            } else { \
               LINEAR_1D(X,Xtype,0,0,0,IntType,0) \
            } \
         } \
      } \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_out == 2 ) { \
\
/* Calculate the stride along the y dimension of the output grid. */ \
      ystride = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1; \
\
/* Calculate the coordinate limits of the output grid in each \
   dimension. */ \
      xmin = (double) lbnd_out[ 0 ] - 0.5; \
      xmax = (double) ubnd_out[ 0 ] + 0.5; \
      ymin = (double) lbnd_out[ 1 ] - 0.5; \
      ymax = (double) ubnd_out[ 1 ] + 0.5; \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
      if( varwgt ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               LINEAR_2D(X,Xtype,1,1,0,IntType,1) \
            } else if ( genvar ) { \
               LINEAR_2D(X,Xtype,1,0,1,IntType,1) \
            } else { \
               LINEAR_2D(X,Xtype,1,0,0,IntType,1) \
            } \
         } else { \
            if ( usevar ) { \
               LINEAR_2D(X,Xtype,0,1,0,IntType,1) \
            }else if ( genvar ) { \
               LINEAR_2D(X,Xtype,0,0,1,IntType,1) \
            } else { \
               LINEAR_2D(X,Xtype,0,0,0,IntType,1) \
            } \
         } \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               LINEAR_2D(X,Xtype,1,1,0,IntType,0) \
            } else if ( genvar ) { \
               LINEAR_2D(X,Xtype,1,0,1,IntType,0) \
            } else { \
               LINEAR_2D(X,Xtype,1,0,0,IntType,0) \
            } \
         } else { \
            if ( usevar ) { \
               LINEAR_2D(X,Xtype,0,1,0,IntType,0) \
            }else if ( genvar ) { \
               LINEAR_2D(X,Xtype,0,0,1,IntType,0) \
            } else { \
               LINEAR_2D(X,Xtype,0,0,0,IntType,0) \
            } \
         } \
      } \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      dim = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
      frac_hi = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      frac_lo = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      hi = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
      lo = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
      wt = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      wtprod = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the output grid. */ \
         for ( s = 1, idim = 0; idim < ndim_out; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
\
/* Calculate the coordinate limits of the output grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_out[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_out[ idim ] + 0.5; \
         } \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
         if( varwgt ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  LINEAR_ND(X,Xtype,1,1,0,IntType,1) \
               } else if ( genvar ) { \
                  LINEAR_ND(X,Xtype,1,0,1,IntType,1) \
               } else { \
                  LINEAR_ND(X,Xtype,1,0,0,IntType,1) \
               } \
            } else { \
               if ( usevar ) { \
                  LINEAR_ND(X,Xtype,0,1,0,IntType,1) \
               } else if ( genvar ) { \
                  LINEAR_ND(X,Xtype,0,0,1,IntType,1) \
               } else { \
                  LINEAR_ND(X,Xtype,0,0,0,IntType,1) \
               } \
            } \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  LINEAR_ND(X,Xtype,1,1,0,IntType,0) \
               } else if ( genvar ) { \
                  LINEAR_ND(X,Xtype,1,0,1,IntType,0) \
               } else { \
                  LINEAR_ND(X,Xtype,1,0,0,IntType,0) \
               } \
            } else { \
               if ( usevar ) { \
                  LINEAR_ND(X,Xtype,0,1,0,IntType,0) \
               } else if ( genvar ) { \
                  LINEAR_ND(X,Xtype,0,0,1,IntType,0) \
               } else { \
                  LINEAR_ND(X,Xtype,0,0,0,IntType,0) \
               } \
            } \
         } \
      } \
\
/* Free the workspace. */ \
      dim = astFree( dim ); \
      frac_hi = astFree( frac_hi ); \
      frac_lo = astFree( frac_lo ); \
      hi = astFree( hi ); \
      lo = astFree( lo ); \
      stride = astFree( stride ); \
      wt = astFree( wt ); \
      wtprod = astFree( wtprod ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
   } \
\
}






#define LINEAR_1D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the output grid. Also test if it is bad. */ \
      x = coords[ 0 ][ point ]; \
      bad = bad || ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
\
/* If OK, obtain the indices along the output grid x dimension of the \
   two adjacent output pixels which will receive contributions from the \
   input pixel. Also obtain the fractional weight to be applied to each of \
   these pixels. */ \
      if ( !bad ) { \
         lo_x = (int) floor( x ); \
         hi_x = lo_x + 1; \
         frac_lo_x = (double) hi_x - x; \
         frac_hi_x = 1.0 - frac_lo_x; \
\
/* Increment the number of input pixels pasted into the output array. */ \
         if( nused ) (*nused)++; \
\
/* Obtain the offset within the output array of the first pixel to be \
   updated (the one with the smaller index). */ \
         off_lo = lo_x - lbnd_out[ 0 ]; \
\
/* If we are using the input data variances as weights, calculate the \
   weight, and scale the fractions of each input pixel by the weight. */ \
         wgt = conwgt; \
         if( Varwgt ) wgt *= 1.0/in_var[ off_in ]; \
         frac_lo_x *= wgt; \
         frac_hi_x *= wgt; \
\
/* For each of the two pixels which may be updated, test if the pixel index \
   lies within the output grid. Where it does, update the output pixel \
   with the required fraction of the input pixel value. */ \
         if ( lo_x >= lbnd_out[ 0 ] ) { \
            pfac = frac_lo_x*infac; \
            c = CONV(IntType,pfac*in_val); \
            out[ off_lo ] += CONV(IntType, c ); \
            if( work ) work[ off_lo ] += frac_lo_x; \
            if ( Usevar ) { \
               out_var[ off_lo ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
            } else if ( Genvar && frac_lo_x != 0.0 ) { \
               out_var[ off_lo ] += c*c/frac_lo_x; \
               work[ off_lo + npix_out ] += frac_lo_x*frac_lo_x; \
            } \
         } \
         if ( hi_x <= ubnd_out[ 0 ] ) { \
            pfac = frac_hi_x*infac; \
            c = CONV(IntType,pfac*in_val); \
            out[ off_lo + 1 ] += CONV(IntType, c ); \
            if( work ) work[ off_lo + 1 ] += frac_hi_x; \
            if ( Usevar ) { \
               out_var[ off_lo + 1 ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
            } else if ( Genvar && frac_hi_x != 0.0 ) { \
               out_var[ off_lo + 1 ] += c*c/frac_hi_x; \
               work[ off_lo + 1 + npix_out ] += frac_hi_x*frac_hi_x; \
            } \
         } \
      } \
   }




#define LINEAR_2D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Obtain the x coordinate of the current point and test if it lies \
   outside the output grid. Also test if it is bad. */ \
      y = coords[ 1 ][ point ]; \
      bad = bad || ( y < ymin ) || ( y >= ymax ) || ( y == AST__BAD ); \
      if ( !bad ) { \
\
/* Similarly obtain and test the y coordinate. */ \
         x = coords[ 0 ][ point ]; \
         bad = bad || ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
         if ( !bad ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
            if( nused ) (*nused)++; \
\
/* If OK, obtain the indices along the output grid x dimension of the \
   two adjacent pixels which recieve contributions from the input pixel. \
   Also obtain the fractional weight to be applied to each of \
   these pixels. */ \
            lo_x = (int) floor( x ); \
            hi_x = lo_x + 1; \
            frac_lo_x = (double) hi_x - x; \
            frac_hi_x = 1.0 - frac_lo_x; \
\
/* Repeat this process for the y dimension. */ \
            lo_y = (int) floor( y ); \
            hi_y = lo_y + 1; \
            frac_lo_y = (double) hi_y - y; \
            frac_hi_y = 1.0 - frac_lo_y; \
\
/* If we are using the input data variances as weights, calculate the \
   weight, and scale the fractions of each input pixel by the weight. \
   Since the product of two fractions is always used to scale the input \
   data values, we use the square root of the reciprocal of the variance \
   as the weight (so that when the product of two fractions is taken, \
   the square roots multiply together to give the required 1/variance \
   weight).  */ \
            wgt = conwgt; \
            if( Varwgt ) wgt *= 1.0/sqrt( in_var[ off_in ] ); \
            frac_lo_x *= wgt; \
            frac_hi_x *= wgt; \
            frac_lo_y *= wgt; \
            frac_hi_y *= wgt; \
\
/* Obtain the offset within the output array of the first pixel to be \
   updated (the one with the smaller index along both dimensions). */ \
            off_lo = lo_x - lbnd_out[ 0 ] + ystride * ( lo_y - lbnd_out[ 1 ] ); \
\
/* For each of the four pixels which may be updated, test if the pixel indices \
   lie within the output grid. Where they do, update the output pixel \
   with the required fraction of the input pixel value. */ \
            if ( lo_y >= lbnd_out[ 1 ] ) { \
               if ( lo_x >= lbnd_out[ 0 ] ) { \
                  pixwt = frac_lo_x * frac_lo_y; \
                  pfac = pixwt*infac; \
                  c = CONV(IntType,pfac*in_val); \
                  out[ off_lo ] += CONV(IntType, c ); \
                  if( work ) work[ off_lo ] += pixwt; \
                  if ( Usevar ) { \
                     out_var[ off_lo ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
                  } else if ( Genvar && pixwt != 0.0 ) { \
                     out_var[ off_lo ] += c*c/pixwt; \
                     work[ off_lo + npix_out ] += pixwt*pixwt; \
                  } \
               } \
               if ( hi_x <= ubnd_out[ 0 ] ) { \
                  off = off_lo + 1; \
                  pixwt = frac_hi_x * frac_lo_y; \
                  pfac = pixwt*infac; \
                  c = CONV(IntType,pfac*in_val); \
                  out[ off ] += CONV(IntType, c ); \
                  if( work ) work[ off ] += pixwt; \
                  if ( Usevar ) { \
                     out_var[ off ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
                  } else if ( Genvar && pixwt != 0.0 ) { \
                     out_var[ off ] += c*c/pixwt; \
                     work[ off + npix_out ] += pixwt*pixwt; \
                  } \
               } \
            } \
            if ( hi_y <= ubnd_out[ 1 ] ) { \
               if ( lo_x >= lbnd_out[ 0 ] ) { \
                  off = off_lo + ystride; \
                  pixwt = frac_lo_x * frac_hi_y; \
                  pfac = pixwt*infac; \
                  c = CONV(IntType,pfac*in_val); \
                  out[ off ] += CONV(IntType, c ); \
                  if( work ) work[ off ] += pixwt; \
                  if ( Usevar ) { \
                     out_var[ off ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
                  } else if ( Genvar && pixwt != 0.0 ) { \
                     out_var[ off ] += c*c/pixwt; \
                     work[ off + npix_out ] += pixwt*pixwt; \
                  } \
               } \
               if ( hi_x <= ubnd_out[ 0 ] ) { \
                  off = off_lo + ystride + 1; \
                  pixwt = frac_hi_x * frac_hi_y; \
                  pfac = pixwt*infac; \
                  c = CONV(IntType,pfac*in_val); \
                  out[ off ] += CONV(IntType, c ); \
                  if( work ) work[ off ] += pixwt; \
                  if ( Usevar ) { \
                     out_var[ off ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
                  } else if ( Genvar && pixwt != 0.0 ) { \
                     out_var[ off ] += c*c/pixwt; \
                     work[ off + npix_out ] += pixwt*pixwt; \
                  } \
               } \
            } \
         } \
      } \
   }


#define LINEAR_ND(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
   for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
      off_in = offset[ point ]; \
      in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
      if ( Usebad ) { \
         bad = ( in_val == badval ); \
         if ( Varwgt ) { \
            bad = bad || ( in_var[ off_in ] == badval ) \
                      || ( in_var[ off_in ] <= 0.0 ); \
         } else if ( Usevar ) { \
            bad = bad || ( in_var[ off_in ] == badval ); \
         } \
      } else { \
         if ( Varwgt ) { \
            bad = ( in_var[ off_in ] <= 0.0 ); \
         } else { \
            bad = 0; \
         } \
      } \
\
/* Initialise offsets into the output array. Then loop to obtain each \
   coordinate associated with the current output point. */ \
      if( !bad ) { \
         off_out = 0; \
         for ( idim = 0; idim < ndim_out; idim++ ) { \
            xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate lies outside the output grid.  Also test if \
   it is bad. If either is true, the corresponding output pixel value \
   will be bad, so give up on this point. */ \
            bad = ( xn < xn_min[ idim ] ) || ( xn >= xn_max[ idim ] ) || \
                  ( xn == AST__BAD ); \
            if ( bad ) break; \
\
/* Obtain the indices along the current dimension of the output grid of \
   the two (usually adjacent) pixels which will be updated. If necessary, \
   however, restrict each index to ensure it does not lie outside the \
   input grid. Also calculate the fractional weight to be given to each \
   pixel in order to divide the input value linearly between them. */ \
            ixn = (int) floor( xn ); \
            lo[ idim ] = MaxI( ixn, lbnd_out[ idim ], status ); \
            hi[ idim ] = MinI( ixn + 1, ubnd_out[ idim ], status ); \
            frac_lo[ idim ] = 1.0 - fabs( xn - (double) lo[ idim ] ); \
            frac_hi[ idim ] = 1.0 - fabs( xn - (double) hi[ idim ] ); \
\
/* Store the lower index involved in spreading along each \
   dimension and accumulate the offset from the start of the output \
   array of the pixel which has these indices. */ \
            dim[ idim ] = lo[ idim ]; \
            off_out += stride[ idim ] * ( lo[ idim ] - lbnd_out[ idim ] ); \
\
/* Also store the fractional weight associated with the lower pixel \
   along each dimension. */ \
            wt[ idim ] = frac_lo[ idim ]; \
         } \
\
/* If we are using the input data variances as weights, calculate the \
   weight, and scale the fractions of each input pixel by the weight. */ \
         wgt = conwgt; \
         if( Varwgt ) wgt *= pow( in_var[ off_in ], -1.0/(double)ndim_out ); \
         for ( idim = 0; idim < ndim_out; idim++ ) { \
            frac_lo[ idim ] *= wgt; \
            frac_hi[ idim ] *= wgt; \
            wt[ idim ] = frac_lo[ idim ]; \
         } \
\
/* If OK, increment the number of input pixels pasted into the output array. */ \
         if ( !bad ) { \
            if( nused ) (*nused)++; \
\
/* Loop over adjacent output pixels to divide up the input value. */ \
            idim = ndim_out - 1; \
            wtprod[ idim ] = 1.0; \
            done = 0; \
            do { \
\
/* Each pixel pixel to be updated has a total weight equal to the product \
   of the weights which account for the displacement of its centre from \
   the required position along each dimension. However, since we typically \
   only change the index of one dimension at a time, we can avoid forming \
   this product repeatedly by retaining an array of accumulated weight \
   products for all higher dimensions. We need then only update the \
   lower elements in this array, corresponding to those dimensions \
   whose index has changed. We do this here, "idim" being the index of \
   the most significant dimension to have changed. Note that on the \
   first pass, all dimensions are considered changed, causing this \
   array to be initialised. */ \
               for ( ii = idim; ii >= 1; ii-- ) { \
                  wtprod[ ii - 1 ] = wtprod[ ii ] * wt[ ii ]; \
               } \
\
/* Update the relevent output pixel. The pixel weight is formed by including \
   the weight factor for dimension zero, since this is not included in \
   the "wtprod" array. */ \
               pixwt = wtprod[ 0 ] * wt[ 0 ]; \
               pfac = pixwt*infac; \
               c = CONV(IntType,pfac*in_val); \
               out[ off_out ] += CONV(IntType, c ); \
               if( work ) work[ off_out ] += pixwt; \
               if ( Usevar ) { \
                  out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
               } else if ( Genvar && pixwt != 0.0 ) { \
                  out_var[ off_out ] += c*c/pixwt; \
                  work[ off_out + npix_out ] += pixwt*pixwt; \
               } \
\
/* Now update the indices, offset and weight factors to refer to the \
   next output pixel to be updated. */ \
               idim = 0; \
               do { \
\
/* The first input dimension which still refers to the pixel with the \
   lower of the two possible indices is switched to refer to the other \
   pixel (with the higher index). The offset into the output array and \
   the fractional weight factor for this dimension are also updated \
   accordingly. */ \
                  if ( dim[ idim ] != hi[ idim ] ) { \
                     dim[ idim ] = hi[ idim ]; \
                     off_out += stride[ idim ]; \
                     wt[ idim ] = frac_hi[ idim ]; \
                     break; \
\
/* Any earlier dimensions (referring to the higher index) are switched \
   back to the lower index, if not already there, before going on to \
   consider the next dimension. (This process is the same as \
   incrementing a binary number and propagating overflows up through \
   successive digits, except that dimensions where the "lo" and "hi" \
   values are the same can only take one value.) The process stops at \
   the first attempt to return the final dimension to the lower \
   index. */ \
                  } else { \
                     if ( dim[ idim ] != lo[ idim ] ) { \
                        dim[ idim ] = lo[ idim ]; \
                        off_out -= stride[ idim ]; \
                        wt[ idim ] = frac_lo[ idim ]; \
                     } \
                     done = ( ++idim == ndim_out ); \
                  } \
               } while ( !done ); \
            } while ( !done ); \
         } \
      } \
   }

/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_SPREAD_LINEAR(LD,long double,0)
#endif
MAKE_SPREAD_LINEAR(D,double,0)
MAKE_SPREAD_LINEAR(F,float,0)
MAKE_SPREAD_LINEAR(I,int,1)
MAKE_SPREAD_LINEAR(B,signed char,1)
MAKE_SPREAD_LINEAR(UB,unsigned char,1)

/* Undefine the macros used above. */
#undef LINEAR_1D
#undef LINEAR_2D
#undef LINEAR_ND
#undef MAKE_SPREAD_LINEAR

/*
*  Name:
*     SpreadNearest<X>

*  Purpose:
*     Rebin a data grid, using the nearest-pixel spreading scheme.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void SpreadNearest<X>( int ndim_out, const int *lbnd_out,
*                            const int *ubnd_out, const <Xtype> *in,
*                            const <Xtype> *in_var, double infac, int npoint,
*                            const int *offset, const double *const *coords,
*                            double conwgt, int flags, <Xtype> badval, int npix_out, <Xtype> *out,
*                            <Xtype> *out_var, double *work, int64_t *nused,
*                            int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This is a set of functions which rebins a rectangular region of an
*     input grid of data (and, optionally, associated statistical variance
*     values) so as to place them into a new output grid. Each input
*     grid point may be mapped on to a position in the output grid in
*     an arbitrary way. Where the positions given do not correspond
*     with a pixel centre in the output grid, the spreading scheme
*     used is simply to select the nearest pixel (i.e. the one whose
*     bounds contain the supplied position).

*  Parameters:
*     ndim_out
*        The number of dimensions in the output grid. This should be at
*        least one.
*     lbnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the output grid along each dimension.
*     ubnd_out
*        Pointer to an array of integers, with "ndim_out" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the output grid along each dimension.
*
*        Note that "lbnd_out" and "ubnd_out" together define the shape
*        and size of the output grid, its extent along a particular
*        (i'th) dimension being ubnd_out[i]-lbnd_out[i]+1 (assuming "i"
*        is zero-based). They also define the output grid's coordinate
*        system, with each pixel being of unit extent along each
*        dimension with integral coordinate values at its centre.
*     in
*        Pointer to the array of data to be rebinned. The numerical type
*        of these data should match the function used, as given by the
*        suffix on the function name. Note that details of how the input
*        grid maps on to this array (e.g. the storage order, number of
*        dimensions, etc.) is arbitrary and is specified entirely by means
*        of the "offset" array. The "in" array should therefore contain
*        sufficient elements to accommodate the "offset" values supplied.
*        There is no requirement that all elements of the "in" array
*        should be rebinned, and any which are not addressed by the
*        contents of the "offset" array will be ignored.
*     in_var
*        An optional pointer to a second array of positive numerical
*        values (with the same size and type as the "in" array), which
*        represent estimates of the statistical variance associated
*        with each element of the "in" array. If this second array is
*        given (along with the corresponding "out_var" array), then
*        estimates of the variance of the resampled data will also be
*        returned. It is addressed in exactly the same way (via the
*        "offset" array) as the "in" array.
*
*        If no variance estimates are required, a NULL pointer should
*        be given.
*     infac
*        A factor by which to multiply the input data values before use.
*     npoint
*        The number of input points which are to be rebinned.
*     offset
*        Pointer to an array of integers with "npoint" elements. For
*        each input point, this array should contain the zero-based
*        offset in the input array(s) (i.e. the "in" and, optionally,
*        the "in_var" arrays) from which the value to be rebinned should
*        be obtained.
*     coords
*        An array of pointers to double, with "ndim_out" elements.
*        Element "coords[coord]" should point at the first element of
*        an array of double (with "npoint" elements) which contains the
*        values of coordinate number "coord" for each point being
*        rebinned. The value of coordinate number "coord" for
*        rebinning point number "point" is therefore given by
*        "coords[coord][point]" (assuming both indices are
*        zero-based).  If any point has a coordinate value of AST__BAD
*        associated with it, then the corresponding input data (and
*        variance) value will be ignored.
*     conwgt
*        The initial weight to use for all pixels (typically 1.0). Other
*        weights (e.g. interpolation weights, variance weights, etc) are
*        applied as factors to this initial value.
*     flags
*        The bitwise OR of a set of flag values which control the
*        operation of the function. These are chosen from:
*
*        - AST__USEBAD: indicates whether there are "bad" (i.e. missing) data
*        in the input array(s) which must be recognised.  If this flag is not
*        set, all input values are treated literally.
*        - AST__GENVAR: Indicates that output variances should be generated
*        from the spread of values contributing to each output pixel.
*        - AST__USEVAR: Indicates that output variances should be generated
*        by rebinning the input variances.
*        - AST__VARWGT: Indicates that input variances should be used to
*        create weights for the input data values.
*
*        Only one of AST__GENVAR and AST__USEVAR should be supplied.
*     badval
*        If the AST__USEBAD flag is set in the "flags" value (above),
*        this parameter specifies the value which is used to identify
*        bad data and/or variance values in the input array(s). Its
*        numerical type must match that of the "in" (and "in_var")
*        arrays. The same value will also be used to flag any output
*        array elements for which resampled values could not be
*        obtained.  The output arrays(s) may be flagged with this
*        value whether or not the AST__USEBAD flag is set (the
*        function return value indicates whether any such values have
*        been produced).
*     npix_out
*        Number of pixels in output array.
*     out
*        Pointer to an array with the same data type as the "in"
*        array, into which the rebinned data will be returned. The
*        storage order should be such that the index of the first grid
*        dimension varies most rapidly and that of the final dimension
*        least rapidly (i.e. Fortran array storage order).
*     out_var
*        An optional pointer to an array with the same data type and
*        size as the "out" array, into which variance estimates for
*        the rebinned values may be returned. This array will only be
*        used if the "in_var" array has been given. The values returned
*        are estimates of the statistical variance of the corresponding
*        values in the "out" array, on the assumption that all errors in
*        input grid values (in the "in" array) are statistically independent
*        and that their variance estimates (in the "in_var" array) may
*        simply be summed (with appropriate weighting factors).
*
*        If no output variance estimates are required, a NULL pointer
*        should be given.
*     work
*        A pointer to an array with the same data type and size as the "out"
*        array which is used as work space. The values in the supplied
*        array are incremented on exit by the sum of the weights used
*        with each output pixel.
*     nused
*        An optional pointer to a size_t which will be incremented by the
*        number of input values pasted into the output array. Ignored if NULL.

*  Notes:
*     - There is a separate function for each numerical type of
*     gridded data, distinguished by replacing the <X> in the function
*     name by the appropriate 1- or 2-character suffix.
*/
/* Define a macro to implement the function for a specific data type. */
#define MAKE_SPREAD_NEAREST(X,Xtype,IntType) \
static void SpreadNearest##X( int ndim_out, \
                             const int *lbnd_out, const int *ubnd_out, \
                             const Xtype *in, const Xtype *in_var, \
                             double infac, int npoint, const int *offset, \
                             const double *const *coords, double conwgt, int flags, \
                             Xtype badval, int npix_out, Xtype *out, \
                             Xtype *out_var, double *work, int64_t *nused, \
                             int *status ) { \
\
/* Local Variables: */ \
   Xtype c;                      /* Contribution to output value */ \
   Xtype in_val;                 /* Input data value */ \
   double *xn_max;               /* Pointer to upper limits array (n-d) */ \
   double *xn_min;               /* Pointer to lower limits array (n-d) */ \
   double pfac;                  /* Input weight with extra supplied factor */ \
   double pixwt;                 /* Weight for input value */ \
   double x;                     /* x coordinate value */ \
   double xmax;                  /* x upper limit */ \
   double xmin;                  /* x lower limit */ \
   double xn;                    /* Coordinate value (n-d) */ \
   double y;                     /* y coordinate value */ \
   double ymax;                  /* y upper limit */ \
   double ymin;                  /* y lower limit */ \
   int *stride;                  /* Pointer to array of dimension strides */ \
   int bad;                      /* Output pixel bad? */ \
   int genvar;                   /* Generate output variances? */ \
   int idim;                     /* Loop counter for dimensions */ \
   int ix;                       /* Number of pixels offset in x direction */ \
   int ixn;                      /* Number of pixels offset (n-d) */ \
   int iy;                       /* Number of pixels offset in y direction */ \
   int off_in;                   /* Pixel offset into input array */ \
   int off_out;                  /* Pixel offset into output array */ \
   int point;                    /* Loop counter for output points */ \
   int s;                        /* Temporary variable for strides */ \
   int usebad;                   /* Use "bad" input pixel values? */ \
   int usevar;                   /* Process variance array? */ \
   int varwgt;                   /* Use input variances as weights? */ \
   int ystride;                  /* Stride along input grid y direction */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Determine if we are processing bad pixels or variances. */ \
   usebad = flags & AST__USEBAD; \
   usevar = 0; \
   genvar = 0; \
   if( flags & AST__GENVAR ) { \
      genvar = out_var && work; \
   } else if( flags & AST__USEVAR ) { \
      usevar = in_var && out_var; \
   } \
   varwgt = ( flags & AST__VARWGT ) && in_var && work; \
\
/* Handle the 1-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   if ( ndim_out == 1 ) { \
\
/* Calculate the coordinate limits of the output array. */ \
      xmin = (double) lbnd_out[ 0 ] - 0.5; \
      xmax = (double) ubnd_out[ 0 ] + 0.5; \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
      if( varwgt ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               NEAR_1D(X,Xtype,1,1,0,IntType,1) \
            } else if ( genvar ) { \
               NEAR_1D(X,Xtype,1,0,1,IntType,1) \
            } else { \
               NEAR_1D(X,Xtype,1,0,0,IntType,1) \
            } \
         } else { \
            if ( usevar ) { \
               NEAR_1D(X,Xtype,0,1,0,IntType,1) \
            } else if ( genvar ) { \
               NEAR_1D(X,Xtype,0,0,1,IntType,1) \
            } else { \
               NEAR_1D(X,Xtype,0,0,0,IntType,1) \
            } \
         } \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               NEAR_1D(X,Xtype,1,1,0,IntType,0) \
            } else if ( genvar ) { \
               NEAR_1D(X,Xtype,1,0,1,IntType,0) \
            } else { \
               NEAR_1D(X,Xtype,1,0,0,IntType,0) \
            } \
         } else { \
            if ( usevar ) { \
               NEAR_1D(X,Xtype,0,1,0,IntType,0) \
            } else if ( genvar ) { \
               NEAR_1D(X,Xtype,0,0,1,IntType,0) \
            } else { \
               NEAR_1D(X,Xtype,0,0,0,IntType,0) \
            } \
         } \
      } \
\
/* Handle the 2-dimensional case optimally. */ \
/* ---------------------------------------- */ \
   } else if ( ndim_out == 2 ) { \
\
/* Calculate the stride along the y dimension of the output grid. */ \
      ystride = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1; \
\
/* Calculate the coordinate limits of the output array in each \
   dimension. */ \
      xmin = (double) lbnd_out[ 0 ] - 0.5; \
      xmax = (double) ubnd_out[ 0 ] + 0.5; \
      ymin = (double) lbnd_out[ 1 ] - 0.5; \
      ymax = (double) ubnd_out[ 1 ] + 0.5; \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
      if( varwgt ) { \
         if ( usebad ) { \
            if ( usevar ) { \
               NEAR_2D(X,Xtype,1,1,0,IntType,1) \
            } else if ( genvar ) { \
               NEAR_2D(X,Xtype,1,0,1,IntType,1) \
            } else { \
               NEAR_2D(X,Xtype,1,0,0,IntType,1) \
            } \
         } else { \
            if ( usevar ) { \
               NEAR_2D(X,Xtype,0,1,0,IntType,1) \
            } else if ( genvar ) { \
               NEAR_2D(X,Xtype,0,0,1,IntType,1) \
            } else { \
               NEAR_2D(X,Xtype,0,0,0,IntType,1) \
            } \
         } \
      } else { \
         if ( usebad ) { \
            if ( usevar ) { \
               NEAR_2D(X,Xtype,1,1,0,IntType,0) \
            } else if ( genvar ) { \
               NEAR_2D(X,Xtype,1,0,1,IntType,0) \
            } else { \
               NEAR_2D(X,Xtype,1,0,0,IntType,0) \
            } \
         } else { \
            if ( usevar ) { \
               NEAR_2D(X,Xtype,0,1,0,IntType,0) \
            } else if ( genvar ) { \
               NEAR_2D(X,Xtype,0,0,1,IntType,0) \
            } else { \
               NEAR_2D(X,Xtype,0,0,0,IntType,0) \
            } \
         } \
      } \
\
/* Handle other numbers of dimensions. */ \
/* ----------------------------------- */ \
   } else { \
\
/* Allocate workspace. */ \
      stride = astMalloc( sizeof( int ) * (size_t) ndim_out ); \
      xn_max = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      xn_min = astMalloc( sizeof( double ) * (size_t) ndim_out ); \
      if ( astOK ) { \
\
/* Calculate the stride along each dimension of the output grid. */ \
         for ( s = 1, idim = 0; idim < ndim_out; idim++ ) { \
            stride[ idim ] = s; \
            s *= ubnd_out[ idim ] - lbnd_out[ idim ] + 1; \
\
/* Calculate the coordinate limits of the output grid in each \
   dimension. */ \
            xn_min[ idim ] = (double) lbnd_out[ idim ] - 0.5; \
            xn_max[ idim ] = (double) ubnd_out[ idim ] + 0.5; \
         } \
\
/* Identify eight cases, according to whether bad pixels and/or variances \
   are being processed and/or used. In each case we assign constant values \
   (0 or 1) to the "Usebad", "Usevar" and "Varwgt" flags so that code for \
   handling bad pixels and variances can be eliminated by the compiler's \
   optimisation system when not required. */ \
         if( varwgt ) { \
            if ( usebad ) { \
               if ( usevar ) { \
                  NEAR_ND(X,Xtype,1,1,0,IntType,1) \
               } else if ( genvar ) { \
                  NEAR_ND(X,Xtype,1,0,1,IntType,1) \
               } else { \
                  NEAR_ND(X,Xtype,1,0,0,IntType,1) \
               } \
            } else { \
               if ( usevar ) { \
                  NEAR_ND(X,Xtype,0,1,0,IntType,1) \
               } else if ( genvar ) { \
                  NEAR_ND(X,Xtype,0,0,1,IntType,1) \
               } else { \
                  NEAR_ND(X,Xtype,0,0,0,IntType,1) \
               } \
            } \
         } else { \
            if ( usebad ) { \
               if ( usevar ) { \
                  NEAR_ND(X,Xtype,1,1,0,IntType,0) \
               } else if ( genvar ) { \
                  NEAR_ND(X,Xtype,1,0,1,IntType,0) \
               } else { \
                  NEAR_ND(X,Xtype,1,0,0,IntType,0) \
               } \
            } else { \
               if ( usevar ) { \
                  NEAR_ND(X,Xtype,0,1,0,IntType,0) \
               } else if ( genvar ) { \
                  NEAR_ND(X,Xtype,0,0,1,IntType,0) \
               } else { \
                  NEAR_ND(X,Xtype,0,0,0,IntType,0) \
               } \
            } \
         } \
      } \
\
/* Free the workspace. */ \
      stride = astFree( stride ); \
      xn_max = astFree( xn_max ); \
      xn_min = astFree( xn_min ); \
   } \
\
}





#define NEAR_1D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
            for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
               off_in = offset[ point ]; \
               in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
               if ( Usebad ) { \
                  bad = ( in_val == badval ); \
                  if ( Varwgt ) { \
                     bad = bad || ( in_var[ off_in ] == badval ) \
                               || ( in_var[ off_in ] <= 0.0 ); \
                  } else if ( Usevar ) { \
                     bad = bad || ( in_var[ off_in ] == badval ); \
                  } \
               } else { \
                  if ( Varwgt ) { \
                     bad = ( in_var[ off_in ] <= 0.0 ); \
                  } else { \
                     bad = 0; \
                  } \
               } \
\
/* Obtain the output x coordinate corresponding to the centre of the \
   current input pixel and test if it lies outside the output grid, or \
   is bad. */ \
               x = coords[ 0 ][ point ]; \
               bad = bad || ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
               if ( !bad ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
                  if( nused ) (*nused)++; \
\
/* If not, then obtain the offset within the output grid of the pixel \
   which contains the current input point. */ \
                  off_out = (int) floor( x + 0.5 ) - lbnd_out[ 0 ]; \
\
/* If we are using the input data variances as weights, calculate the \
   weight. */ \
                  pixwt = conwgt; \
                  if( Varwgt ) pixwt *= 1.0/in_var[ off_in ]; \
\
/* Get the weighted input data value, including any extra scaling. */ \
                  pfac = pixwt*infac; \
                  c = CONV(IntType,pfac*in_val); \
\
/* Increment the value of this output pixel by the weighted input pixel \
   value, and increment the sum of the weights. */ \
                  out[ off_out ] += CONV(IntType, c ); \
                  if( work ) work[ off_out ] += pixwt; \
\
/* If output variances are being calculated on the basis of the input \
   variances, then we also store the required sum in "out_var". */ \
                  if( Usevar ) { \
                     out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
\
/* If output variances are being calculated on the basis of the spread of \
   input values, we need the sum of the squared weighted data values, the \
   sum of the weights (already in the first half of the "work" array), and \
   the sum of the squared weights. */ \
                  } else if( Genvar && pixwt != 0.0 ) { \
                     out_var[ off_out ] += c*c/pixwt; \
                     work[ off_out + npix_out ] += pixwt*pixwt; \
                  } \
               } \
            }






#define NEAR_2D(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
            for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
               off_in = offset[ point ]; \
               in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
               if ( Usebad ) { \
                  bad = ( in_val == badval ); \
                  if ( Varwgt ) { \
                     bad = bad || ( in_var[ off_in ] == badval ) \
                               || ( in_var[ off_in ] <= 0.0 ); \
                  } else if ( Usevar ) { \
                     bad = bad || ( in_var[ off_in ] == badval ); \
                  } \
               } else { \
                  if ( Varwgt ) { \
                     bad = ( in_var[ off_in ] <= 0.0 ); \
                  } else { \
                     bad = 0; \
                  } \
               } \
\
/* Obtain the output y coordinate corresponding to the centre of the \
   current input pixel and test if it lies outside the output grid, or \
   is bad. */ \
               y = coords[ 1 ][ point ]; \
               bad = bad || ( y < ymin ) || ( y >= ymax ) || ( y == AST__BAD ); \
               if ( !bad ) { \
\
/* Obtain the output x coordinate corresponding to the centre of the \
   current input pixel and test if it lies outside the output grid, or \
   is bad. */ \
                  x = coords[ 0 ][ point ]; \
                  bad = bad || ( x < xmin ) || ( x >= xmax ) || ( x == AST__BAD ); \
                  if ( !bad ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
                     if( nused ) (*nused)++; \
\
/* Obtain the offsets along each output grid dimension of the output \
   pixel which is to receive the input pixel value. */ \
                     ix = (int) floor( x + 0.5 ) - lbnd_out[ 0 ]; \
                     iy = (int) floor( y + 0.5 ) - lbnd_out[ 1 ]; \
\
/* Calculate this pixel's offset from the start of the output array. */ \
                     off_out = ix + ystride * iy; \
\
/* If we are using the input data variances as weights, calculate the \
   weight. */ \
                     pixwt = conwgt; \
                     if( Varwgt ) pixwt *= 1.0/in_var[ off_in ]; \
\
/* Get the weighted input data value, including any extra scaling. */ \
                     pfac = pixwt*infac; \
                     c = CONV(IntType,pfac*in_val); \
\
/* Increment the value of this output pixel by the weighted input pixel \
   value, and increment the sum of the weights. */ \
                     out[ off_out ] += CONV(IntType, c ); \
                     if( work ) work[ off_out ] += pixwt; \
\
/* If output variances are being calculated on the basis of the input \
   variances, then we also store the required sum in "out_var". */ \
                     if( Usevar ) { \
                        out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
\
/* If output variances are being calculated on the basis of the spread of \
   input values, we need the sum of the squared weighted data values, the \
   sum of the weights (already in the first half of the "work" array), and \
   the sum of the squared weights. */ \
                     } else if( Genvar && pixwt != 0.0 ) { \
                        out_var[ off_out ] += c*c/pixwt; \
                        work[ off_out + npix_out ] += pixwt*pixwt; \
                     } \
                  } \
               } \
            }



#define NEAR_ND(X,Xtype,Usebad,Usevar,Genvar,IntType,Varwgt) \
\
/* Loop round all input points which are to be rebinned. */ \
            for( point = 0; point < npoint; point++ ) { \
\
/* Obtain the input data value which is to be added into the output array. */ \
               off_in = offset[ point ]; \
               in_val = in[ off_in ]; \
\
/* If necessary, test if the input data value or variance is bad. If we \
   are using the reciprocal of the input variances as weights, then \
   variance values of zero are also effectively bad (but we can use input \
   variances of zero otherwise). */ \
               if ( Usebad ) { \
                  bad = ( in_val == badval ); \
                  if ( Varwgt ) { \
                     bad = bad || ( in_var[ off_in ] == badval ) \
                               || ( in_var[ off_in ] <= 0.0 ); \
                  } else if ( Usevar ) { \
                     bad = bad || ( in_var[ off_in ] == badval ); \
                  } \
               } else { \
                  if ( Varwgt ) { \
                     bad = ( in_var[ off_in ] <= 0.0 ); \
                  } else { \
                     bad = 0; \
                  } \
               } \
\
               if( !bad ) { \
\
/* Initialise the offset into the output array. Then loop to obtain \
   each coordinate associated with the current output point. */ \
                  off_out = 0; \
                  for ( idim = 0; idim < ndim_out; idim++ ) { \
                     xn = coords[ idim ][ point ]; \
\
/* Test if the coordinate lies outside the output grid, or is bad. If \
   either is true, the corresponding input pixel value will be ignored, \
   so give up on this point. */ \
                     bad = ( xn < xn_min[ idim ] ) || ( xn >= xn_max[ idim ] ) || \
                           ( xn == AST__BAD ); \
                     if ( bad ) { \
                         break; \
                     } \
\
/* Obtain the offset along the current output grid dimension of the \
   output pixel which is to receive the input pixel value. */ \
                     ixn = (int) floor( xn + 0.5 ) - lbnd_out[ idim ]; \
\
/* Accumulate this pixel's offset from the start of the output array. */ \
                     off_out += ixn * stride[ idim ]; \
                  } \
\
                  if( !bad ) { \
\
/* Increment the number of input pixels pasted into the output array. */ \
                     if( nused ) (*nused)++; \
\
/* If we are using the input data variances as weights, calculate the \
   weight. */ \
                     pixwt = conwgt; \
                     if( Varwgt ) pixwt *= 1.0/in_var[ off_in ]; \
\
/* Get the weighted input data value, including any extra scaling. */ \
                     pfac = pixwt*infac; \
                     c = CONV(IntType,pfac*in_val); \
\
/* Increment the value of this output pixel by the weighted input pixel \
   value, and increment the sum of the weights. */ \
                     out[ off_out ] += CONV(IntType, c ); \
                     if( work ) work[ off_out ] += pixwt; \
\
/* If output variances are being calculated on the basis of the input \
   variances, then we also store the required sum in "out_var". */ \
                     if( Usevar ) { \
                        out_var[ off_out ] += CONV(IntType,in_var[ off_in ]*pfac*pfac); \
\
/* If output variances are being calculated on the basis of the spread of \
   input values, we need the sum of the squared weighted data values, the \
   sum of the weights (already in the first half of the "work" array), and \
   the sum of the squared weights. */ \
                     } else if( Genvar && pixwt != 0.0 ) { \
                        out_var[ off_out ] += c*c/pixwt; \
                        work[ off_out + npix_out ] += pixwt*pixwt; \
                     } \
                  } \
               } \
            }






/* Expand the main macro above to generate a function for each
   required signed data type. */
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_SPREAD_NEAREST(LD,long double,0)
#endif

MAKE_SPREAD_NEAREST(D,double,0)
MAKE_SPREAD_NEAREST(F,float,0)
MAKE_SPREAD_NEAREST(I,int,1)
MAKE_SPREAD_NEAREST(B,signed char,1)
MAKE_SPREAD_NEAREST(UB,unsigned char,1)

/* Undefine the macros used above. */
#undef NEAR_ND
#undef NEAR_2D
#undef NEAR_1D
#undef MAKE_SPREAD_NEAREST






static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     TestAttrib

*  Purpose:
*     Test if a specified attribute value is set for a Mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     int TestAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Mapping member function (over-rides the astTestAttrib protected
*     method inherited from the Object class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     a value has been set for one of a Mapping's attributes.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     attrib
*        Pointer to a null terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if a value has been set, otherwise zero.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstMapping *this;             /* Pointer to the Mapping structure */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Obtain a pointer to the Mapping structure. */
   this = (AstMapping *) this_object;

/* Check the attribute name and test the appropriate attribute. */

/* Invert. */
/* ------- */
   if ( !strcmp( attrib, "invert" ) ) {
      result = astTestInvert( this );

/* Report. */
/* ------- */
   } else if ( !strcmp( attrib, "report" ) ) {
      result = astTestReport( this );

/* If the name is not recognised, test if it matches any of the
   read-only attributes of this class. If it does, then return
   zero. */
   } else if ( !strcmp( attrib, "nin" ) ||
        !strcmp( attrib, "islinear" ) ||
        !strcmp( attrib, "issimple" ) ||
        !strcmp( attrib, "nout" ) ||
        !strcmp( attrib, "tranforward" ) ||
        !strcmp( attrib, "traninverse" ) ) {
      result = 0;

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_testattrib)( this_object, attrib, status );
   }

/* Return the result, */
   return result;
}

static void Tran1( AstMapping *this, int npoint, const double xin[],
                   int forward, double xout[], int *status ) {
/*
*++
*  Name:
c     astTran1
f     AST_TRAN1

*  Purpose:
*     Transform 1-dimensional coordinates.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astTran1( AstMapping *this, int npoint, const double xin[],
c                    int forward, double xout[] )
f     CALL AST_TRAN1( THIS, NPOINT, XIN, FORWARD, XOUT, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function applies a Mapping to transform the coordinates of
f     This routine applies a Mapping to transform the coordinates of
*     a set of points in one dimension.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be applied.
c     npoint
f     NPOINT = INTEGER (Given)
*        The number of points to be transformed.
c     xin
f     XIN( NPOINT ) = DOUBLE PRECISION (Given)
c        An array of "npoint" coordinate values for the input
f        An array of coordinate values for the input
*        (untransformed) points.
c     forward
f     FORWARD = LOGICAL (Given)
c        A non-zero value indicates that the Mapping's forward
c        coordinate transformation is to be applied, while a zero
c        value indicates that the inverse transformation should be
c        used.
f        A .TRUE. value indicates that the Mapping's forward
f        coordinate transformation is to be applied, while a .FALSE.
f        value indicates that the inverse transformation should be
f        used.
c     xout
f     XOUT( NPOINT ) = DOUBLE PRECISION (Returned)
c        An array (with "npoint" elements) into which the
f        An array into which the
*        coordinates of the output (transformed) points will be written.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The Mapping supplied must have the value 1 for both its Nin
*     and Nout attributes.
*--
*/

/* Local Variables: */
   AstPointSet *in_points;       /* Pointer to input PointSet */
   AstPointSet *out_points;      /* Pointer to output PointSet */
   const double *in_ptr[ 1 ];    /* Array of input data pointers */
   double *out_ptr[ 1 ];         /* Array of output data pointers */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the Mapping and numbers of points/coordinates. */
   ValidateMapping( this, forward, npoint, 1, 1, "astTran1", status );

/* Set up pointers to the input and output coordinate arrays. */
   if ( astOK ) {
      in_ptr[ 0 ] = xin;
      out_ptr[ 0 ] = xout;

/* Create PointSets to describe the input and output points. */
      in_points = astPointSet( npoint, 1, "", status );
      out_points = astPointSet( npoint, 1, "", status );

/* Associate the data pointers with the PointSets (note we must
   explicitly remove the "const" qualifier from the input data here,
   although they will not be modified).  */
      astSetPoints( in_points, (double **) in_ptr );
      astSetPoints( out_points, out_ptr );

/* Apply the required transformation to the coordinates. */
      (void) astTransform( this, in_points, forward, out_points );

/* If the Mapping's Report attribute is set, report the effect the
   Mapping has had on the coordinates. */
      if ( astGetReport( this ) ) astReportPoints( this, forward,
                                                   in_points, out_points );

/* Delete the two PointSets. */
      in_points = astDelete( in_points );
      out_points = astDelete( out_points );
   }
}

static void Tran2( AstMapping *this,
                   int npoint, const double xin[], const double yin[],
                   int forward, double xout[], double yout[], int *status ) {
/*
*++
*  Name:
c     astTran2
f     AST_TRAN2

*  Purpose:
*     Transform 2-dimensional coordinates.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astTran2( AstMapping *this,
c                    int npoint, const double xin[], const double yin[],
c                    int forward, double xout[], double yout[] )
f     CALL AST_TRAN2( THIS, NPOINT, XIN, YIN, FORWARD, XOUT, YOUT, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function applies a Mapping to transform the coordinates of
f     This routine applies a Mapping to transform the coordinates of
*     a set of points in two dimensions.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be applied.
c     npoint
f     NPOINT = INTEGER (Given)
*        The number of points to be transformed.
c     xin
f     XIN( NPOINT ) = DOUBLE PRECISION (Given)
c        An array of "npoint" X-coordinate values for the input
f        An array of X-coordinate values for the input
*        (untransformed) points.
c     yin
f     YIN( NPOINT ) = DOUBLE PRECISION (Given)
c        An array of "npoint" Y-coordinate values for the input
f        An array of Y-coordinate values for the input
*        (untransformed) points.
c     forward
f     FORWARD = LOGICAL (Given)
c        A non-zero value indicates that the Mapping's forward
c        coordinate transformation is to be applied, while a zero
c        value indicates that the inverse transformation should be
c        used.
f        A .TRUE. value indicates that the Mapping's forward
f        coordinate transformation is to be applied, while a .FALSE.
f        value indicates that the inverse transformation should be
f        used.
c     xout
f     XOUT( NPOINT ) = DOUBLE PRECISION (Returned)
c        An array (with "npoint" elements) into which the
f        An array into which the
*        X-coordinates of the output (transformed) points will be written.
c     yout
f     YOUT( NPOINT ) = DOUBLE PRECISION (Returned)
c        An array (with "npoint" elements) into which the
f        An array into which the
*        Y-coordinates of the output (transformed) points will be written.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The Mapping supplied must have the value 2 for both its Nin
*     and Nout attributes.
*--
*/

/* Local Variables: */
   AstPointSet *in_points;       /* Pointer to input PointSet */
   AstPointSet *out_points;      /* Pointer to output PointSet */
   const double *in_ptr[ 2 ];    /* Array of input data pointers */
   double *out_ptr[ 2 ];         /* Array of output data pointers */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the Mapping and the numbers of points/coordinates. */
   ValidateMapping( this, forward, npoint, 2, 2, "astTran2", status );

/* Set up pointers to the input and output coordinate arrays. */
   if ( astOK ) {
      in_ptr[ 0 ] = xin;
      in_ptr[ 1 ] = yin;
      out_ptr[ 0 ] = xout;
      out_ptr[ 1 ] = yout;

/* Create PointSets to describe the input and output points. */
      in_points = astPointSet( npoint, 2, "", status );
      out_points = astPointSet( npoint, 2, "", status );

/* Associate the data pointers with the PointSets (note we must
   explicitly remove the "const" qualifier from the input data here,
   although they will not be modified).  */
      astSetPoints( in_points, (double **) in_ptr );
      astSetPoints( out_points, out_ptr );

/* Apply the required transformation to the coordinates. */
      (void) astTransform( this, in_points, forward, out_points );

/* If the Mapping's Report attribute is set, report the effect the
   Mapping has had on the coordinates. */
      if ( astGetReport( this ) ) astReportPoints( this, forward,
                                                   in_points, out_points );

/* Delete the two PointSets. */
      in_points = astDelete( in_points );
      out_points = astDelete( out_points );
   }
}

static void TranGrid( AstMapping *this, int ncoord_in, const int lbnd[],
                      const int ubnd[], double tol, int maxpix, int forward,
                      int ncoord_out, int outdim, double *out, int *status ) {
/*
*++
*  Name:
c     astTranGrid
f     AST_TRANGRID

*  Purpose:
*     Transform a grid of positions

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astTranGrid( AstMapping *this, int ncoord_in,
c                       const int lbnd[], const int ubnd[],
c                       double tol, int maxpix, int forward,
c                       int ncoord_out, int outdim, double *out );
f     CALL AST_TRANGRID( THIS, NCOORD_IN, LBND, UBND, TOL, MAXPIX,
f                        FORWARD, NCOORD_OUT, OUTDIM, OUT, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function uses the supplied Mapping to transforms a regular square
*     grid of points covering a specified box. It attempts to do this
*     quickly by first approximating the Mapping with a linear transformation
*     applied over the whole region of the input grid which is being used.
*     If this proves to be insufficiently accurate, the input region is
*     sub-divided into two along its largest dimension and the process is
*     repeated within each of the resulting sub-regions. This process of
*     sub-division continues until a sufficiently good linear approximation
*     is found, or the region to which it is being applied becomes too small
*     (in which case the original Mapping is used directly).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be applied.
c     ncoord_in
f     NCOORD_IN = INTEGER (Given)
*        The number of coordinates being supplied for each box corner
*        (i.e. the number of dimensions of the space in which the
*        input points reside).
c     lbnd
f     LBND( NCOORD_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ncoord_in" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
c     ubnd
f     UBND( NCOORD_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ncoord_in" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
c        Note that "lbnd" and "ubnd" together define the shape
f        Note that LBND and UBND together define the shape
*        and size of the input grid, its extent along a particular
c        (j'th) dimension being ubnd[j]-lbnd[j]+1 (assuming the
c        index "j" to be zero-based). They also define
f        (J'th) dimension being UBND(J)-LBND(J)+1. They also define
*        the input grid's coordinate system, each pixel having unit
*        extent along each dimension with integral coordinate values
*        at its centre.
c     tol
f     TOL = DOUBLE PRECISION (Given)
*        The maximum tolerable geometrical distortion which may be
*        introduced as a result of approximating non-linear Mappings
*        by a set of piece-wise linear transformations. This should be
*        expressed as a displacement within the output coordinate system
*        of the Mapping.
*
*        If piece-wise linear approximation is not required, a value
*        of zero may be given. This will ensure that the Mapping is
*        used without any approximation, but may increase execution
*        time.
*
*        If the value is too high, discontinuities between the linear
*        approximations used in adjacent panel will be higher. If this
*        is a problem, reduce the tolerance value used.
c     maxpix
f     MAXPIX = INTEGER (Given)
*        A value which specifies an initial scale size (in input grid points)
*        for the adaptive algorithm which approximates non-linear Mappings
*        with piece-wise linear transformations. Normally, this should
*        be a large value (larger than any dimension of the region of
*        the input grid being used). In this case, a first attempt to
*        approximate the Mapping by a linear transformation will be
*        made over the entire input region.
*
*        If a smaller value is used, the input region will first be
c        divided into sub-regions whose size does not exceed "maxpix"
f        divided into sub-regions whose size does not exceed MAXPIX
*        grid points in any dimension. Only at this point will attempts
*        at approximation commence.
*
*        This value may occasionally be useful in preventing false
*        convergence of the adaptive algorithm in cases where the
*        Mapping appears approximately linear on large scales, but has
*        irregularities (e.g. holes) on smaller scales. A value of,
*        say, 50 to 100 grid points can also be employed as a safeguard
*        in general-purpose software, since the effect on performance is
*        minimal.
*
*        If too small a value is given, it will have the effect of
*        inhibiting linear approximation altogether (equivalent to
c        setting "tol" to zero). Although this may degrade
f        setting TOL to zero). Although this may degrade
*        performance, accurate results will still be obtained.
c     forward
f     FORWARD = LOGICAL (Given)
c        A non-zero value indicates that the Mapping's forward
c        coordinate transformation is to be applied, while a zero
c        value indicates that the inverse transformation should be
c        used.
f        A .TRUE. value indicates that the Mapping's forward
f        coordinate transformation is to be applied, while a .FALSE.
f        value indicates that the inverse transformation should be
f        used.
c     ncoord_out
f     NCOORD_OUT = INTEGER (Given)
*        The number of coordinates being generated by the Mapping for
*        each output point (i.e. the number of dimensions of the
*        space in which the output points reside). This need not be
c        the same as "ncoord_in".
f        the same as NCOORD_IN.
c     outdim
f     OUTDIM = INTEGER (Given)
c        The number of elements along the second dimension of the "out"
f        The number of elements along the first dimension of the OUT
*        array (which will contain the output coordinates). The value
*        given should not be less than the number of points in the grid.
c     out
f     OUT( OUTDIM, NCOORD_OUT ) = DOUBLE PRECISION (Returned)
c        The address of the first element in a 2-dimensional array of
c        shape "[ncoord_out][outdim]", into
c        which the coordinates of the output (transformed) points will
c        be written. These will be stored such that the value of
c        coordinate number "coord" for output point number "point"
c        will be found in element "out[coord][point]".
f        An array into which the coordinates of the output
f        (transformed) points will be written. These will be stored
f        such that the value of coordinate number COORD for output
f        point number POINT will be found in element OUT(POINT,COORD).
*        The points are ordered such that the first axis of the input
*        grid changes most rapidly. For example, if the input grid is
*        2-dimensional and extends from (2,-1) to (3,1), the output
*        points will be stored in the order (2,-1), (3, -1), (2,0), (3,0),
*        (2,1), (3,1).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
c     - If the forward coordinate transformation is being applied, the
c     Mapping supplied must have the value of "ncoord_in" for its Nin
c     attribute and the value of "ncoord_out" for its Nout attribute. If
c     the inverse transformation is being applied, these values should
c     be reversed.
f     - If the forward coordinate transformation is being applied, the
f     Mapping supplied must have the value of NCOORD_IN for its Nin
f     attribute and the value of NCOORD_OUT for its Nout attribute. If
f     the inverse transformation is being applied, these values should
f     be reversed.
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Thread-specific data */
   AstMapping *simple;           /* Pointer to simplified Mapping */
   double **out_ptr;             /* Pointer to array of output data pointers */
   int coord;                    /* Loop counter for coordinates */
   int idim;                     /* Loop counter for coordinate dimensions */
   int npoint;                   /* Number of points in the grid */
   int64_t mpix;                 /* Number of points for testing */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to a structure holding thread-specific global data values */
   astGET_GLOBALS(this);

/* Calculate the number of points in the grid, and check that the lower and
   upper bounds of the input grid are consistent. Report an error if any
   pair is not. */
   mpix = 1;
   for ( idim = 0; idim < ncoord_in; idim++ ) {
      if ( lbnd[ idim ] > ubnd[ idim ] ) {
         astError( AST__GBDIN, "astTranGrid(%s): Lower bound of "
                   "input grid (%d) exceeds corresponding upper bound "
                   "(%d).", status, astGetClass( this ),
                   lbnd[ idim ], ubnd[ idim ] );
         astError( AST__GBDIN, "Error in input dimension %d.", status,
                   idim + 1 );
         break;
      } else {
         mpix *= ubnd[ idim ] - lbnd[ idim ] + 1;
      }
   }

/* Report an error if there are too many pixels in the input. */
   npoint = mpix;
   if ( astOK && npoint != mpix ) {
      astError( AST__EXSPIX, "astTranGrid(%s): Supplied grid "
                "contains too many points (%g): must be fewer than %d.",
                status, astGetClass( this ), (double) mpix, INT_MAX/ncoord_out );
   }

   mpix = outdim*ncoord_out;
   if ( astOK && (int) mpix != mpix ) {
      astError( AST__EXSPIX, "astTranGrid(%s): Supplied output array "
                "contains too many pixels (%g): must be fewer than %d.",
                status, astGetClass( this ), (double) mpix, INT_MAX );
   }


/* Validate the mapping and numbers of points/coordinates. */
   ValidateMapping( this, forward, npoint, ncoord_in, ncoord_out,
                    "astTranGrid", status );

/* Check that the positional accuracy tolerance supplied is valid and
   report an error if necessary. */
   if ( astOK && ( tol < 0.0 ) ) {
      astError( AST__PATIN, "astTranGrid(%s): Invalid positional "
                "accuracy tolerance (%.*g pixel).", status,
                astGetClass( this ), AST__DBL_DIG, tol );
      astError( AST__PATIN, "This value should not be less than zero." , status);
   }

/* Check that the initial scale size in grid points supplied is valid and
   report an error if necessary. */
   if ( astOK && ( maxpix < 0 ) ) {
      astError( AST__SSPIN, "astTranGrid(%s): Invalid initial scale "
                "size in grid points (%d).", status, astGetClass( this ), maxpix );
      astError( AST__SSPIN, "This value should not be less than zero." , status);
   }

/* Validate the output array dimension argument. */
   if ( astOK && ( outdim < npoint ) ) {
      astError( AST__DIMIN, "astTranGrid(%s): The output array dimension value "
                "(%d) is invalid.", status, astGetClass( this ), outdim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "grid points being transformed (%d).", status, npoint );
   }

/* If there are sufficient pixels to make it worthwhile, simplify the
   Mapping supplied to improve performance. Otherwise, just clone the
   Mapping pointer. Note we save a pointer to the original Mapping so
   that lower-level functions can use it if they need to report an error. */
   simple = NULL;
   unsimplified_mapping = this;
   if ( astOK ) {
      if ( npoint > 1024 ) {
         simple = astSimplify( this );

/* Report an error if the required transformation of this simplified
   Mapping is not defined. */
         if( astOK ) {
            if ( forward && !astGetTranForward( simple ) ) {
               astError( AST__TRNND, "astTranGrid(%s): A forward coordinate "
                         "transformation is not defined by the %s supplied.", status,
                         astGetClass( unsimplified_mapping ),
                         astGetClass( unsimplified_mapping ) );
            } else if ( !forward && !astGetTranInverse( simple ) ) {
               astError( AST__TRNND, "astTranGrid(%s): An inverse coordinate "
                         "transformation is not defined by the %s supplied.", status,
                         astGetClass( unsimplified_mapping ),
                         astGetClass( unsimplified_mapping ) );
            }
         }

      } else {
         simple = astClone( this );
      }

/* Allocate memory to hold the array of output data pointers. */
      out_ptr = astMalloc( sizeof( double * ) * (size_t) ncoord_out );

/* Initialise the output data pointers to point into the "out" array. */
      if ( astOK ) {
         for ( coord = 0; coord < ncoord_out; coord++ ) {
            out_ptr[ coord ] = out + coord * outdim;
         }

/* If required, temporarily invert the Mapping. */
         if( !forward ) astInvert( simple );

/* Perform the transformation. */
         TranGridAdaptively( simple, ncoord_in, lbnd, ubnd, lbnd, ubnd, tol,
                             maxpix, ncoord_out, out_ptr, status );

/* If required, uninvert the Mapping. */
         if( !forward ) astInvert( simple );

      }

/* Free the memory used for the data pointers. */
      out_ptr = astFree( out_ptr );

/* Annul the pointer to the simplified/cloned Mapping. */
      simple = astAnnul( simple );
   }
}

static void TranGridAdaptively( AstMapping *this, int ncoord_in,
                                const int *lbnd_in, const int *ubnd_in,
                                const int lbnd[], const int ubnd[],
                                double tol, int maxpix, int ncoord_out,
                                double *out[], int *status ){
/*
*  Name:
*     TranGridAdaptively

*  Purpose:
*     Transform grid positions adaptively.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void TranGridAdaptively( AstMapping *this, int ncoord_in,
*                              const int *lbnd_in, const int *ubnd_in,
*                              const int lbnd[], const int ubnd[],
*                              double tol, int maxpix, int ncoord_out,
*                              double *out[] )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function transforms grid points within a specified section of a
*     rectangular grid (with any number of dimensions) using the forward
*     transformation of the specified Mapping.
*
*     This function is very similar to TranGridWithBlocking and TranGridSection
*     which lie below it in the calling hierarchy. However, this function
*     also attempts to adapt to the Mapping supplied and to sub-divide the
*     section being transformed into smaller sections within which a linear
*     approximation to the Mapping may be used.  This reduces the number of
*     Mapping evaluations, thereby improving efficiency particularly when
*     complicated Mappings are involved.

*  Parameters:
*     this
*        Pointer to the Mapping to be applied. The forward transformation
*        is used.
*     ncoord_in
*        The number of coordinates being supplied for each box corner
*        (i.e. the number of dimensions of the space in which the
*        input points reside).
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the whole input grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     lbnd
*        Pointer to an array of integers, with "ncoord_in" elements,
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
*     ubnd
*        Pointer to an array of integers, with "ncoord_in" elements,
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
*        Note that "lbnd" and "ubnd" together define the shape
*        and size of the input grid, its extent along a particular
*        (j'th) dimension being ubnd[j]-lbnd[j]+1 (assuming the
*        index "j" to be zero-based). They also define
*        the input grid's coordinate system, each pixel having unit
*        extent along each dimension with integral coordinate values
*        at its centre.
*     tol
*        The maximum tolerable geometrical distortion which may be
*        introduced as a result of approximating non-linear Mappings
*        by a set of piece-wise linear transformations. This should be
*        expressed as a displacement in pixels in the output grid's
*        coordinate system.
*
*        If piece-wise linear approximation is not required, a value
*        of zero may be given. This will ensure that the Mapping is
*        used without any approximation, but may increase execution
*        time.
*
*        If the value is too high, discontinuities between the linear
*        approximations used in adjacent panel will be higher. If this
*        is a problem, reduce the tolerance value used.
*     maxpix
*        A value which specifies an initial scale size (in grid points)
*        for the adaptive algorithm which approximates non-linear Mappings
*        with piece-wise linear transformations. Normally, this should
*        be a large value (larger than any dimension of the region of
*        the input grid being used). In this case, a first attempt to
*        approximate the Mapping by a linear transformation will be
*        made over the entire input region.
*
*        If a smaller value is used, the input region will first be
*        divided into sub-regions whose size does not exceed "maxpix"
*        grid points in any dimension. Only at this point will attempts
*        at approximation commence.
*
*        This value may occasionally be useful in preventing false
*        convergence of the adaptive algorithm in cases where the
*        Mapping appears approximately linear on large scales, but has
*        irregularities (e.g. holes) on smaller scales. A value of,
*        say, 50 to 100 grid points can also be employed as a safeguard
*        in general-purpose software, since the effect on performance is
*        minimal.
*
*        If too small a value is given, it will have the effect of
*        inhibiting linear approximation altogether (equivalent to
*        setting "tol" to zero). Although this may degrade
*        performance, accurate results will still be obtained.
*     ncoord_out
*        The number of dimensions of the space in which the output points
*        reside.
*     out
*        Pointer to an array with "ndim_out" elements. Element [i] of
*        this array is a pointer to an array in which to store the
*        transformed values for output axis "i". The points are ordered
*        such that the first axis of the input grid changes most rapidly.
*        For example, if the input grid is 2-dimensional and extends from
*        (2,-1) to (3,1), the output points will be stored in the order
*        (2,-1), (3, -1), (2,0), (3,0), (2,1), (3,1).

*/

/* Local Variables: */
   double *flbnd;                /* Array holding floating point lower bounds */
   double *fubnd;                /* Array holding floating point upper bounds */
   double *linear_fit;           /* Pointer to array of fit coefficients */
   int *hi;                      /* Pointer to array of section upper bounds */
   int *lo;                      /* Pointer to array of section lower bounds */
   int coord_in;                 /* Loop counter for input coordinates */
   int dim;                      /* Output section dimension size */
   int dimx;                     /* Dimension with maximum section extent */
   int divide;                   /* Sub-divide the output section? */
   int i;                        /* Loop count */
   int isLinear;                 /* Is the transformation linear? */
   int mxdim;                    /* Largest output section dimension size */
   int npix;                     /* Number of pixels in output section */
   int npoint;                   /* Number of points for obtaining a fit */
   int nvertex;                  /* Number of vertices of output section */
   int toobig;                   /* Section too big (must sub-divide)? */
   int toosmall;                 /* Section too small to sub-divide? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Further initialisation. */
   npix = 1;
   mxdim = 0;
   dimx = 1;
   nvertex = 1;

/* Loop through the input grid dimensions. */
   for ( coord_in = 0; coord_in < ncoord_in; coord_in++ ) {

/* Obtain the extent in each dimension of the input section which is
   to be rebinned, and calculate the total number of pixels it contains. */
      dim = ubnd[ coord_in ] - lbnd[ coord_in ] + 1;
      npix *= dim;

/* Find the maximum dimension size of this input section and note which
   dimension has this size. */
      if ( dim > mxdim ) {
         mxdim = dim;
         dimx = coord_in;
      }

/* Calculate how many vertices the output section has. */
      nvertex *= 2;
   }

/* Calculate how many sample points will be needed (by the astLinearApprox
   function) to obtain a linear fit to the Mapping's forward transformation. */
   npoint = 1 + 4 * ncoord_in + 2 * nvertex;

/* If the number of pixels in the input section is not at least 4
   times this number, we will probably not save significant time by
   attempting to obtain a linear fit, so note that the input section
   is too small. */
   toosmall = ( npix < ( 4 * npoint ) );

/* Note if the maximum dimension of the input section exceeds the
   user-supplied scale factor. */
   toobig = ( maxpix < mxdim );

/* Assume the Mapping is significantly non-linear before deciding
   whether to sub-divide the output section. */
   linear_fit = NULL;

/* If the output section is too small to be worth obtaining a linear
   fit, or if the accuracy tolerance is zero, we will not
   sub-divide. This means that the Mapping will be used to transform
   each pixel's coordinates and no linear approximation will be
   used. */
   if ( toosmall || ( tol == 0.0 ) ) {
      divide = 0;

/* Otherwise, if the largest input section dimension exceeds the
   scale length given, we will sub-divide. This offers the possibility
   of obtaining a linear approximation to the Mapping over a reduced
   range of input coordinates (which will be handled by a recursive
   invocation of this function). */
   } else if ( toobig ) {
      divide = 1;

/* If neither of the above apply, then attempt to fit a linear
   approximation to the forward transformation of the Mapping over
   the range of coordinates covered by the input section. We need to
   temporarily copy the integer bounds into floating point arrays to
   use astLinearApprox. */
   } else {

/* Allocate memory for floating point bounds and for the coefficient array */
      flbnd = astMalloc( sizeof( double )*(size_t) ncoord_in );
      fubnd = astMalloc( sizeof( double )*(size_t) ncoord_in );
      linear_fit = astMalloc( sizeof( double )*
                              (size_t) ( ncoord_out*( ncoord_in + 1 ) ) );
      if( astOK ) {

/* Copy the bounds into these arrays, and change them so that they refer
   to the lower and upper edges of the cell rather than the centre. This
   is essential if one of the axes is spanned by a single cell, since
   otherwise the upper and lower bounds would be identical. */
         for( i = 0; i < ncoord_in; i++ ) {
            flbnd[ i ] = (double) lbnd[ i ] - 0.5;
            fubnd[ i ] = (double) ubnd[ i ] + 0.5;
         }

/* Get the linear approximation to the forward transformation. */
         isLinear = astLinearApprox( this, flbnd, fubnd, tol, linear_fit );

/* Free the coeff array if the inverse transformation is not linear. */
         if( !isLinear ) linear_fit = astFree( linear_fit );

      } else {
         linear_fit = astFree( linear_fit );
      }

/* Free resources */
      flbnd = astFree( flbnd );
      fubnd = astFree( fubnd );

/* If a linear fit was obtained, we will use it and therefore do not
   wish to sub-divide further. Otherwise, we sub-divide in the hope
   that this may result in a linear fit next time. */
      divide = !linear_fit;
   }

/* If no sub-division is required, perform the transformation (in a
   memory-efficient manner, since the section we are rebinning might
   still be very large). This will use the linear fit, if obtained
   above. */
   if ( astOK ) {
      if ( !divide ) {
         TranGridWithBlocking( this, linear_fit, ncoord_in, lbnd_in,
                               ubnd_in, lbnd, ubnd, ncoord_out, out, status );

/* Otherwise, allocate workspace to perform the sub-division. */
      } else {
         lo = astMalloc( sizeof( int ) * (size_t) ncoord_in );
         hi = astMalloc( sizeof( int ) * (size_t) ncoord_in );
         if ( astOK ) {

/* Initialise the bounds of a new input section to match the original
   input section. */
            for ( coord_in = 0; coord_in < ncoord_in; coord_in++ ) {
               lo[ coord_in ] = lbnd[ coord_in ];
               hi[ coord_in ] = ubnd[ coord_in ];
            }

/* Replace the upper bound of the section's largest dimension with the
   mid-point of the section along this dimension, rounded downwards. */
            hi[ dimx ] =
               (int) floor( 0.5 * (double) ( lbnd[ dimx ] + ubnd[ dimx ] ) );

/* Rebin the resulting smaller section using a recursive invocation
   of this function. */
            TranGridAdaptively( this, ncoord_in, lbnd_in, ubnd_in, lo, hi,
                                tol, maxpix, ncoord_out, out, status );

/* Now set up a second section which covers the remaining half of the
   original input section. */
            lo[ dimx ] = hi[ dimx ] + 1;
            hi[ dimx ] = ubnd[ dimx ];

/* If this section contains pixels, transform it in the same way. */
            if ( lo[ dimx ] <= hi[ dimx ] ) {
               TranGridAdaptively( this, ncoord_in, lbnd_in, ubnd_in, lo, hi,
                                   tol, maxpix, ncoord_out, out, status );
            }
         }

/* Free the workspace. */
         lo = astFree( lo );
         hi = astFree( hi );
      }
   }

/* If coefficients for a linear fit were obtained, then free the space
   they occupy. */
   if ( linear_fit ) linear_fit = astFree( linear_fit );
}

static void TranGridSection( AstMapping *this, const double *linear_fit,
                             int ndim_in, const int *lbnd_in,
                             const int *ubnd_in, const int *lbnd,
                             const int *ubnd, int ndim_out, double *out[], int *status ){
/*
*  Name:
*     TranGridSection

*  Purpose:
*     Transform grid points within a section of a rectangular grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void TranGridSection( AstMapping *this, const double *linear_fit,
*                           int ndim_in, const int *lbnd_in,
*                           const int *ubnd_in, const int *lbnd,
*                           const int *ubnd, int ndim_out, double *out[] )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function transforms grid points within a specified section of a
*     rectangular grid (with any number of dimensions) using a specified
*     Mapping or, alternatively, a linear approximation fitted to the
*     Mapping's forward transformation.

*  Parameters:
*     this
*        Pointer to a Mapping, whose forward transformation may be
*        used to transform the coordinates of points in the input
*        grid.
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's forward coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        forward transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input data grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input data grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the input data grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     lbnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the first pixel in the
*        section of the input data grid which is to be rebinned.
*     ubnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the last pixel in the
*        section of the input data grid which is to be rebinned.
*
*        Note that "lbnd" and "ubnd" define the shape and position of
*        the section of the input grid which is to be rebinned. This section
*        should lie wholly within the extent of the input grid (as defined
*        by the "lbnd_out" and "ubnd_out" arrays). Regions of the input
*        grid lying outside this section will be ignored.
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     out
*        Pointer to an array with "ndim_out" elements. Element [i] of
*        this array is a pointer to an array in which to store the
*        transformed values for output axis "i". The points are ordered
*        such that the first axis of the input grid changes most rapidly.
*        For example, if the input grid is 2-dimensional and extends from
*        (2,-1) to (3,1), the output points will be stored in the order
*        (2,-1), (3, -1), (2,0), (3,0), (2,1), (3,1).

*  Notes:
*     - This function does not take steps to limit memory usage if the
*     grids supplied are large. To resample large grids in a more
*     memory-efficient way, the ResampleWithBlocking function should
*     be used.
*/

/* Local Variables: */
   AstPointSet *pset_in;         /* Input PointSet for transformation */
   AstPointSet *pset_out;        /* Output PointSet for transformation */
   const double *grad;           /* Pointer to gradient matrix of linear fit */
   const double *zero;           /* Pointer to zero point array of fit */
   double **ptr_in;              /* Pointer to input PointSet coordinates */
   double **ptr_out;             /* Pointer to output PointSet coordinates */
   double *accum;                /* Pointer to array of accumulated sums */
   double x1;                    /* Interim x coordinate value */
   double xx1;                   /* Initial x coordinate value */
   double y1;                    /* Interim y coordinate value */
   double yy1;                   /* Initial y coordinate value */
   int *dim;                     /* Pointer to array of output pixel indices */
   int *offset;                  /* Pointer to array of output pixel offsets */
   int *stride;                  /* Pointer to array of output grid strides */
   int coord_in;                 /* Loop counter for input dimensions */
   int coord_out;                /* Loop counter for output dimensions */
   int done;                     /* All pixel indices done? */
   int i1;                       /* Interim offset into "accum" array */
   int i2;                       /* Final offset into "accum" array */
   int idim;                     /* Loop counter for dimensions */
   int ix;                       /* Loop counter for output x coordinate */
   int iy;                       /* Loop counter for output y coordinate */
   int npoint;                   /* Number of output points (pixels) */
   int off1;                     /* Interim pixel offset into output array */
   int off2;                     /* Interim pixel offset into output array */
   int off;                      /* Final pixel offset into output array */
   int point;                    /* Counter for output points (pixels ) */
   int s;                        /* Temporary variable for strides */

/* Check the global error status. */
   if ( !astOK ) return;

/* Further initialisation. */
   pset_in = NULL;
   ptr_in = NULL;
   ptr_out = NULL;
   pset_out = NULL;

/* Calculate the number of input points, as given by the product of
   the input grid dimensions. */
   for ( npoint = 1, coord_in = 0; coord_in < ndim_in; coord_in++ ) {
      npoint *= ubnd[ coord_in ] - lbnd[ coord_in ] + 1;
   }

/* Allocate workspace. */
   offset = astMalloc( sizeof( int ) * (size_t) npoint );
   stride = astMalloc( sizeof( int ) * (size_t) ndim_in );
   if ( astOK ) {

/* Calculate the stride for each input grid dimension. */
      off = 0;
      s = 1;
      for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
         stride[ coord_in ] = s;
         s *= ubnd_in[ coord_in ] - lbnd_in[ coord_in ] + 1;
      }

/* A linear fit to the Mapping is available. */
/* ========================================= */
      if ( linear_fit ) {

/* If a linear fit to the Mapping has been provided, then obtain
   pointers to the array of gradients and zero-points comprising the
   fit. */
         grad = linear_fit + ndim_out;
         zero = linear_fit;

/* Create a PointSet to hold the output grid coordinates and obtain an
   array of pointers to its coordinate data. */
         pset_out = astPointSet( npoint, ndim_out, "", status );
         ptr_out = astGetPoints( pset_out );
         if ( astOK ) {

/* Initialise the count of input points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ( ndim_in == 1 ) && ( ndim_out == 1 ) ) {

/* Loop through the pixels of the input grid and transform their x
   coordinates into the output grid's coordinate system using the
   linear fit supplied. Store the results in the PointSet created
   above. */
               off = lbnd[ 0 ] - lbnd_in[ 0 ];
               xx1 = zero[ 0 ] + grad[ 0 ] * (double) lbnd[ 0 ];

               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_out[ 0 ][ point ] = xx1;
                  xx1 += grad[ 0 ];
                  offset[ point++ ] = off++;
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ( ndim_in == 2 ) && ( ndim_out == 2 ) ) {

/* Loop through the range of y coordinates in the input grid and
   calculate interim values of the output coordinates using the linear
   fit supplied. */
               x1 = zero[ 0 ] + grad[ 1 ] * (double) ( lbnd[ 1 ] - 1 );
               y1 = zero[ 1 ] + grad[ 3 ] * (double) ( lbnd[ 1 ] - 1 );
               off1 = stride[ 1 ] * ( lbnd[ 1 ] - lbnd_in[ 1 ] - 1 ) - lbnd_in[ 0 ];
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  x1 += grad[ 1 ];
                  y1 += grad[ 3 ];

/* Also calculate an interim pixel offset into the input array. */
                  off1 += stride[ 1 ];

/* Now loop through the range of input x coordinates and calculate
   the final values of the input coordinates, storing the results in
   the PointSet created above. */
                  xx1 = x1 + grad[ 0 ] * (double) lbnd[ 0 ];
                  yy1 = y1 + grad[ 2 ] * (double) lbnd[ 0 ];
                  off = off1 + lbnd[ 0 ];
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_out[ 0 ][ point ] = xx1;
                     xx1 += grad[ 0 ];
                     ptr_out[ 1 ][ point ] = yy1;
                     yy1 += grad[ 2 ];

/* Also calculate final pixel offsets into the input array. */
                     offset[ point++ ] = off++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               accum = astMalloc( sizeof( double ) *
                                 (size_t) ( ndim_in * ndim_out ) );
               dim = astMalloc( sizeof( int ) * (size_t) ndim_in );
               if ( astOK ) {

/* Initialise an array of pixel indices for the input grid which refer to the
   first pixel which we will rebin. Also calculate the offset of this pixel
   within the input array. */
                  off = 0;
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     dim[ coord_in ] = lbnd[ coord_in ];
                     off += stride[ coord_in ] *
                            ( dim[ coord_in ] - lbnd_in[ coord_in ] );
                  }

/* To calculate each output grid coordinate we must perform a matrix
   multiply on the input grid coordinates (using the gradient matrix)
   and then add the zero points. However, since we will usually only
   be altering one input coordinate at a time (the least
   significant), we can avoid the full matrix multiply by accumulating
   partial sums for the most significant input coordinates and only
   altering those sums which need to change each time. The zero points
   never change, so we first fill the "most significant" end of the
   "accum" array with these. */
                  for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                     accum[ ( coord_out + 1 ) * ndim_in - 1 ] =
                                                              zero[ coord_out ];
                  }
                  coord_in = ndim_in - 1;

/* Now loop to process each input pixel. */
                  for ( done = 0; !done; point++ ) {

/* To generate the output coordinate that corresponds to the current
   input pixel, we work down from the most significant dimension
   whose index has changed since the previous pixel we considered
   (given by "coord_in"). For each affected dimension, we accumulate
   in "accum" the matrix sum (including the zero point) for that
   dimension and all higher input dimensions. We must accumulate a
   separate set of sums for each output coordinate we wish to
   produce. (Note that for the first pixel we process, all dimensions
   are considered "changed", so we start by initialising the whole
   "accum" array.) */
                     for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
                        i1 = coord_out * ndim_in;
                        for ( idim = coord_in; idim >= 1; idim-- ) {
                           i2 = i1 + idim;
                           accum[ i2 - 1 ] = accum[ i2 ] +
                                             dim[ idim ] * grad[ i2 ];
                        }

/* The output coordinate for each dimension is given by the accumulated
   sum for input dimension zero (giving the sum over all input
   dimensions). We do not store this in the "accum" array, but assign
   the result directly to the coordinate array of the PointSet created
   earlier. */
                        ptr_out[ coord_out ][ point ] = accum[ i1 ] +
                                                      dim[ 0 ] * grad[ i1 ];
                     }

/* Store the offset of the current pixel in the input array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next input pixel. */
                     coord_in = 0;
                     do {

/* The least significant index which currently has less than its maximum
   value is incremented by one. The offset into the input array is updated
   accordingly. */
                        if ( dim[ coord_in ] < ubnd[ coord_in ] ) {
                           dim[ coord_in ]++;
                           off += stride[ coord_in ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the input pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_in ] = lbnd[ coord_in ];
                           off -= stride[ coord_in ] *
                                  ( ubnd[ coord_in ] - lbnd[ coord_in ] );

/* All the output pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_in == ndim_in );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               accum = astFree( accum );
               dim = astFree( dim );
            }
         }

/* No linear fit to the Mapping is available. */
/* ========================================== */
      } else {

/* Create a PointSet to hold the coordinates of the input pixels and
   obtain a pointer to its coordinate data. */
         pset_in = astPointSet( npoint, ndim_in, "", status );
         ptr_in = astGetPoints( pset_in );
         if ( astOK ) {

/* Initialise the count of input points. */
            point = 0;

/* Handle the 1-dimensional case optimally. */
/* ---------------------------------------- */
            if ( ndim_in == 1 && ndim_out == 1 ) {

/* Loop through the required range of input x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   pixel offset into the input array. */
               for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                  ptr_in[ 0 ][ point ] = (double) ix;
                  offset[ point++ ] = ix - lbnd_in[ 0 ];
               }

/* Handle the 2-dimensional case optimally. */
/* ---------------------------------------- */
            } else if ( ndim_in == 2 && ndim_out == 2 ) {

/* Loop through the required range of input y coordinates,
   calculating an interim pixel offset into the input array. */
               off1 = stride[ 1 ] * ( lbnd[ 1 ] - lbnd_in[ 1 ] - 1 )
                      - lbnd_in[ 0 ];
               for ( iy = lbnd[ 1 ]; iy <= ubnd[ 1 ]; iy++ ) {
                  off1 += stride[ 1 ];

/* Loop through the required range of input x coordinates, assigning
   the coordinate values to the PointSet created above. Also store a
   final pixel offset into the input array. */
                  off2 = off1 + lbnd[ 0 ];
                  for ( ix = lbnd[ 0 ]; ix <= ubnd[ 0 ]; ix++ ) {
                     ptr_in[ 0 ][ point ] = (double) ix;
                     ptr_in[ 1 ][ point ] = (double) iy;
                     offset[ point++ ] = off2++;
                  }
               }

/* Handle other numbers of dimensions. */
/* ----------------------------------- */
            } else {

/* Allocate workspace. */
               dim = astMalloc( sizeof( int ) * (size_t) ndim_in );
               if ( astOK ) {

/* Initialise an array of pixel indices for the input grid which
   refer to the first pixel to be rebinned. Also calculate the offset
   of this pixel within the input array. */
                  off = 0;
                  for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                     dim[ coord_in ] = lbnd[ coord_in ];
                     off += stride[ coord_in ] *
                            ( dim[ coord_in ] - lbnd_in[ coord_in ] );
                  }

/* Loop to generate the coordinates of each input pixel. */
                  for ( done = 0; !done; point++ ) {

/* Copy each pixel's coordinates into the PointSet created above. */
                     for ( coord_in = 0; coord_in < ndim_in; coord_in++ ) {
                        ptr_in[ coord_in ][ point ] =
                                                     (double) dim[ coord_in ];
                     }

/* Store the offset of the pixel in the input array. */
                     offset[ point ] = off;

/* Now update the array of pixel indices to refer to the next input
   pixel. */
                     coord_in = 0;
                     do {

/* The least significant index which currently has less than its
   maximum value is incremented by one. The offset into the input
   array is updated accordingly. */
                        if ( dim[ coord_in ] < ubnd[ coord_in ] ) {
                           dim[ coord_in ]++;
                           off += stride[ coord_in ];
                           break;

/* Any less significant indices which have reached their maximum value
   are returned to their minimum value and the input pixel offset is
   decremented appropriately. */
                        } else {
                           dim[ coord_in ] = lbnd[ coord_in ];
                           off -= stride[ coord_in ] *
                                  ( ubnd[ coord_in ] - lbnd[ coord_in ] );

/* All the input pixels have been processed once the most significant
   pixel index has been returned to its minimum value. */
                           done = ( ++coord_in == ndim_in );
                        }
                     } while ( !done );
                  }
               }

/* Free the workspace. */
               dim = astFree( dim );
            }

/* When all the input pixel coordinates have been generated, use the
   Mapping's forward transformation to generate the output coordinates
   from them. Obtain an array of pointers to the resulting coordinate
   data. */
            pset_out = astTransform( this, pset_in, 1, NULL );
            ptr_out = astGetPoints( pset_out );
         }

/* Annul the PointSet containing the input coordinates. */
         pset_in = astAnnul( pset_in );
      }
   }

/* Copy the output coordinates into the correct positions within the
   supplied "out" array. */
/* ================================================================= */
   if( astOK ) {
      for ( coord_out = 0; coord_out < ndim_out; coord_out++ ) {
         for ( point = 0; point < npoint; point++ ) {
            out[ coord_out ][ offset[ point ] ] = ptr_out[ coord_out ][ point ];
         }
      }
   }

/* Annul the PointSet used to hold output coordinates. */
   pset_out = astAnnul( pset_out );

/* Free the workspace. */
   offset = astFree( offset );
   stride = astFree( stride );
}

static void TranGridWithBlocking( AstMapping *this, const double *linear_fit,
                                  int ndim_in, const int *lbnd_in,
                                  const int *ubnd_in, const int *lbnd,
                                  const int *ubnd, int ndim_out,
                                  double *out[], int *status ){
/*
*  Name:
*     TranGridWithBlocking

*  Purpose:
*     Transforms positions in a section of a grid in a memory-efficient way.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void TranGridWithBlocking( AstMapping *this, const double *linear_fit,
*                                int ndim_in, const int *lbnd_in,
*                                const int *ubnd_in, const int *lbnd,
*                                const int *ubnd, int ndim_out,
*                                double *out[], int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function transforms positions within a specified section of a
*     rectangular grid (with any number of dimensions) using the forward
*     transformation of the supplied Mapping.
*
*     This function is very similar to TranGridSection, except that in
*     order to limit memory usage and to ensure locality of reference,
*     it divides the input grid up into "blocks" which have a limited
*     extent along each input dimension. Each block, which will not
*     contain more than a pre-determined maximum number of pixels, is
*     then passed to TranGridSection for transformation.

*  Parameters:
*     this
*        Pointer to a Mapping, whose forward transformation may be
*        used to transform the coordinates of pixels in the input
*        grid into associated positions in the output grid.
*
*        The number of input coordintes for the Mapping (Nin
*        attribute) should match the value of "ndim_in" (below), and
*        the number of output coordinates (Nout attribute) should
*        match the value of "ndim_out".
*     linear_fit
*        Pointer to an optional array of double which contains the
*        coefficients of a linear fit which approximates the above
*        Mapping's forward coordinate transformation. If this is
*        supplied, it will be used in preference to the above Mapping
*        when transforming coordinates. This may be used to enhance
*        performance in cases where evaluation of the Mapping's
*        forward transformation is expensive. If no linear fit is
*        available, a NULL pointer should be supplied.
*
*        The way in which the fit coefficients are stored in this
*        array and the number of array elements are as defined by the
*        astLinearApprox function.
*     ndim_in
*        The number of dimensions in the input grid. This should be at
*        least one.
*     lbnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the first
*        pixel in the input grid along each dimension.
*     ubnd_in
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the centre of the last
*        pixel in the input grid along each dimension.
*
*        Note that "lbnd_in" and "ubnd_in" together define the shape
*        and size of the whole input grid, its extent along a
*        particular (i'th) dimension being (ubnd_in[i] - lbnd_in[i] +
*        1). They also define the input grid's coordinate system, with
*        each pixel being of unit extent along each dimension with
*        integral coordinate values at its centre.
*     lbnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the first pixel in the
*        section of the input data grid which is to be transformed.
*     ubnd
*        Pointer to an array of integers, with "ndim_in" elements.
*        This should give the coordinates of the last pixel in the
*        section of the input data grid which is to be transformed.
*
*        Note that "lbnd" and "ubnd" define the shape and position of the
*        section of the input grid which is to be transformed.
*     ndim_out
*        The number of dimensions in the output grid. This should be
*        at least one.
*     out
*        Pointer to an array with "ndim_out" elements. Element [i] of
*        this array is a pointer to an array in which to store the
*        transformed values for output axis "i". The points are ordered
*        such that the first axis of the input grid changes most rapidly.
*        For example, if the input grid is 2-dimensional and extends from
*        (2,-1) to (3,1), the output points will be stored in the order
*        (2,-1), (3, -1), (2,0), (3,0), (2,1), (3,1).
*     status
*        Pointer to the inherited status variable.

*/

/* Local Constants: */
   const int mxpix = 2 * 1024;   /* Maximum number of pixels in a block (this
                                    relatively small number seems to give best
                                    performance) */

/* Local Variables: */
   int *dim_block;               /* Pointer to array of block dimensions */
   int *lbnd_block;              /* Pointer to block lower bound array */
   int *ubnd_block;              /* Pointer to block upper bound array */
   int dim;                      /* Dimension size */
   int done;                     /* All blocks rebinned? */
   int hilim;                    /* Upper limit on maximum block dimension */
   int idim;                     /* Loop counter for dimensions */
   int lolim;                    /* Lower limit on maximum block dimension */
   int mxdim_block;              /* Maximum block dimension */
   int npix;                     /* Number of pixels in block */

/* Check the global error status. */
   if ( !astOK ) return;

/* Allocate workspace. */
   lbnd_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   ubnd_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   dim_block = astMalloc( sizeof( int ) * (size_t) ndim_in );
   if ( astOK ) {

/* Find the optimum block size. */
/* ---------------------------- */
/* We first need to find the maximum extent which a block of input
   pixels may have in each dimension. We determine this by taking the
   input grid extent in each dimension and then limiting the maximum
   dimension size until the resulting number of pixels is sufficiently
   small. This approach allows the block shape to approximate (or
   match) the input grid shape when appropriate. */

/* First loop to calculate the total number of input pixels and the
   maximum input dimension size. */
      npix = 1;
      mxdim_block = 0;
      for ( idim = 0; idim < ndim_in; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         npix *= dim;
         if ( mxdim_block < dim ) mxdim_block = dim;
      }

/* If the number of input pixels is too large for a single block, we
   perform iterations to determine the optimum upper limit on a
   block's dimension size. Initialise the limits on this result. */
      if ( npix > mxpix ) {
         lolim = 1;
         hilim = mxdim_block;

/* Loop to perform a binary chop, searching for the best result until
   the lower and upper limits on the result converge to adjacent
   values. */
         while ( ( hilim - lolim ) > 1 ) {

/* Form a new estimate from the mid-point of the previous limits. */
            mxdim_block = ( hilim + lolim ) / 2;

/* See how many pixels a block contains if its maximum dimension is
   limited to this new value. */
            for ( npix = 1, idim = 0; idim < ndim_in; idim++ ) {
               dim = ubnd[ idim ] - lbnd[ idim ] + 1;
               npix *= ( dim < mxdim_block ) ? dim : mxdim_block;
            }

/* Update the appropriate limit, according to whether the number of
   pixels is too large or too small. */
            *( ( npix <= mxpix ) ? &lolim : &hilim ) = mxdim_block;
         }

/* When iterations have converged, obtain the maximum limit on the
   dimension size of a block which results in no more than the maximum
   allowed number of pixels per block. However, ensure that all block
   dimensions are at least 2. */
            mxdim_block = lolim;
      }
      if ( mxdim_block < 2 ) mxdim_block = 2;

/* Calculate the block dimensions by applying this limit to the output
   grid dimensions. */
      for ( idim = 0; idim < ndim_in; idim++ ) {
         dim = ubnd[ idim ] - lbnd[ idim ] + 1;
         dim_block[ idim ] = ( dim < mxdim_block ) ? dim : mxdim_block;

/* Also initialise the lower and upper bounds of the first block of
   output grid pixels to be rebinned, ensuring that this does not
   extend outside the grid itself. */
         lbnd_block[ idim ] = lbnd[ idim ];
         ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                    ubnd[ idim ], status );
      }

/* Transform each block of input grid positions. */
/* --------------------------------------------- */
/* Loop to generate the extent of each block of input grid positions and to
   transform them. */
      done = 0;
      while ( !done && astOK ) {

/* Rebin the current block, accumulating the sum of bad pixels produced. */
         TranGridSection( this, linear_fit, ndim_in, lbnd_in, ubnd_in,
                          lbnd_block, ubnd_block, ndim_out, out, status );

/* Update the block extent to identify the next block of input pixels. */
         idim = 0;
         do {

/* We find the least significant dimension where the upper bound of
   the block has not yet reached the upper bound of the region of the
   input grid which we are rebinning. The block's position is then
   incremented by one block extent along this dimension, checking that
   the resulting extent does not go outside the region being rebinned. */
            if ( ubnd_block[ idim ] < ubnd[ idim ] ) {
               lbnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ], ubnd[ idim ], status );
               ubnd_block[ idim ] = MinI( lbnd_block[ idim ] +
                                          dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );
               break;

/* If any less significant dimensions are found where the upper bound
   of the block has reached its maximum value, we reset the block to
   its lowest position. */
            } else {
               lbnd_block[ idim ] = lbnd[ idim ];
               ubnd_block[ idim ] = MinI( lbnd[ idim ] + dim_block[ idim ] - 1,
                                          ubnd[ idim ], status );

/* All the blocks have been processed once the position along the most
   significant dimension has been reset. */
               done = ( ++idim == ndim_in );
            }
         } while ( !done );
      }
   }

/* Free the workspace. */
   lbnd_block = astFree( lbnd_block );
   ubnd_block = astFree( ubnd_block );
   dim_block = astFree( dim_block );
}

static void TranN( AstMapping *this, int npoint,
                   int ncoord_in, int indim, const double *in,
                   int forward,
                   int ncoord_out, int outdim, double *out, int *status ) {
/*
*++
*  Name:
c     astTranN
f     AST_TRANN

*  Purpose:
*     Transform N-dimensional coordinates.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astTranN( AstMapping *this, int npoint,
c                    int ncoord_in, int indim, const double *in,
c                    int forward,
c                    int ncoord_out, int outdim, double *out )
f     CALL AST_TRANN( THIS, NPOINT,
f                     NCOORD_IN, INDIM, IN,
f                     FORWARD, NCOORD_OUT, OUTDIM, OUT, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function applies a Mapping to transform the coordinates of
f     This routine applies a Mapping to transform the coordinates of
*     a set of points in an arbitrary number of dimensions. It is the
*     appropriate routine to use if the coordinates are not purely 1-
*     or 2-dimensional and are stored in a single array (which they
*     need not fill completely).
c
c     If the coordinates are not stored in a single array, then the
c     astTranP function might be more suitable.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be applied.
c     npoint
f     NPOINT = INTEGER (Given)
*        The number of points to be transformed.
c     ncoord_in
f     NCOORD_IN = INTEGER (Given)
*        The number of coordinates being supplied for each input point
*        (i.e. the number of dimensions of the space in which the
*        input points reside).
c     indim
f     INDIM = INTEGER (Given)
c        The number of elements along the second dimension of the "in"
f        The number of elements along the first dimension of the IN
*        array (which contains the input coordinates). This value is
*        required so that the coordinate values can be correctly
*        located if they do not entirely fill this array. The value
c        given should not be less than "npoint".
f        given should not be less than NPOINT.
c     in
f     IN( INDIM, NCOORD_IN ) = DOUBLE PRECISION (Given)
c        The address of the first element in a 2-dimensional array of
c        shape "[ncoord_in][indim]",
c        containing the coordinates of the input (untransformed)
c        points. These should be stored such that the value of
c        coordinate number "coord" for input point number "point" is
c        found in element "in[coord][point]".
f        An array containing the coordinates of the input
f        (untransformed) points. These should be stored such that the
f        value of coordinate number COORD for input point number POINT
f        is found in element IN(POINT,COORD).
c     forward
f     FORWARD = LOGICAL (Given)
c        A non-zero value indicates that the Mapping's forward
c        coordinate transformation is to be applied, while a zero
c        value indicates that the inverse transformation should be
c        used.
f        A .TRUE. value indicates that the Mapping's forward
f        coordinate transformation is to be applied, while a .FALSE.
f        value indicates that the inverse transformation should be
f        used.
c     ncoord_out
f     NCOORD_OUT = INTEGER (Given)
*        The number of coordinates being generated by the Mapping for
*        each output point (i.e. the number of dimensions of the
*        space in which the output points reside). This need not be
c        the same as "ncoord_in".
f        the same as NCOORD_IN.
c     outdim
f     OUTDIM = INTEGER (Given)
c        The number of elements along the second dimension of the "out"
f        The number of elements along the first dimension of the OUT
*        array (which will contain the output coordinates). This value
*        is required so that the coordinate values can be correctly
*        located if they will not entirely fill this array. The value
c        given should not be less than "npoint".
f        given should not be less than NPOINT.
c     out
f     OUT( OUTDIM, NCOORD_OUT ) = DOUBLE PRECISION (Returned)
c        The address of the first element in a 2-dimensional array of
c        shape "[ncoord_out][outdim]", into
c        which the coordinates of the output (transformed) points will
c        be written. These will be stored such that the value of
c        coordinate number "coord" for output point number "point"
c        will be found in element "out[coord][point]".
f        An array into which the coordinates of the output
f        (transformed) points will be written. These will be stored
f        such that the value of coordinate number COORD for output
f        point number POINT will be found in element OUT(POINT,COORD).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
c     - If the forward coordinate transformation is being applied, the
c     Mapping supplied must have the value of "ncoord_in" for its Nin
c     attribute and the value of "ncoord_out" for its Nout attribute. If
c     the inverse transformation is being applied, these values should
c     be reversed.
f     - If the forward coordinate transformation is being applied, the
f     Mapping supplied must have the value of NCOORD_IN for its Nin
f     attribute and the value of NCOORD_OUT for its Nout attribute. If
f     the inverse transformation is being applied, these values should
f     be reversed.
*--
*/

/* Local Variables: */
   AstPointSet *in_points;       /* Pointer to input PointSet */
   AstPointSet *out_points;      /* Pointer to output PointSet */
   const double **in_ptr;        /* Pointer to array of input data pointers */
   double **out_ptr;             /* Pointer to array of output data pointers */
   int coord;                    /* Loop counter for coordinates */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the mapping and numbers of points/coordinates. */
   ValidateMapping( this, forward, npoint, ncoord_in, ncoord_out, "astTranN", status );

/* Also validate the input array dimension argument. */
   if ( astOK && ( indim < npoint ) ) {
      astError( AST__DIMIN, "astTranN(%s): The input array dimension value "
                "(%d) is invalid.", status, astGetClass( this ), indim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "points being transformed (%d).", status, npoint );
   }

/* Similarly, validate the output array dimension argument. */
   if ( astOK && ( outdim < npoint ) ) {
      astError( AST__DIMIN, "astTranN(%s): The output array dimension value "
                "(%d) is invalid.", status, astGetClass( this ), outdim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "points being transformed (%d).", status, npoint );
   }

/* Allocate memory to hold the arrays of input and output data
   pointers. */
   if ( astOK ) {
      in_ptr = (const double **) astMalloc( sizeof( const double * ) *
                                            (size_t) ncoord_in );
      out_ptr = astMalloc( sizeof( double * ) * (size_t) ncoord_out );


#ifdef DEBUG
      { int i, ns;
        ns = ncoord_out*outdim;
        for( i = 0; i < ns; i++ ) out[ i ] = 0.0;
      }
#endif


/* Initialise the input data pointers to locate the coordinate data in
   the "in" array. */
      if ( astOK ) {
         for ( coord = 0; coord < ncoord_in; coord++ ) {
            in_ptr[ coord ] = in + coord * indim;
         }

/* Similarly initialise the output data pointers to point into the
   "out" array. */
         for ( coord = 0; coord < ncoord_out; coord++ ) {
            out_ptr[ coord ] = out + coord * outdim;
         }

/* Create PointSets to describe the input and output points. */
         in_points = astPointSet( npoint, ncoord_in, "", status );
         out_points = astPointSet( npoint, ncoord_out, "", status );

/* Associate the data pointers with the PointSets (note we must
   explicitly remove the "const" qualifier from the input data here,
   although they will not be modified).  */
         astSetPoints( in_points, (double **) in_ptr );
         astSetPoints( out_points, out_ptr );

/* Apply the required transformation to the coordinates. */
         (void) astTransform( this, in_points, forward, out_points );

/* If the Mapping's Report attribute is set, report the effect the
   Mapping has had on the coordinates. */
         if ( astGetReport( this ) ) astReportPoints( this, forward,
                                                      in_points, out_points );

/* Delete the two PointSets. */
         in_points = astDelete( in_points );
         out_points = astDelete( out_points );
      }

/* Free the memory used for the data pointers. */
      in_ptr = (const double **) astFree( (void *) in_ptr );
      out_ptr = astFree( out_ptr );
   }
}

static void TranP( AstMapping *this, int npoint,
                   int ncoord_in, const double *ptr_in[],
                   int forward, int ncoord_out, double *ptr_out[], int *status ) {
/*
c++
*  Name:
*     astTranP

*  Purpose:
*     Transform N-dimensional coordinates held in separate arrays.

*  Type:
*     Public virtual function.

*  Synopsis:
*     #include "mapping.h"
*     void astTranP( AstMapping *this, int npoint,
*                    int ncoord_in, const double *ptr_in[],
*                    int forward, int ncoord_out, double *ptr_out[] )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function applies a Mapping to transform the coordinates of
*     a set of points in an arbitrary number of dimensions. It is the
*     appropriate routine to use if the coordinates are not purely 1-
*     or 2-dimensional and are stored in separate arrays, since each
*     coordinate array is located by supplying a separate pointer to
*     it.
*
*     If the coordinates are stored in a single (2-dimensional) array,
*     then the astTranN function might be more suitable.

*  Parameters:
*     this
*        Pointer to the Mapping to be applied.
*     npoint
*        The number of points to be transformed.
*     ncoord_in
*        The number of coordinates being supplied for each input point
*        (i.e. the number of dimensions of the space in which the
*        input points reside).
*     ptr_in
*        An array of pointers to double, with "ncoord_in"
*        elements. Element "ptr_in[coord]" should point at the first
*        element of an array of double (with "npoint" elements) which
*        contain the values of coordinate number "coord" for each
*        input (untransformed) point. The value of coordinate number
*        "coord" for input point number "point" is therefore given by
*        "ptr_in[coord][point]" (assuming both indices are
*        zero-based).
*     forward
*        A non-zero value indicates that the Mapping's forward
*        coordinate transformation is to be applied, while a zero
*        value indicates that the inverse transformation should be
*        used.
*     ncoord_out
*        The number of coordinates being generated by the Mapping for
*        each output point (i.e. the number of dimensions of the space
*        in which the output points reside). This need not be the same
*        as "ncoord_in".
*     ptr_out
*        An array of pointers to double, with "ncoord_out"
*        elements. Element "ptr_out[coord]" should point at the first
*        element of an array of double (with "npoint" elements) into
*        which the values of coordinate number "coord" for each output
*        (transformed) point will be written.  The value of coordinate
*        number "coord" for output point number "point" will therefore
*        be found in "ptr_out[coord][point]".

*  Notes:
*     - If the forward coordinate transformation is being applied, the
*     Mapping supplied must have the value of "ncoord_in" for its Nin
*     attribute and the value of "ncoord_out" for its Nout
*     attribute. If the inverse transformation is being applied, these
*     values should be reversed.
*     - This routine is not available in the Fortran 77 interface to
*     the AST library.
c--
*/

/* Local Variables: */
   AstPointSet *in_points;       /* Pointer to input PointSet */
   AstPointSet *out_points;      /* Pointer to output PointSet */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the Mapping and number of points/coordinates. */
   ValidateMapping( this, forward, npoint, ncoord_in, ncoord_out, "astTranP", status );

/* Create PointSets to describe the input and output points. */
   if ( astOK ) {
      in_points = astPointSet( npoint, ncoord_in, "", status );
      out_points = astPointSet( npoint, ncoord_out, "", status );

/* Associate the data pointers with the PointSets (note we must
   explicitly remove the "const" qualifier from the input data here,
   although they will not be modified).  */
      astSetPoints( in_points, (double **) ptr_in );
      astSetPoints( out_points, ptr_out );

/* Apply the required transformation to the coordinates. */
      (void) astTransform( this, in_points, forward, out_points );

/* If the Mapping's Report attribute is set, report the effect the
   Mapping has had on the coordinates. */
      if ( astGetReport( this ) ) astReportPoints( this, forward,
                                                   in_points, out_points );

/* Delete the two PointSets. */
      in_points = astDelete( in_points );
      out_points = astDelete( out_points );
   }
}

static AstPointSet *Transform( AstMapping *this, AstPointSet *in,
                               int forward, AstPointSet *out, int *status ) {
/*
*+
*  Name:
*     astTransform

*  Purpose:
*     Transform a set of points.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "mapping.h"
*     AstPointSet *astTransform( AstMapping *this, AstPointSet *in,
*                                int forward, AstPointSet *out )

*  Class Membership:
*     Mapping method.

*  Description:
*     This function takes a Mapping and a set of points encapsulated
*     in a PointSet, and applies either the forward or inverse
*     coordinate transformation (if defined by the Mapping) to the
*     points.

*  Parameters:
*     this
*        Pointer to the Mapping. The nature of the coordinate
*        transformation will depend on the class of Mapping
*        supplied. Note that there is no constructor for the Mapping
*        class itself, so this object should be from a derived class.
*     in
*        Pointer to the PointSet holding the input coordinate data.
*     forward
*        A non-zero value indicates that the forward coordinate
*        transformation should be applied, while a zero value requests
*        the inverse transformation.
*     out
*        Pointer to a PointSet which will hold the transformed
*        (output) coordinate values. A NULL value may also be given,
*        in which case a new PointSet will be created by this
*        function.

*  Returned Value:
*     Pointer to the output (possibly new) PointSet.

*  Notes:
*     - An error will result if the Mapping supplied does not define
*     the requested coordinate transformation (either forward or
*     inverse).
*     - The number of coordinate values per point in the input
*     PointSet must match the number of input coordinates for the
*     Mapping being applied (or number of output coordinates if the
*     inverse transformation is requested).
*     - If an output PointSet is supplied, it must have space for
*     sufficient number of points and coordinate values per point to
*     accommodate the result (e.g. the number of Mapping output
*     coordinates, or number of input coordinates if the inverse
*     transformation is requested). Any excess space will be ignored.
*     - A null pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   AstPointSet *result;          /* Pointer to output PointSet */
   int def;                      /* Coordinate transformation defined? */
   int ncoord_in;                /* Number of input PointSet coordinates */
   int ncoord_out;               /* Number of coordinates in output PointSet */
   int nin;                      /* Number of input Mapping coordinates */
   int nout;                     /* Number of output Mapping coordinates */
   int npoint;                   /* Number of points to transform */
   int npoint_out;               /* Number of points in output PointSet */

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Initialise. */
   result = NULL;

/* Determine if a coordinate transformation is defined for the requested
   direction. */
   def = forward ? astGetTranForward( this ) : astGetTranInverse( this );

/* Report an error if the transformation is not defined. */
   if ( astOK && !def ) {
      astError( AST__TRNND, "astTransform(%s): %s coordinate transformation "
                "is not defined by the %s supplied.", status, astGetClass( this ),
                forward ? "A forward" : "An inverse", astGetClass( this ) );
   }

/* Obtain the effective number of input and output coordinate values for the
   transformation to be performed, taking account of the transformation
   direction required. Note we use Mapping methods to obtain these values, as
   this will take account of whether the Mapping has been inverted. */
   nin = forward ? astGetNin( this ) : astGetNout( this );
   nout = forward ? astGetNout( this ) : astGetNin( this );

/* Obtain the number of input points to transform and the number of coordinate
   values per input point. */
   npoint = astGetNpoint( in );
   ncoord_in = astGetNcoord( in );

/* If OK, check that the number of input coordinates matches the number
   required by the mapping. Report an error if these numbers do not match. */
   if ( astOK && ( ncoord_in != nin ) ) {
      astError( AST__NCPIN, "astTransform(%s): Bad number of coordinate "
                "values (%d) in input %s.", status, astGetClass( this ), ncoord_in,
                astGetClass( in ) );
      astError( AST__NCPIN, "The %s given requires %d coordinate value(s) for "
                "each input point.", status, astGetClass( this ), nin );
   }

/* If still OK, and a non-NULL pointer has been given for the output PointSet,
   then obtain the number of points and number of coordinates per point for
   this PointSet. */
   if ( astOK && out ) {
      npoint_out = astGetNpoint( out );
      ncoord_out = astGetNcoord( out );

/* Check that the dimensions of this PointSet are adequate to accommodate the
   output coordinate values and report an error if they are not. */
      if ( astOK ) {
         if ( npoint_out < npoint ) {
            astError( AST__NOPTS, "astTransform(%s): Too few points (%d) in "
                      "output %s.", status, astGetClass( this ), npoint_out,
                      astGetClass( out ) );
            astError( AST__NOPTS, "The %s needs space to hold %d transformed "
                      "point(s).", status, astGetClass( this ), npoint );
         } else if ( ncoord_out < nout ) {
            astError( AST__NOCTS, "astTransform(%s): Too few coordinate "
                      "values per point (%d) in output %s.", status,
                      astGetClass( this ), ncoord_out, astGetClass( out ) );
            astError( AST__NOCTS, "The %s supplied needs space to store %d "
                      "coordinate value(s) per transformed point.", status,
                      astGetClass( this ), nout );
         }
      }
   }

/* If all the validation stages are passed successfully, and a NULL output
   pointer was given, then create a new PointSet to encapsulate the output
   coordinate data. */
   if ( astOK ) {
      if ( !out ) {
         result = astPointSet( npoint, nout, "", status );

/* Otherwise, use the PointSet supplied. */
      } else {
         result = out;
      }
   }

/* Return a pointer to the output PointSet. Note that we do not actually
   transform (or even copy) the coordinates. This is left for derived classes
   to implement. */
   return result;
}

/*
*++
*  Name:
c     astUinterp
f     AST_UINTERP

*  Purpose:
*     Perform sub-pixel interpolation on a grid of data.

*  Type:
*     Fictitious function.

*  Synopsis:
c     #include "mapping.h"
c     void astUinterp( int ndim_in, const int lbnd_in[], const int ubnd_in[],
c                      const <Xtype> in[], const <Xtype> in_var[],
c                      int npoint, const int offset[],
c                      const double *const coords[], const double params[],
c                      int flags, <Xtype> badval,
c                      <Xtype> out[], <Xtype> out_var[], int *nbad )
f     CALL AST_UINTERP( NDIM_IN, LBND_IN, UBND_IN, IN, IN_VAR,
f                       NPOINT, OFFSET, COORDS, PARAMS, FLAGS, BADVAL,
f                       OUT, OUT_VAR, NBAD, STATUS )

*  Class Membership:
*     Mapping member function.

*  Description:
c     This is a fictitious function which does not actually
c     exist. Instead, this description constitutes a template so that
c     you may implement a function with this interface for yourself
c     (and give it any name you wish). A pointer to such a function
c     may be passed via the "finterp" parameter of the astResample<X>
c     functions (q.v.) in order to perform sub-pixel interpolation
c     during resampling of gridded data (you must also set the
c     "interp" parameter of astResample<X> to the value
c     AST__UINTERP). This allows you to use your own interpolation
c     algorithm in addition to those which are pre-defined.
f     This is a fictitious routine which does not actually
f     exist. Instead, this description constitutes a template so that
f     you may implement a routine with this interface for yourself
f     (and give it any name you wish). Such a routine
f     may be passed via the FINTERP argument of the AST_RESAMPLE<X>
f     functions (q.v.) in order to perform sub-pixel interpolation
f     during resampling of gridded data (you must also set the
f     INTERP argument of AST_RESAMPLE<X> to the value
f     AST__UINTERP). This allows you to use your own interpolation
f     algorithm in addition to those which are pre-defined.
*
c     The function interpolates an input grid of data (and,
f     The routine interpolates an input grid of data (and,
*     optionally, processes associated statistical variance estimates)
*     at a specified set of points.

*  Parameters:
c     ndim_in
f     NDIM_IN = INTEGER (Given)
*        The number of dimensions in the input grid. This will be at
*        least one.
c     lbnd_in
f     LBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the first pixel
*        in the input grid along each dimension.
c     ubnd_in
f     UBND_IN( NDIM_IN ) = INTEGER (Given)
c        Pointer to an array of integers, with "ndim_in" elements,
f        An array
*        containing the coordinates of the centre of the last pixel in
*        the input grid along each dimension.
*
c        Note that "lbnd_in" and "ubnd_in" together define the shape,
f        Note that LBND_IN and UBND_IN together define the shape,
*        size and coordinate system of the input grid in the same
c        way as they do in astResample<X>.
f        way as they do in AST_RESAMPLE<X>.
c     in
f     IN( * ) = <Xtype> (Given)
c        Pointer to an array, with one element for each pixel in the
f        An array, with one element for each pixel in the
*        input grid, containing the input data. This will be the same
c        array as was passed to astResample<X> via the "in" parameter.
f        array as was passed to AST_RESAMPLE<X> via the IN argument.
*        The numerical type of this array should match that of the
*        data being processed.
c     in_var
f     IN_VAR( * ) = <Xtype> (Given)
c        Pointer to an optional second array with the same size and
c        type as the "in" array. If given, this will contain the set
c        of variance values associated with the input data and will be
c        the same array as was passed to astResample<X> via the
c        "in_var" parameter.
f        An optional second array with the same size and type as the
f        IN array. This will only be given if the AST__USEVAR flag is
f        set via the FLAGS argument (below). If given, it will contain
f        the set of variance values associated with the input data and
f        will be the same array as was passed to AST_RESAMPLE<X> via
f        the IN_VAR argument.
*
c        If no variance values are being processed, this will be a
c        NULL pointer.
f        If the AST__USEVAR flag is not set, then no variance values
f        are being processed. In this case, this array of variance
f        values may be a dummy (e.g. one-element) array and should not
f        be used.
c     npoint
f     NPOINT = INTEGER (Given)
*        The number of points at which the input grid is to be
*        interpolated. This will be at least one.
c     offset
f     OFFSET( NPOINT ) = INTEGER (Given)
c        Pointer to an array of integers with "npoint" elements. For
c        each interpolation point, this will contain the zero-based
c        index in the "out" (and "out_var") array(s) at which the
c        interpolated value (and its variance, if required) should be
c        stored. For example, the interpolated value for point number
c        "point" should be stored in "out[offset[point]]" (assuming
c        the index "point" is zero-based).
f        For each interpolation point, this array will contain the
f        offset from the start of the OUT (and OUT_VAR) array(s) at
f        which the interpolated value (and its variance, if required)
f        should be stored. For example, the interpolated value for
f        point number POINT should be stored in OUT(1+OFFSET(POINT)).
c     coords
f     COORDS( NPOINT, NDIM_IN ) = DOUBLE PRECISION (Given)
c        An array of pointers to double, with "ndim_in"
c        elements. Element "coords[coord]" will point at the first
c        element of an array of double (with "npoint" elements) which
c        contains the values of coordinate number "coord" for each
c        interpolation point. The value of coordinate number "coord"
c        for interpolation point number "point" is therefore given by
c        "coords[coord][point]" (assuming both indices are
c        zero-based).
f        A 2-dimensional array containing the coordinates of the
f        points at which interpolation should be performed. These will
f        be stored so that coordinate number COORD for interpolation
f        point number POINT is found in element COORDS(POINT,COORD).
*
*        If any interpolation point has any of its coordinates equal
c        to the value AST__BAD (as defined in the "ast.h" header
f        to the value AST__BAD (as defined in the AST_PAR include
*        file), then the corresponding output data (and variance)
c        should either be set to the value given by "badval",
f        should either be set to the value given by BADVAL,
*        or left unchanged, depending on whether the AST__NOBAD flag is
c        specified by "flags".
f        specified by FLAGS.
c     params
f     PARAMS( * ) = DOUBLE PRECISION (Given)
c        This will be a pointer to the same array as was given via the
c        "params" parameter of astResample<X>. You may use this to
f        This will be the same array as was given via the
f        PARAMS argument of AST_RESAMPLE<X>. You may use this to
*        pass any additional parameter values required by your
*        interpolation algorithm.
c     flags
f     FLAGS = INTEGER (Given)
c        This will be the same value as was given via the "flags"
c        parameter of astResample<X>. You may test this value to
f        This will be the same value as was given via the FLAGS
f        argument of AST_RESAMPLE<X>. You may test this value to
*        provide additional control over the operation of your
*        resampling algorithm. Note that the special flag values
*        AST__URESAMP1, 2, 3 & 4 are reserved for you to use for your
*        own purposes and will not clash with other pre-defined flag
c        values (see astResample<X>).
f        values (see AST_RESAMPLE<X>).
c     badval
f     BADVAL = <Xtype> (Given)
c        This will be the same value as was given via the "badval"
c        parameter of astResample<X>, and will have the same numerical
c        type as the data being processed (i.e. as elements of the
c        "in" array).  It should be used to test for bad pixels in the
c        input grid (but only if the AST__USEBAD flag is set via the
c        "flags" parameter) and (unless the AST__NOBAD flag is set in
c        "flags") for identifying bad output values in
c        the "out" (and "out_var") array(s).
f        This will be the same value as was given for the BADVAL
f        argument of AST_RESAMPLE<X>, and will have the same numerical
f        type as the data being processed (i.e. as elements of the IN
f        array).  It should be used to test for bad pixels in the
f        input grid (but only if the AST__USEBAD flag is set via the
f        FLAGS argument) and (unless the AST__NOBAD flag is set in
f        FLAGS) for identifying bad output values in the OUT (and
f        OUT_VAR) array(s).
c     out
f     OUT( * ) = <Xtype> (Returned)
c        Pointer to an array with the same numerical type as the "in"
f        An array with the same numerical type as the IN
*        array, into which the interpolated data values should be
*        returned.  Note that details of the storage order and number
*        of dimensions of this array are not required, since the
c        "offset" array contains all necessary information about where
f        OFFSET array contains all necessary information about where
*        each returned value should be stored.
*
c        In general, not all elements of this array (or the "out_var"
f        In general, not all elements of this array (or the OUT_VAR
*        array below) may be used in any particular invocation of the
c        function. Those which are not used should be returned
f        routine. Those which are not used should be returned
*        unchanged.
c     out_var
f     OUT_VAR( * ) = <Xtype> (Returned)
c        Pointer to an optional array with the same type and size as
c        the "out" array, into which variance estimates for the
c        resampled values should be returned.  This array will only be
c        given if the "in_var" array has also been given.
f        An optional array with the same type and size as the OUT
f        array, into which variance estimates for the resampled values
f        should be returned. This array will only be given if the
f        AST__USEVAR flag is set via the FLAGS argument.
*
c        If given, it is addressed in exactly the same way (via the
c        "offset" array) as the "out" array. The values returned
c        should be estimates of the statistical variance of the
c        corresponding values in the "out" array, on the assumption
c        that all errors in input data values are statistically
c        independent and that their variance estimates may simply be
c        summed (with appropriate weighting factors).
f        If given, it is addressed in exactly the same way (via the
f        OFFSET array) as the OUT array. The values returned should be
f        estimates of the statistical variance of the corresponding
f        values in the OUT array, on the assumption that all errors in
f        input data values are statistically independent and that
f        their variance estimates may simply be summed (with
f        appropriate weighting factors).
*
c        If no output variance estimates are required, a NULL pointer
c        will be given.
f        If the AST__USEVAR flag is not set, then variance values are
f        not being processed.  In this case, this array may be a dummy
f        (e.g. one-element) array and should not be used.
c     nbad
f     NBAD = INTEGER (Returned)
c        Pointer to an int in which to return the number of interpolation
c        points at
f        This should return the number of interpolation points at
*        which no valid interpolated value could be obtained.  The maximum
c        value that should be returned is "npoint", and the minimum is
f        value that should be returned is NPOINT, and the minimum is
*        zero (indicating that all output values were successfully
*        obtained).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The data type <Xtype> indicates the numerical type of the data
c     being processed, as for astResample<X>.
f     being processed, as for AST_RESAMPLE<X>.
c     - This function will typically be invoked more than once for each
c     invocation of astResample<X>.
f     - This routine will typically be invoked more than once for each
f     invocation of AST_RESAMPLE<X>.
c     - If an error occurs within this function, it should use
c     astSetStatus to set the AST error status to an error value.
c     This will cause an immediate return from astResample<X>. The error
c     value AST__UINER is available for this purpose, but other values may
c     also be used (e.g. if you wish to distinguish different types of
c     error).
f     - If an error occurs within this routine, it should set the
f     STATUS argument to an error value before returning. This will
f     cause an immediate return from AST_RESAMPLE<X>. The error value
f     AST__UINER is available for this purpose, but other values may also
f     be used (e.g. if you wish to distinguish different types of error).
f     The AST__UINER error value is defined in the AST_ERR include file.
*--
*/
/* Note the above is just a description to act as a template. The
   function does not actually exist. */

/*
*++
*  Name:
c     astUkern1
f     AST_UKERN1

*  Purpose:
*     1-dimensional sub-pixel interpolation kernel.

*  Type:
*     Fictitious function.

*  Synopsis:
c     #include "mapping.h"
c     void astUkern1( double offset, const double params[], int flags,
c                     double *value )
f     CALL AST_UKERN1( OFFSET, PARAMS, FLAGS, VALUE, STATUS )

*  Class Membership:
*     Mapping member function.

*  Description:
c     This is a fictitious function which does not actually
c     exist. Instead, this description constitutes a template so that
c     you may implement a function with this interface for yourself
c     (and give it any name you wish). A pointer to such a function
c     may be passed via the "finterp" parameter of the astResample<X>
c     functions (q.v.) in order to supply a 1-dimensional
c     interpolation kernel to the algorithm which performs sub-pixel
c     interpolation during resampling of gridded data (you must also
c     set the "interp" parameter of astResample<X> to the value
c     AST__UKERN1). This allows you to use your own interpolation
c     kernel in addition to those which are pre-defined.
f     This is a fictitious routine which does not actually
f     exist. Instead, this description constitutes a template so that
f     you may implement a routine with this interface for yourself
f     (and give it any name you wish). Such a routine
f     may be passed via the FINTERP argument of the AST_RESAMPLE<X>
f     functions (q.v.) in order to supply a 1-dimensional
f     interpolation kernel to the algorithm which performs sub-pixel
f     interpolation during resampling of gridded data (you must also
f     set the INTERP argument of AST_RESAMPLE<X> to the value
f     AST__UKERN1). This allows you to use your own interpolation
f     kernel in addition to those which are pre-defined.
*
c     The function calculates the value of a 1-dimensional sub-pixel
f     The routine calculates the value of a 1-dimensional sub-pixel
*     interpolation kernel. This determines how the weight given to
*     neighbouring pixels in calculating an interpolated value depends
*     on the pixel's offset from the interpolation point. In more than
*     one dimension, the weight assigned to a pixel is formed by
*     evaluating this 1-dimensional kernel using the offset along each
*     dimension in turn. The product of the returned values is then
*     used as the pixel weight.

*  Parameters:
c     offset
f     OFFSET = DOUBLE PRECISION (Given)
*        This will be the offset of the pixel from the interpolation
*        point, measured in pixels. This value may be positive or
*        negative, but for most practical interpolation schemes its
*        sign should be ignored.
c     params
f     PARAMS( * ) = DOUBLE PRECISION (Given)
c        This will be a pointer to the same array as was given via the
c        "params" parameter of astResample<X>. You may use this to
f        This will be the same array as was given via the
f        PARAMS argument of AST_RESAMPLE<X>. You may use this to
*        pass any additional parameter values required by your kernel,
c        but note that "params[0]" will already have been used to specify
f        but note that PARAMS(1) will already have been used to specify
*        the number of neighbouring pixels which contribute to the
*        interpolated value.
c     flags
f     FLAGS = INTEGER (Given)
c        This will be the same value as was given via the "flags"
c        parameter of astResample<X>. You may test this value to
f        This will be the same value as was given via the FLAGS
f        argument of AST_RESAMPLE<X>. You may test this value to
*        provide additional control over the operation of your
c        function. Note that the special flag values AST__URESAMP1, 2,
f        routine. Note that the special flag values AST__URESAMP1, 2,
*        3 & 4 are reserved for you to use for your own purposes and
*        will not clash with other pre-defined flag
c        values (see astResample<X>).
f        values (see AST_RESAMPLE<X>).
c     value
f     VALUE = DOUBLE PRECISION (Returned)
c        Pointer to a double to receive the calculated kernel value,
f        The calculated kernel value,
*        which may be positive or negative.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - Not all functions make good interpolation kernels. In general,
*     acceptable kernels tend to be symmetrical about zero, to have a
*     positive peak (usually unity) at zero, and to evaluate to zero
*     whenever the pixel offset has any other integral value (this
*     ensures that the interpolated values pass through the original
*     data). An interpolation kernel may or may not have regions with
*     negative values. You should consult a good book on image
*     processing for more details.
c     - If an error occurs within this function, it should use
c     astSetStatus to set the AST error status to an error value.
c     This will cause an immediate return from astResample<X>. The error
c     value AST__UK1ER is available for this purpose, but other values may
c     also be used (e.g. if you wish to distinguish different types of
c     error).
f     - If an error occurs within this routine, it should set the
f     STATUS argument to an error value before returning. This will
f     cause an immediate return from AST_RESAMPLE<X>. The error value
f     AST__UK1ER is available for this purpose, but other values may also
f     be used (e.g. if you wish to distinguish different types of error).
f     The AST__UK1ER error value is defined in the AST_ERR include file.
*--
*/
/* Note the above is just a description to act as a template. The
   function does not actually exist. */

static double UphillSimplex( const MapData *mapdata, double acc, int maxcall,
                             const double dx[], double xmax[], double *err,
                             int *ncall, int *status ) {
/*
*  Name:
*     UphillSimplex

*  Purpose:
*     Find a function maximum using a modification of the simplex method.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     double UphillSimplex( const MapData *mapdata, double acc, int maxcall,
*                           const double dx[], double xmax[], double *err,
*                           int *ncall, int *status );

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function applies a modification of the simplex method to
*     find a local maximum in the value returned by a Mapping
*     function. The modification used allows the method to cope with
*     coordinate constraints and (equivalently) regions where the
*     function returns "bad" values. The method is robust and not
*     susceptible to overflow, so is suitable for applying to Mapping
*     functions of unknown form.

*  Parameters:
*     mapdata
*        Pointer to a MapData structure which describes the Mapping
*        function, its coordinate constraints, etc.
*     acc
*        The accuracy required in the value of the maximum.
*     maxcall
*        The maximum number of Mapping function evaluations to use.
*     dx
*        Pointer to an array of double containing an offset along each
*        input coordinate for the Mapping function supplied. These
*        offsets will be used to construct the initial simplex
*        (i.e. they are the initial "step lengths" for each
*        coordinate) and may be positive or negative.
*     xmax
*        Pointer to an array of double which contains the coordinates
*        of an initial estimate of the location of the maximum. On
*        exit, this will be updated to contain the best estimate of
*        the location of the maximum as generated by this function.
*     err
*        Pointer to a double in which to return an estimate of the
*        error in the value of the maximum found. For normal
*        convergence, this should be no larger than "acc". However, if
*        the maximum number of Mapping function evaluations is
*        reached, the returned value may be larger than this, although
*        it should still be valid. In such cases, re-starting the
*        algorithm at the new location returned in "xmax" may be
*        advisable.
*     ncall
*        Pointer to an int in which the number of Mapping function
*        evaluations will be returned.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     An estimate of the Mapping function value at the local maximum.

*  Notes:
*     - The function may return before the requested accuracy has been
*     met and before all Mapping function evaluations have been
*     made. This signifies that an excessive number of function values
*     have been needed outside the coordinate constraints. This is
*     only likely if the function is unable to make progress near such
*     a constraint, in which case the algorithm should probably be
*     re-started.
*     - A value of AST__BAD will be returned if no maximum could be
*     found.  This means that all the Mapping function evaluations
*     performed returned a value of AST__BAD.
*     - A value of AST__BAD will also be returned and no useful
*     information about a solution will be produced if this routine is
*     invoked with the global error status set, or if it should fail
*     for any reason.
*/

/* Local Constants: */
   const double factor = 3.0;    /* Simplex contraction/expansion factor */

/* Local Variables: */
   double *f;                    /* Pointer to array of function values */
   double *x;                    /* Pointer to array of vertex coordinates */
   double *xnew;                 /* Pointer to workspace array */
   double fnew;                  /* New function value */
   double fsave;                 /* Saved function value */
   double offset;                /* Coordinate difference between vertices */
   double range;                 /* Range of simplex values */
   double result;                /* Value to return */
   double tmp;                   /* Temporary store for coordinate */
   int coord;                    /* Loop counter for coordinates */
   int hi;                       /* Index of best vertex */
   int lo;                       /* Index of worst vertex */
   int ncalla;                   /* Number of function calls attempted */
   int ncoord;                   /* Number of function dimensions */
   int nextlo;                   /* Index of second worst vertex */
   int nvertex;                  /* Number of simplex vertices */
   int vertex;                   /* Loop counter for vertices */

/* Initialise. */
   result = AST__BAD;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Further initialisation. */
   *err = DBL_MAX;
   *ncall = 0;

/* Obtain the number of input coordinates for the Mapping function and
   calculate the number of simplex vertices. */
   ncoord = mapdata->nin;
   nvertex = ncoord + 1;

/* Allocate workspace. */
   f = astMalloc( sizeof( double ) * (size_t) nvertex );
   x = astMalloc( sizeof( double ) * (size_t) ( ncoord * nvertex ) );
   xnew = astMalloc( sizeof( double ) * (size_t) ncoord );
   if ( astOK ) {

/* Loop to set up an initial simplex. */
      for ( vertex = 0; vertex < nvertex; vertex++ ) {
         for ( coord = 0; coord < ncoord; coord++ ) {
            tmp = xmax[ coord ];

/* Displace each point (except the first) the required amount along
   one of the axes to generate the coordinates of the simplex
   vertices. */
            if ( coord == ( vertex - 1 ) ) tmp += dx[ coord ];
            x[ vertex * ncoord + coord ] = tmp;
         }

/* Evaluate the Mapping function at each vertex. */
         f[ vertex ] = MapFunction( mapdata, &x[ vertex * ncoord ], ncall, status );
         if ( f[ vertex ] == AST__BAD ) f[ vertex ] = -DBL_MAX;
      }

/* Initialise the number of times we attempt to call the Mapping
   function (not necessarily the same as the number of times it was
   actually called, which is stored in *ncall). */
      ncalla = nvertex;

/* Loop until convergence is reached or an error occurs. */
      while( astOK ) {

/* Initialise the index of the lowest vertex of the simplex, the next
   lowest vertex and the highest vertex. */
         lo = ( f[ 0 ] < f[ 1 ] ) ? 0 : 1;
         nextlo = 1 - lo;
         hi = 0;

/* Loop to inspect each vertex and update these values. Ensure that in
   the case of equal vertices, the first one is taken to be the
   highest. This makes the maximisation stable (so that if no better
   maximum can be found, the original position is returned rather than
   a nearby position that yields the same function value). */
         for ( vertex = 0; vertex < nvertex; vertex++ ) {
            if ( f[ vertex ] <= f[ lo ] ) {
               nextlo = lo;
               lo = vertex;
            } else if ( ( f[ vertex ] <= f[ nextlo ] ) && ( vertex != lo ) ) {
               nextlo = vertex;
            }
            if ( f[ vertex ] > f[ hi ] ) hi = vertex;
         }

/* Estimate the error on the result as the difference between the
   highest and lowest simplex vertices. */
         if ( ( f[ hi ] == -DBL_MAX ) || ( f[ lo ] == -DBL_MAX ) ) {
            range = DBL_MAX;
         } else {
            range = f[ hi ] - f[ lo ];
         }

/* Test for convergence. Ideally, the accuracy criterion should have
   been met. However, also quit if the maximum number of Mapping
   function evaluations has been reached, or the number of points at
   which function values have been requested reaches three times this
   limit (this latter number will typically be larger because points
   lying outside the coordinate constraints do not result in the
   Mapping function being evaluated). */
         if ( range <= fabs( acc ) ||
              ( *ncall >= maxcall ) || ( ncalla >= ( 3 * maxcall ) ) ) {

/* If quitting, return the coordinates and function value at the best
   simplex vertex, and the error estimate. */
            for ( coord = 0; coord < ncoord; coord++ ) {
               xmax[ coord ] = x[ hi * ncoord + coord ];
            }
            result = ( f[ hi ] == -DBL_MAX ) ? AST__BAD : f[ hi ];
            *err = range;
            break;
         }

/* If performing another iteration, first try reflecting the worst
   vertex through the opposite face of the simplex. Check for
   errors. */
         fnew = NewVertex( mapdata, lo, -1.0, x, f, ncall, xnew, status );
         ncalla++;
         if ( astOK ) {

/* If this results in a point lying in a forbiddden region (either
   outside the coordinate constraints or where the Mapping function
   yields bad coordinate values), then we must make a departure from
   the standard simplex algorithm. This is because the inability to
   make forward progress in this case can cause the simplex to
   repeatedly contract about each face (except one) in turn. This
   mechanism normally results in lateral contraction as the simplex
   attempts to squeeze through a narrow gap which is impeding
   progress. However, in this case there is no gap to get through, so
   the lateral contraction can eventually make the simplex become
   degenerate (due to rounding). This prevents it from expanding
   laterally again and exploring the region adjacent to the constraint
   boundary once it has become small enough. */
            if ( fnew == AST__BAD ) {

/* To overcome this, we instead contract the worst simplex vertex
   towards the best vertex (this has the cumulative effect of
   contracting the simplex without changing its shape). First find the
   offset in each coordinate between these two vertices. */
               for ( coord = 0; coord < ncoord; coord++ ) {
                  offset = x[ lo * ncoord + coord ] - x[ hi * ncoord + coord ];

/* Scale the offset to obtain the new coordinate. */
                  x[ lo * ncoord + coord ] = x[ hi * ncoord + coord ] +
                                             offset / factor;

/* If the distance between the two vertices has not decreased, we are
   in a region where rounding errors prevent them approaching each
   other any more closely, so simply set them equal. */
                  if ( fabs( x[ lo * ncoord + coord ] -
                             x[ hi * ncoord + coord ] ) >= fabs( offset ) ) {
                     x[ lo * ncoord + coord ] = x[ hi * ncoord + coord ];
                  }
               }

/* Evaluate the Mapping function at the new vertex. */
               f[ lo ] = MapFunction( mapdata, &x[ lo * ncoord ], ncall, status );
               if ( f[ lo ] == AST__BAD ) f[ lo ] = -DBL_MAX;
               ncalla++;

/* We now return to the standard simplex algorithm. If the new vertex
   is a new maximum, then see if more of the same is even better by
   trying to expand the best vertex away from the opposite face. */
            } else if ( fnew >= f[ hi ] ) {
               fnew = NewVertex( mapdata, lo, factor, x, f, ncall, xnew, status );
               ncalla++;

/* Otherwise, if the new vertex was no improvement on the second
   worst, then try contracting the worst vertex towards the opposite
   face. */
            } else if ( fnew <= f[ nextlo ] ) {
               fsave = f[ lo ];
               fnew = NewVertex( mapdata, lo, 1.0 / factor, x, f, ncall, xnew, status );
               ncalla++;

/* If this didn't result in any improvement, then contract the entire
   simplex towards the best vertex. Use the same approach as earlier
   to protect against rounding so that all the simplex vertices will
   eventually coalesce if this process is repeated enough times. */
               if ( astOK && ( fnew <= fsave ) ) {
                  for ( vertex = 0; vertex < nvertex; vertex++ ) {
                     if ( vertex != hi ) {
                        for ( coord = 0; coord < ncoord; coord++ ) {
                           offset = x[ vertex * ncoord + coord ] -
                                    x[ hi * ncoord + coord ];
                           x[ vertex * ncoord + coord ] =
                               x[ hi * ncoord + coord ] + offset / factor;
                           if ( fabs( x[ vertex * ncoord + coord ] -
                                      x[ hi * ncoord + coord ] ) >=
                                fabs( offset ) ) {
                              x[ vertex * ncoord + coord ] =
                                 x[ hi * ncoord + coord ];
                           }
                        }

/* Evaluate the Mapping function at each new vertex. */
                        f[ vertex ] = MapFunction( mapdata,
                                                   &x[ vertex * ncoord ],
                                                   ncall, status );
                        if ( f[ vertex ] == AST__BAD ) f[ vertex ] = -DBL_MAX;
                        ncalla++;
                     }
                  }
               }
            }
         }
      }
   }

/* Free workspace. */
   f = astFree( f );
   x = astFree( x );
   xnew = astFree( xnew );

/* If an error occurred, clear the returned result. */
   if ( !astOK ) result = AST__BAD;

/* Return the result. */
   return result;
}

static void ValidateMapping( AstMapping *this, int forward,
                             int npoint, int ncoord_in, int ncoord_out,
                             const char *method, int *status ) {
/*
*  Name:
*     ValidateMapping

*  Purpose:
*     Validate a Mapping for use to transform coordinates.

*  Type:
*     Private function.

*  Synopsis:
*     #include "mapping.h"
*     void ValidateMapping( AstMapping *this, int forward,
*                           int npoint, int ncoord_in, int ncoord_out,
*                           const char *method, int *status )

*  Class Membership:
*     Mapping member function.

*  Description:
*     This function checks that a Mapping is suitable for transforming
*     a set of points. It also checks that the number of points and
*     the number of coordinate values per point is valid. If an error
*     is detected, the global error status is set and an error report
*     made. Otherwise, the function returns without further action.

*  Parameters:
*     this
*        Pointer to the Mapping.
*     forward
*        A non-zero value indicates that the forward coordinate
*        transformation is to be checked, while a zero value requests
*        the inverse transformation.
*     npoint
*        The number of points being transformed.
*     ncoord_in
*        The number of coordinates associated with each input point.
*     ncoord_out
*        The number of coordinates associated with each output point.
*     method
*        Pointer to a null terminated character string containing the
*        name of the method which invoked this function to validate a
*        Mapping. This is used solely for constructing error messages.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   int nin;                    /* Mapping Nin attribute value */
   int nout;                   /* Mapping Nout attribute value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Report an error if the requested transformation is not defined. */
   if ( !( forward ? astGetTranForward( this ) : astGetTranInverse( this ) )
        && astOK ) {
      astError( AST__TRNND, "%s(%s): %s coordinate transformation "
                "is not defined by the %s supplied.", status, method,
                astGetClass( this ),
                ( forward ? "A forward" : "An inverse" ),
                astGetClass( this ) );
   }

/* Obtain the effective values of the Nin and Nout attributes for the
   Mapping. */
   nin = forward ? astGetNin( this ) : astGetNout( this );
   nout = forward ? astGetNout( this ) : astGetNin( this );

/* If OK, check that the number of input coordinates matches the
   number required by the Mapping. Report an error if these numbers do
   not match. */
   if ( astOK && ( ncoord_in != nin ) ) {
      astError( AST__NCPIN, "%s(%s): Bad number of input coordinate values "
                "(%d).", status, method, astGetClass( this ), ncoord_in );
      astError( AST__NCPIN, "The %s given requires %d coordinate value%s for "
                "each input point.", status, astGetClass( this ), nin,
                ( nin == 1 ) ? "" : "s" );
   }

/* If OK, also check that the number of output coordinates matches the
   number required by the Mapping. Report an error if these numbers do
   not match. */
   if ( astOK && ( ncoord_out != nout ) ) {
      astError( AST__NCPIN, "%s(%s): Bad number of output coordinate values "
                "(%d).", status, method, astGetClass( this ), ncoord_out );
      astError( AST__NCPIN, "The %s given generates %s%d coordinate value%s "
                "for each output point.", status, astGetClass( this ),
                ( nout < ncoord_out ) ? "only " : "", nout,
                ( nout == 1 ) ? "" : "s" );
   }

/* Check that the number of points being transformed is not negative
   and report an error if necessary. */
   if ( astOK && ( npoint < 0 ) ) {
      astError( AST__NPTIN, "%s(%s): Number of points to be transformed (%d) "
                "is invalid.", status, method, astGetClass( this ), npoint );
   }
}

/* Functions which access class attributes. */
/* ---------------------------------------- */
/* Implement member functions to access the attributes associated with
   this class using the macros defined for this purpose in the
   "object.h" file. */
/*
*att++
*  Name:
*     Invert

*  Purpose:
*     Mapping inversion flag.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls which one of a Mapping's two possible
*     coordinate transformations is considered the "forward"
*     transformation (the other being the "inverse"
*     transformation). If the attribute value is zero (the default),
*     the Mapping's behaviour will be the same as when it was first
*     created. However, if it is non-zero, its two transformations
*     will be inter-changed, so that the Mapping displays the inverse
*     of its original behaviour.
*
*     Inverting the boolean sense of the Invert attribute will cause
*     the values of a Mapping's Nin and Nout attributes to be
*     interchanged. The values of its TranForward and TranInverse
*     attributes will also be interchanged. This operation may be
c     performed with the astInvert function.
f     performed with the AST_INVERT routine.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     UnitMap
*        The value of the Invert attribute has no effect on the
*        behaviour of a UnitMap.
*     FrameSet
*        Inverting the boolean sense of the Invert attribute for a
*        FrameSet will cause its base and current Frames (and its Base
*        and Current attributes) to be interchanged. This, in turn,
*        may affect other properties and attributes of the FrameSet
*        (such as Nin, Nout, Naxes, TranForward, TranInverse,
*        etc.). The Invert attribute of a FrameSet is not itself
*        affected by selecting a new base or current Frame.
*att--
*/
/* This ia a boolean value (0 or 1) with a value of CHAR_MAX when
   undefined but yielding a default of zero. */
astMAKE_CLEAR(Mapping,Invert,invert,CHAR_MAX)
astMAKE_GET(Mapping,Invert,int,0,( ( this->invert == CHAR_MAX ) ?
                                   0 : this->invert ))
astMAKE_SET(Mapping,Invert,int,invert,( (this->flags&=~AST__ISSIMPLE_FLAG),(value!=0) ))
astMAKE_TEST(Mapping,Invert,( this->invert != CHAR_MAX ))

/*
*att++
*  Name:
*     IsLinear

*  Purpose:
*     Is the Mapping linear?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean), read-only.

*  Description:
*     This attribute indicates whether a Mapping is an instance of a
*     class that always represents a linear transformation. Note, some
*     Mapping classes can represent linear or non-linear transformations
*     (the MathMap class for instance). Such classes have a zero value for
*     the IsLinear attribute. Specific instances of such classes can be
*     tested for linearity using the
*     astLinearApprox function.
*     AST_LINEARAPPROX routine.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        The IsLinear value for a CmpMap is determined by the classes
*        of the encapsulated Mappings. For instance, a CmpMap that combines
*        a ZoomMap and a ShiftMap will have a non-zero value for its IsLinear
*        attribute, but a CmpMap that contains a MathMap will have a
*        value of zero for its IsLinear attribute.
*     Frame
*        The IsLinear value for a Frame is 1 (since a Frame is equivalent
*        to a UnitMap).
*     FrameSet
*        The IsLinear value for a FrameSet is obtained from the Mapping
*        from the base Frame to the current Frame.

*att--
*/

/*
*att++
*  Name:
*     IsSimple

*  Purpose:
*     Has the Mapping been simplified?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean), read-only.

*  Description:
*     This attribute indicates whether a Mapping has been simplified
*     by the
c     astSimplify
f     AST_SIMPLIFY
*     method. If the IsSimple value is non-zero, then the Mapping has
*     been simplified and so there is nothing to be gained by simplifying
*     it again. Indeed, the
c     astSimplify
f     AST_SIMPLIFY
*     method will immediately return the Mapping unchanged if the IsSimple
*     attribute indicates that the Mapping has already been simplified.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     Frame
*        All classes of Frame return zero for the IsSimple attribute.
*        This is because changes can be made to a Frame which affect the
*        Mapping represented by the Frame, and so there can be no
*        guarantee that the Mapping may not need re-simplifying. Most
*        non-Frame Mappings, on the other hand, are immutable and so when
*        they are simplified it is certain that they weill remain in a
*        simple state.

*att--
*/
astMAKE_GET(Mapping,IsSimple,int,0,((this->flags)&AST__ISSIMPLE_FLAG))

/*
*att++
*  Name:
*     Nin

*  Purpose:
*     Number of input coordinates for a Mapping.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer, read-only.

*  Description:
*     This attribute gives the number of coordinate values required to
*     specify an input point for a Mapping (i.e. the number of
*     dimensions of the space in which the Mapping's input points
*     reside).

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        If a CmpMap's component Mappings are joined in series, then
*        its Nin attribute is equal to the Nin attribute of the first
*        component (or to the Nout attribute of the second component
*        if the the CmpMap's Invert attribute is non-zero).
*
*        If a CmpMap's component Mappings are joined in parallel, then
*        its Nin attribute is given by the sum of the Nin attributes
*        of each component (or to the sum of their Nout attributes if
*        the CmpMap's Invert attribute is non-zero).
*     Frame
*        The Nin attribute for a Frame is always equal to the number
*        of Frame axes (Naxes attribute).
*     FrameSet
*        The Nin attribute of a FrameSet is equal to the number of
*        axes (Naxes attribute) of its base Frame (as specified by the
*        FrameSet's Base attribute). The Nin attribute value may
*        therefore change if a new base Frame is selected.
*att--
*/

/*
*att++
*  Name:
*     Nout

*  Purpose:
*     Number of output coordinates for a Mapping.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer, read-only.

*  Description:
*     This attribute gives the number of coordinate values generated
*     by a Mapping to specify each output point (i.e. the number of
*     dimensions of the space in which the Mapping's output points
*     reside).

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        If a CmpMap's component Mappings are joined in series, then
*        its Nout attribute is equal to the Nout attribute of the
*        second component (or to the Nin attribute of the first
*        component if the the CmpMap's Invert attribute is non-zero).
*
*        If a CmpMap's component Mappings are joined in parallel, then
*        its Nout attribute is given by the sum of the Nout attributes
*        of each component (or to the sum of their Nin attributes if
*        the CmpMap's Invert attribute is non-zero).
*     Frame
*        The Nout attribute for a Frame is always equal to the number
*        of Frame axes (Naxes attribute).
*     FrameSet
*        The Nout attribute of a FrameSet is equal to the number of
*        FrameSet axes (Naxes attribute) which, in turn, is equal to
*        the Naxes attribute of the FrameSet's current Frame (as
*        specified by the Current attribute). The Nout attribute value
*        may therefore change if a new current Frame is selected.
*att--
*/

/*
*att++
*  Name:
*     Report

*  Purpose:
*     Report transformed coordinates?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls whether coordinate values are reported
*     whenever a Mapping is used to transform a set of points. If its
*     value is zero (the default), no report is made. However, if it
*     is non-zero, the coordinates of each point are reported (both
*     before and after transformation) by writing them to standard
*     output.
*
*     This attribute is provided as an aid to debugging, and to avoid
*     having to report values explicitly in simple programs.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        When applied to a compound Mapping (CmpMap), only the Report
*        attribute of the CmpMap, and not those of its component
*        Mappings, is used.  Coordinate information is never reported
*        for the component Mappings individually, only for the
*        complete CmpMap.
*     Frame
*        When applied to any Frame, the formatting capabilities of the
c        Frame (as provided by the astFormat function) will be used to
f        Frame (as provided by the AST_FORMAT function) will be used to
*        format the reported coordinates.
*     FrameSet
*        When applied to any FrameSet, the formatting capabilities of
*        the base and current Frames will be used (as above) to
*        individually format the input and output coordinates, as
*        appropriate. The Report attribute of a FrameSet is not itself
*        affected by selecting a new base or current Frame, but the
*        resulting formatting capabilities may be.

*  Notes:
*     - Unlike most other attributes, the value of the Report
*     attribute is not transferred when a Mapping is copied. Instead,
*     its value is undefined (and therefore defaults to zero) in any
*     copy. Similarly, it becomes undefined in any external
c     representation of a Mapping produced by the astWrite function.
f     representation of a Mapping produced by the AST_WRITE routine.
*att--
*/
/* This ia a boolean value (0 or 1) with a value of CHAR_MAX when
   undefined but yielding a default of zero. */
astMAKE_CLEAR(Mapping,Report,report,CHAR_MAX)
astMAKE_GET(Mapping,Report,int,0,( ( this->report == CHAR_MAX ) ?
                                   0 : this->report ))
astMAKE_SET(Mapping,Report,int,report,( value != 0 ))
astMAKE_TEST(Mapping,Report,( this->report != CHAR_MAX ))

/*
*att++
*  Name:
*     TranForward

*  Purpose:
*     Forward transformation defined?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean), read-only.

*  Description:
*     This attribute indicates whether a Mapping is able to transform
*     coordinates in the "forward" direction (i.e. converting input
*     coordinates into output coordinates). If this attribute is
*     non-zero, the forward transformation is available. Otherwise, it
*     is not.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        The TranForward attribute value for a CmpMap is given by the
*        boolean AND of the value for each component Mapping.
*     FrameSet
*        The TranForward attribute of a FrameSet applies to the
*        transformation which converts between the FrameSet's base
*        Frame and its current Frame (as specified by the Base and
*        Current attributes). This value is given by the boolean AND
*        of the TranForward values which apply to each of the
*        individual sub-Mappings required to perform this conversion.
*        The TranForward attribute value for a FrameSet may therefore
*        change if a new Base or Current Frame is selected.

*  Notes:
*     - An error will result if a Mapping with a TranForward value of
*     zero is used to transform coordinates in the forward direction.
*att--
*/

/*
*att++
*  Name:
*     TranInverse

*  Purpose:
*     Inverse transformation defined?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean), readonly.

*  Description:
*     This attribute indicates whether a Mapping is able to transform
*     coordinates in the "inverse" direction (i.e. converting output
*     coordinates back into input coordinates). If this attribute is
*     non-zero, the inverse transformation is available. Otherwise, it
*     is not.

*  Applicability:
*     Mapping
*        All Mappings have this attribute.
*     CmpMap
*        The TranInverse attribute value for a CmpMap is given by the
*        boolean AND of the value for each component Mapping.
*     FrameSet
*        The TranInverse attribute of a FrameSet applies to the
*        transformation which converts between the FrameSet's current
*        Frame and its base Frame (as specified by the Current and
*        Base attributes). This value is given by the boolean AND of
*        the TranInverse values which apply to each of the individual
*        sub-Mappings required to perform this conversion.
*        The TranInverse attribute value for a FrameSet may therefore
*        change if a new Base or Current Frame is selected.

*  Notes:
*     - An error will result if a Mapping with a TranInverse value of
*     zero is used to transform coordinates in the inverse direction.
*att--
*/

/* Copy constructor. */
/* ----------------- */
static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
/*
*  Name:
*     Copy

*  Purpose:
*     Copy constructor for Mapping objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Copy( const AstObject *objin, AstObject *objout, int *status )

*  Description:
*     This function implements the copy constructor for Mapping objects.

*  Parameters:
*     objin
*        Pointer to the Mapping to be copied.
*     objout
*        Pointer to the Mapping being constructed.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This constructor exists simply to ensure that the "Report"
*     attribute is cleared in any copy made of a Mapping.
*/

/* Local Variables: */
   AstMapping *out;              /* Pointer to output Mapping */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the output Mapping. */
   out = (AstMapping *) objout;

/* Clear the output Report attribute. */
   out->report = CHAR_MAX;
}

/* Destructor. */
/* ----------- */
static void Delete( AstObject *obj, int *status ) {
/*
*  Name:
*     Delete

*  Purpose:
*     Destructor for Mapping objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Delete( AstObject *obj, int *status )

*  Description:
*     This function implements the destructor for Mapping objects.

*  Parameters:
*     obj
*        Pointer to the Mapping to be deleted.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This destructor does nothing and exists only to maintain a
*     one-to-one correspondence between destructors and copy
*     constructors.
*/

/* Return without action. */
}

/* Dump function. */
/* -------------- */
static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
/*
*  Name:
*     Dump

*  Purpose:
*     Dump function for Mapping objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Dump( AstObject *this, AstChannel *channel, int *status )

*  Description:
*     This function implements the Dump function which writes out data
*     for the Mapping class to an output Channel.

*  Parameters:
*     this
*        Pointer to the Mapping whose data are being written.
*     channel
*        Pointer to the Channel to which the data are being written.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstMapping *this;             /* Pointer to the Mapping structure */
   int invert;                   /* Mapping inverted? */
   int ival;                     /* Integer value */
   int set;                      /* Attribute value set? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Mapping structure. */
   this = (AstMapping *) this_object;

/* Write out values representing the instance variables for the
   Mapping class.  Accompany these with appropriate comment strings,
   possibly depending on the values being written.*/

/* In the case of attributes, we first use the appropriate (private)
   Test...  member function to see if they are set. If so, we then use
   the (private) Get... function to obtain the value to be written
   out.

   For attributes which are not set, we use the astGet... method to
   obtain the value instead. This will supply a default value
   (possibly provided by a derived class which over-rides this method)
   which is more useful to a human reader as it corresponds to the
   actual default attribute value.  Since "set" will be zero, these
   values are for information only and will not be read back. */

/* Determine if the Mapping is inverted. The output values
   (e.g. number of input and output coordinates) will refer to the
   Mapping ***before*** this inversion flag is applied, but we need it
   when using (e.g.) the astGetNin/astGetNout methods to determine
   which one will return the required value. */
   invert = astGetInvert( this );

/* (NB. there is a subtle point here that dictates the extent to which
   this inversion flag can be used... All use of methods (such as
   astGetInvert, which might be over-ridden by derived classes) must
   be restricted to determining the values of "unset" output
   quantities only (below). This is because when re-loading the
   Mapping, the derived classes will not have been loaded at the point
   when these values are re-read - hence any value whose
   interpretation depends on these methods cannot be reliably
   recovered.) */

/* Nin. */
/* ---- */
/* Use the instance variable directly to avoid the effect of the
   Invert attribute on the private member function. Treat zero as the
   default. */
   set = ( this->nin != 0 );
   ival = set ? this->nin : ( !invert ? astGetNin( this ) :
                                        astGetNout( this ) );
   astWriteInt( channel, "Nin", set, 0, ival,
                "Number of input coordinates" );

/* Nout. */
/* ----- */
/* Use the instance variable directly. Treat zero as the default. */
   set = ( this->nout != this->nin );
   ival = set ? this->nout : ( !invert ? astGetNout( this ) :
                                         astGetNin( this ) );
   astWriteInt( channel, "Nout", set, 0, ival,
                "Number of output coordinates" );

/* IsSimple. */
/* --------- */
   ival = astGetIsSimple( this );
   astWriteInt( channel, "IsSimp", ival, 0, ival,
                ival ? "Mapping has been simplified" :
                       "Mapping has not been simplified" );

/* Invert. */
/* ------- */
   set = TestInvert( this, status );
   ival = set ? GetInvert( this, status ) : astGetInvert( this );
   astWriteInt( channel, "Invert", set, 0, ival,
                ival ? "Mapping inverted" :
                       "Mapping not inverted" );

/* TranForward. */
/* ------------ */
/* Use the instance variable directly. Treat 1 as the default. */
   set = ( this->tran_forward == 0 );
   ival = set ? this->tran_forward : ( !invert ? astGetTranForward( this ) :
                                                 astGetTranInverse( this ) );
   astWriteInt( channel, "Fwd", set, 0, ival,
                ival ? "Forward transformation defined" :
                       "Forward transformation not defined" );

/* TranInverse. */
/* ------------ */
/* Use the instance variable directly. Treat 1 as the default. */
   set = ( this->tran_inverse == 0 );
   ival = set ? this->tran_inverse : ( !invert ? astGetTranInverse( this ) :
                                                 astGetTranForward( this ) );
   astWriteInt( channel, "Inv", set, 0, ival,
                ival ? "Inverse transformation defined" :
                       "Inverse transformation not defined" );

/* Report. */
/* ------- */
   set = TestReport( this, status );
   ival = set ? GetReport( this, status ) : astGetReport( this );
   astWriteInt( channel, "Report", set, 0, ival,
                ival ? "Report coordinate transformations" :
                       "Don't report coordinate transformations" );
}

/* Standard class functions. */
/* ========================= */
/* Implement the astIsAMapping and astCheckMapping functions using the macros
   defined for this purpose in the "object.h" header file. */
astMAKE_ISA(Mapping,Object)
astMAKE_CHECK(Mapping)

AstMapping *astInitMapping_( void *mem, size_t size, int init,
                             AstMappingVtab *vtab, const char *name,
                             int nin, int nout,
                             int tran_forward, int tran_inverse, int *status ) {
/*
*+
*  Name:
*     astInitMapping

*  Purpose:
*     Initialise a Mapping.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "mapping.h"
*     AstMapping *astInitMapping( void *mem, size_t size, int init,
*                                 AstMappingVtab *vtab, const char *name,
*                                 int nin, int nout,
*                                 int tran_forward, int tran_inverse )

*  Class Membership:
*     Mapping initialiser.

*  Description:
*     This function is provided for use by class implementations to initialise
*     a new Mapping object. It allocates memory (if necessary) to accommodate
*     the Mapping plus any additional data associated with the derived class.
*     It then initialises a Mapping structure at the start of this memory. If
*     the "init" flag is set, it also initialises the contents of a virtual
*     function table for a Mapping at the start of the memory passed via the
*     "vtab" parameter.

*  Parameters:
*     mem
*        A pointer to the memory in which the Mapping is to be initialised.
*        This must be of sufficient size to accommodate the Mapping data
*        (sizeof(Mapping)) plus any data used by the derived class. If a value
*        of NULL is given, this function will allocate the memory itself using
*        the "size" parameter to determine its size.
*     size
*        The amount of memory used by the Mapping (plus derived class data).
*        This will be used to allocate memory if a value of NULL is given for
*        the "mem" parameter. This value is also stored in the Mapping
*        structure, so a valid value must be supplied even if not required for
*        allocating memory.
*     init
*        A logical flag indicating if the Mapping's virtual function table is
*        to be initialised. If this value is non-zero, the virtual function
*        table will be initialised by this function.
*     vtab
*        Pointer to the start of the virtual function table to be associated
*        with the new Mapping.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the new object belongs (it is this
*        pointer value that will subsequently be returned by the astGetClass
*        method).
*     nin
*        The number of coordinate values per input point.
*     nout
*        The number of coordinate vales per output point.
*     tran_forward
*        A non-zero value indicates that the Mapping will be able to
*        transform coordinates in the forward direction. A zero value
*        indicates that it will not.
*     tran_inverse
*        A non-zero value indicates that the Mapping will be able to
*        transform coordinates in the inverse direction. A zero value
*        indicates that it will not.

*  Returned Value:
*     A pointer to the new Mapping.

*  Notes:
*     -  The Mappings produced by this function implement all the basic methods
*     defined by the Mapping class. However, their astTransform method does not
*     actually perform any coordinate transformation (although it performs all
*     necessary argument validation and creates an output PointSet if
*     necessary, leaving its coordinate values undefined).
*     -  This means that Mappings produced by this function are of limited use
*     on their own, but may easily be extended by a derived class simply by
*     over-riding the astTransform method to add the necessary coordinate
*     arithmetic.
*     -  A null pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*-
*/

/* Local Variables: */
   AstMapping *new;              /* Pointer to new Mapping */

/* Check the global status. */
   if ( !astOK ) return NULL;

/* If necessary, initialise the virtual function table. */
   if ( init ) astInitMappingVtab( vtab, name );

/* Initialise. */
   new = NULL;

/* Check the initialisation values for validity, reporting an error if
   necessary. */
   if ( nin < 0 ) {
      astError( AST__BADNI, "astInitMapping(%s): Bad number of input "
                "coordinates (%d).", status, name, nin );
      astError( AST__BADNI, "This number should be zero or more." , status);
   } else if ( nout < 0 ) {
      astError( AST__BADNO, "astInitMapping(%s): Bad number of output "
                "coordinates (%d).", status, name, nout );
      astError( AST__BADNI, "This number should be zero or more." , status);
   }

/* Initialise an Object structure (the parent class) as the first component
   within the Mapping structure, allocating memory if necessary. */
   new = (AstMapping *) astInitObject( mem, size, 0,
                                       (AstObjectVtab *) vtab, name );

   if ( astOK ) {

/* Initialise the Mapping data. */
/* ---------------------------- */
/* Store the numbers of input and output coordinates. */
      new->nin = nin;
      new->nout = nout;

/* Store the flags indicating which coordinate transformations are
   defined (constrain these values to 0 or 1). */
      new->tran_forward = ( tran_forward != 0 );
      new->tran_inverse = ( tran_inverse != 0 );

/* Initialise other attributes to their undefined values. */
      new->invert = CHAR_MAX;
      new->report = CHAR_MAX;
      new->flags = 0;

/* If an error occurred, clean up by deleting the new object. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return a pointer to the new object. */
   return new;
}

AstMapping *astLoadMapping_( void *mem, size_t size,
                             AstMappingVtab *vtab, const char *name,
                             AstChannel *channel, int *status ) {
/*
*+
*  Name:
*     astLoadMapping

*  Purpose:
*     Load a Mapping.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "mapping.h"
*     AstMapping *astLoadMapping( void *mem, size_t size,
*                                 AstMappingVtab *vtab, const char *name,
*                                 AstChannel *channel )

*  Class Membership:
*     Mapping loader.

*  Description:
*     This function is provided to load a new Mapping using data read
*     from a Channel. It first loads the data used by the parent class
*     (which allocates memory if necessary) and then initialises a
*     Mapping structure in this memory, using data read from the input
*     Channel.
*
*     If the "init" flag is set, it also initialises the contents of a
*     virtual function table for a Mapping at the start of the memory
*     passed via the "vtab" parameter.


*  Parameters:
*     mem
*        A pointer to the memory into which the Mapping is to be
*        loaded.  This must be of sufficient size to accommodate the
*        Mapping data (sizeof(Mapping)) plus any data used by derived
*        classes. If a value of NULL is given, this function will
*        allocate the memory itself using the "size" parameter to
*        determine its size.
*     size
*        The amount of memory used by the Mapping (plus derived class
*        data).  This will be used to allocate memory if a value of
*        NULL is given for the "mem" parameter. This value is also
*        stored in the Mapping structure, so a valid value must be
*        supplied even if not required for allocating memory.
*
*        If the "vtab" parameter is NULL, the "size" value is ignored
*        and sizeof(AstMapping) is used instead.
*     vtab
*        Pointer to the start of the virtual function table to be
*        associated with the new Mapping. If this is NULL, a pointer
*        to the (static) virtual function table for the Mapping class
*        is used instead.
*     name
*        Pointer to a constant null-terminated character string which
*        contains the name of the class to which the new object
*        belongs (it is this pointer value that will subsequently be
*        returned by the astGetClass method).
*
*        If the "vtab" parameter is NULL, the "name" value is ignored
*        and a pointer to the string "Mapping" is used instead.

*  Returned Value:
*     A pointer to the new Mapping.

*  Notes:
*     - A null pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstMapping *new;              /* Pointer to the new Mapping */

/* Initialise. */
   new = NULL;

/* Check the global error status. */
   if ( !astOK ) return new;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(channel);

/* If a NULL virtual function table has been supplied, then this is
   the first loader to be invoked for this Mapping. In this case the
   Mapping belongs to this class, so supply appropriate values to be
   passed to the parent class loader (and its parent, etc.). */
   if ( !vtab ) {
      size = sizeof( AstMapping );
      vtab = &class_vtab;
      name = "Mapping";

/* If required, initialise the virtual function table for this class. */
      if ( !class_init ) {
         astInitMappingVtab( vtab, name );
         class_init = 1;
      }
   }

/* Invoke the parent class loader to load data for all the ancestral
   classes of the current one, returning a pointer to the resulting
   partly-built Mapping. */
   new = astLoadObject( mem, size, (AstObjectVtab *) vtab, name,
                        channel );

   if ( astOK ) {

/* Read input data. */
/* ================ */
/* Request the input Channel to read all the input data appropriate to
   this class into the internal "values list". */
      astReadClassData( channel, "Mapping" );

/* Now read each individual data item from this list and use it to
   initialise the appropriate instance variable(s) for this class. */

/* In the case of attributes, we first read the "raw" input value,
   supplying the "unset" value as the default. If a "set" value is
   obtained, we then use the appropriate (private) Set... member
   function to validate and set the value properly. */

/* Initialise bitwise flags to zero. */
      new->flags = 0;

/* Nin. */
/* ---- */
      new->nin = astReadInt( channel, "nin", 0 );
      if ( new->nin < 0 ) new->nin = 0;

/* Nout. */
/* ----- */
      new->nout = astReadInt( channel, "nout", new->nin );
      if ( new->nout < 0 ) new->nout = 0;

/* Invert. */
/* ------- */
      new->invert = astReadInt( channel, "invert", CHAR_MAX );
      if ( TestInvert( new, status ) ) SetInvert( new, new->invert, status );

/* IsSimple. */
/* --------- */
      if( astReadInt( channel, "issimp", 0 ) ) new->flags |= AST__ISSIMPLE_FLAG;

/* TranForward. */
/* ------------ */
      new->tran_forward = ( astReadInt( channel, "fwd", 1 ) != 0 );

/* TranInverse. */
/* ------------ */
      new->tran_inverse = ( astReadInt( channel, "inv", 1 ) != 0 );

/* Report. */
/* ------- */
      new->report = astReadInt( channel, "report", CHAR_MAX );
      if ( TestReport( new, status ) ) SetReport( new, new->report, status );

/* If an error occurred, clean up by deleting the new Mapping. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return the new Mapping pointer. */
   return new;
}

/* Virtual function interfaces. */
/* ============================ */
/* These provide the external interface to the virtual functions
   defined by this class. Each simply checks the global error status
   and then locates and executes the appropriate member function,
   using the function pointer stored in the object's virtual function
   table (this pointer is located using the astMEMBER macro defined in
   "object.h").

   Note that the member function may not be the one defined here, as
   it may have been over-ridden by a derived class. However, it should
   still have the same interface. */

void astDecompose_( AstMapping *this, AstMapping **map1, AstMapping **map2,
                    int *series, int *invert1, int *invert2, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,Decompose))( this, map1, map2, series, invert1, invert2, status );
}
int astGetNin_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,GetNin))( this, status );
}
int astGetNout_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,GetNout))( this, status );
}
int astGetIsLinear_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,GetIsLinear))( this, status );
}
int astGetTranForward_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,GetTranForward))( this, status );
}
int astGetTranInverse_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,GetTranInverse))( this, status );
}
void astInvert_( AstMapping *this, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,Invert))( this, status );
}
void astMapBox_( AstMapping *this,
                 const double lbnd_in[], const double ubnd_in[], int forward,
                 int coord_out, double *lbnd_out, double *ubnd_out,
                 double xl[], double xu[], int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,MapBox))( this, lbnd_in, ubnd_in, forward,
                                       coord_out, lbnd_out, ubnd_out, xl, xu, status );
}
int astMapList_( AstMapping *this, int series, int invert, int *nmap,
                  AstMapping ***map_list, int **invert_list, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,MapList))( this, series, invert,
                                        nmap, map_list, invert_list, status );
}
int *astMapSplit_( AstMapping *this, int nin, const int *in, AstMapping **map,
                   int *status ){
   int *result = NULL;
   AstMapping *tmap;

   if( map ) *map = NULL;
   if ( !astOK ) return NULL;

   result = (**astMEMBER(this,Mapping,MapSplit))( this, nin, in, &tmap, status );
   if( tmap ) {
      *map = astCopy( tmap );
      tmap = astAnnul( tmap );
   }

   return result;
}
int astMapMerge_( AstMapping *this, int where, int series, int *nmap,
                  AstMapping ***map_list, int **invert_list, int *status ) {

   if ( !astOK || astDoNotSimplify( this ) ) return -1;
   return (**astMEMBER(this,Mapping,MapMerge))( this, where, series, nmap,
                                                map_list, invert_list, status );
}
int astDoNotSimplify_( AstMapping *this, int *status ) {
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,DoNotSimplify))( this, status );
}
void astReportPoints_( AstMapping *this, int forward,
                       AstPointSet *in_points, AstPointSet *out_points, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,ReportPoints))( this, forward,
                                             in_points, out_points, status );
}
#define MAKE_RESAMPLE_(X,Xtype) \
int astResample##X##_( AstMapping *this, int ndim_in, const int *lbnd_in, \
                       const int *ubnd_in, const Xtype *in, \
                       const Xtype *in_var, int interp, \
                       void (* finterp)( void ), const double *params, \
                       int flags, double tol, int maxpix, Xtype badval, \
                       int ndim_out, \
                       const int *lbnd_out, const int *ubnd_out, \
                       const int *lbnd, const int *ubnd, Xtype *out, \
                       Xtype *out_var, int *status ) { \
   if ( !astOK ) return 0; \
   return (**astMEMBER(this,Mapping,Resample##X))( this, ndim_in, lbnd_in, \
                                                   ubnd_in, in, in_var, \
                                                   interp, finterp, params, \
                                                   flags, tol, maxpix, \
                                                   badval, ndim_out, \
                                                   lbnd_out, ubnd_out, \
                                                   lbnd, ubnd, \
                                                   out, out_var, status ); \
}
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_RESAMPLE_(LD,long double)
#endif
MAKE_RESAMPLE_(D,double)
MAKE_RESAMPLE_(F,float)
MAKE_RESAMPLE_(L,long int)
MAKE_RESAMPLE_(UL,unsigned long int)
MAKE_RESAMPLE_(I,int)
MAKE_RESAMPLE_(UI,unsigned int)
MAKE_RESAMPLE_(K,INT_BIG)
MAKE_RESAMPLE_(UK,UINT_BIG)
MAKE_RESAMPLE_(S,short int)
MAKE_RESAMPLE_(US,unsigned short int)
MAKE_RESAMPLE_(B,signed char)
MAKE_RESAMPLE_(UB,unsigned char)
#undef MAKE_RESAMPLE_

#define MAKE_REBIN_(X,Xtype) \
void astRebin##X##_( AstMapping *this, double wlim, int ndim_in, const int *lbnd_in, \
                    const int *ubnd_in, const Xtype *in, \
                    const Xtype *in_var, int interp, \
                    const double *params, \
                    int flags, double tol, int maxpix, Xtype badval, \
                    int ndim_out, \
                    const int *lbnd_out, const int *ubnd_out, \
                    const int *lbnd, const int *ubnd, Xtype *out, \
                    Xtype *out_var, int *status ) { \
   if ( !astOK ) return; \
   (**astMEMBER(this,Mapping,Rebin##X))( this, wlim, ndim_in, lbnd_in, \
                                         ubnd_in, in, in_var, \
                                         interp, params, \
                                         flags, tol, maxpix, \
                                         badval, ndim_out, \
                                         lbnd_out, ubnd_out, \
                                         lbnd, ubnd, \
                                         out, out_var, status ); \
}
#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_REBIN_(LD,long double)
#endif
MAKE_REBIN_(D,double)
MAKE_REBIN_(F,float)
MAKE_REBIN_(I,int)
MAKE_REBIN_(B,signed char)
MAKE_REBIN_(UB,unsigned char)
#undef MAKE_REBIN_


#define MAKE_REBINSEQ_(X,Xtype) \
void astRebinSeq##X##_( AstMapping *this, double wlim, int ndim_in, const int *lbnd_in, \
                        const int *ubnd_in, const Xtype *in, \
                        const Xtype *in_var, int interp, \
                        const double *params, \
                        int flags, double tol, int maxpix, Xtype badval, \
                        int ndim_out, \
                        const int *lbnd_out, const int *ubnd_out, \
                        const int *lbnd, const int *ubnd, Xtype *out, \
                        Xtype *out_var, double *weights, int64_t *nused, \
                        int *status ) { \
   if ( !astOK ) return; \
   (**astMEMBER(this,Mapping,RebinSeq##X))( this, wlim, ndim_in, lbnd_in, \
                                         ubnd_in, in, in_var, \
                                         interp, params, \
                                         flags, tol, maxpix, \
                                         badval, ndim_out, \
                                         lbnd_out, ubnd_out, \
                                         lbnd, ubnd, out, out_var, \
                                         weights, nused, status ); \
}

#if HAVE_LONG_DOUBLE     /* Not normally implemented */
MAKE_REBINSEQ_(LD,long double)
#endif
MAKE_REBINSEQ_(D,double)
MAKE_REBINSEQ_(F,float)
MAKE_REBINSEQ_(I,int)
MAKE_REBINSEQ_(B,signed char)
MAKE_REBINSEQ_(UB,unsigned char)

#undef MAKE_REBINSEQ_

double astRate_( AstMapping *this, double *at, int ax1, int ax2, int *status ){
   astDECLARE_GLOBALS

   if ( !astOK ) return AST__BAD;

   astGET_GLOBALS(this);

   if( ax1 < 0 || ax1 >= astGetNout( this ) ) {
      astError( AST__AXIIN, "astRate(%s): Invalid output index (%d) "
                "specified - should be in the range 1 to %d.", status,
                astGetClass( this ), ax1 + 1, astGetNout( this ) );

   } else if( ax2 < 0 || ax2 >= astGetNin( this ) ) {
      astError( AST__AXIIN, "astRate(%s): Invalid input index (%d) "
                "specified - should be in the range 1 to %d.", status,
                astGetClass( this ), ax2 + 1, astGetNin( this ) );
   }

   if( rate_disabled ) {
      return ( at[ ax2 ] != AST__BAD ) ? 1.0 : AST__BAD;
   } else {
      return (**astMEMBER(this,Mapping,Rate))( this, at, ax1, ax2, status );
   }
}
AstMapping *astRemoveRegions_( AstMapping *this, int *status ) {
   if ( !astOK ) return NULL;
   return (**astMEMBER(this,Mapping,RemoveRegions))( this, status );
}

AstMapping *astSimplify_( AstMapping *this, int *status ) {
   AstMapping *result;
   AstErrorContext error_context;

   if ( !astOK ) return NULL;

/* If this Mapping has already been simplified, or if it cannot be
   simplified (e.g. because it is a Frame) we just returned a clone
   of the upplied pointer. */
   if( !astGetIsSimple( this ) && !astDoNotSimplify( this ) ) {

/* Start a new error reporting context. This is done so that errors
   caused by the siplification process attempting to do inappropriate things
   with the supplied mapping can be caught. */
      astErrorBegin( &error_context );

/* Do the simplification. */
      result = (**astMEMBER(this,Mapping,Simplify))( this, status );

/* If a result was returned, indicate it has been simplified and so does
   not need to be simplified again. */
      if( result ) {
         result->flags |= AST__ISSIMPLE_FLAG;

/* If the simplification process failed due to the supplied Mappings
   being inappropriate (e.g. because it attempted to ue an undefined
   transformation), clear the error status and return a clone of the
   supplied Mapping. */
      } else if( astStatus == AST__NODEF || astStatus == AST__TRNND ){
         astClearStatus;
         result = astClone( this );
      }

/* End the error reporting context. */
      astErrorEnd( &error_context );

/* If the Mapping has already been simplified just return a clone. */
   } else {
      result = astClone( this );
   }

   return result;
}

AstPointSet *astTransform_( AstMapping *this, AstPointSet *in,
                            int forward, AstPointSet *out, int *status ) {
   AstPointSet *result;
   if ( !astOK ) return NULL;
   result = (**astMEMBER(this,Mapping,Transform))( this, in, forward, out, status );
   (void) astReplaceNaN( result );
   return result;
}
void astTran1_( AstMapping *this, int npoint, const double xin[],
                int forward, double xout[], int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,Tran1))( this, npoint, xin, forward, xout, status );
}
void astTran2_( AstMapping *this,
                int npoint, const double xin[], const double yin[],
                int forward, double xout[], double yout[], int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,Tran2))( this, npoint, xin, yin,
                                      forward, xout, yout, status );
}
void astTranGrid_( AstMapping *this, int ncoord_in, const int lbnd[],
                   const int ubnd[], double tol, int maxpix, int forward,
                   int ncoord_out, int outdim, double *out, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,TranGrid))( this, ncoord_in, lbnd, ubnd, tol,
                                         maxpix, forward, ncoord_out, outdim,
                                         out, status );
}
void astTranN_( AstMapping *this, int npoint,
                int ncoord_in, int indim, const double *in,
                int forward, int ncoord_out, int outdim, double *out, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,TranN))( this, npoint,
                                      ncoord_in, indim, in,
                                      forward, ncoord_out, outdim, out, status );
}
void astTranP_( AstMapping *this, int npoint,
                int ncoord_in, const double *ptr_in[],
                int forward, int ncoord_out, double *ptr_out[], int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Mapping,TranP))( this, npoint,
                                      ncoord_in, ptr_in,
                                      forward, ncoord_out, ptr_out, status );
}
int astLinearApprox_( AstMapping *this, const double *lbnd,
                       const double *ubnd, double tol, double *fit, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,LinearApprox))( this, lbnd, ubnd, tol, fit, status );
}


int astQuadApprox_( AstMapping *this,  const double lbnd[2],
                    const double ubnd[2], int nx, int ny, double *fit,
                    double *rms, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,Mapping,QuadApprox))( this, lbnd, ubnd, nx,
                                                  ny, fit, rms, status );
}



/* Public Interface Function Prototypes. */
/* ------------------------------------- */
/* The following functions have public prototypes only (i.e. no
   protected prototypes), so we must provide local prototypes for use
   within this module. */
void DecomposeId_( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
void MapBoxId_( AstMapping *, const double [], const double [], int, int, double *, double *, double [], double [], int * );
double astRateId_( AstMapping *, double *, int, int, int * );
void astMapSplitId_( AstMapping *, int, const int *, int *, AstMapping **,
                     int * );

/* Special interface function implementations. */
/* ------------------------------------------- */
void astDecomposeId_( AstMapping *this, AstMapping **map1,
                      AstMapping **map2, int *series, int *invert1,
                      int *invert2, int *status ) {
/*
*++
*  Name:
c     astDecompose
f     AST_DECOMPOSE

*  Purpose:
*     Decompose a Mapping into two component Mappings.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astDecompose( AstMapping *this, AstMapping **map1,
c                        AstMapping **map2, int *series, int *invert1,
c                        int *invert2  )
f     CALL AST_DECOMPOSE( THIS, MAP1, MAP2, SERIES, INVERT1, INVERT2, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function returns pointers to two Mappings which, when applied
f     This routine returns pointers to two Mappings which, when applied
*     either in series or parallel, are equivalent to the supplied Mapping.
*
*     Since the Frame class inherits from the Mapping class, Frames can
*     be considered as special types of Mappings and so this method can
*     be used to decompose either CmpMaps or CmpFrames.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping.
c     map1
f     MAP1 = INTEGER (Returned)
c        Address of a location to receive a pointer to first component
f        A pointer to first component
*        Mapping.
c     map2
f     MAP2 = INTEGER (Returned)
c        Address of a location to receive a pointer to second component
f        A pointer to second component
*        Mapping.
c     series
f     SERIES = LOGICAL (Returned)
c        Address of a location to receive a value indicating if the
c        component Mappings are applied in series or parallel. A non-zero
c        value means that the supplied Mapping is equivalent to applying map1
c        followed by map2 in series. A zero value means that the supplied
c        Mapping is equivalent to applying map1 to the lower numbered axes
c        and map2 to the higher numbered axes, in parallel.
f        Indicates if the
f        component Mappings are applied in series or parallel. A .TRUE.
f        value means that the supplied Mapping is equivalent to applying MAP1
f        followed by MAP2 in series. A zero value means that the supplied
f        Mapping is equivalent to applying MAP1 to the lower numbered axes
f        and MAP2 to the higher numbered axes, in parallel.
c     invert1
f     INVERT1 = INTEGER (Returned)
c        The value of the Invert attribute to be used with map1.
f        The value of the Invert attribute to be used with MAP1.
c     invert2
f     INVERT2 = INTEGER (Returned)
c        The value of the Invert attribute to be used with map2.
f        The value of the Invert attribute to be used with MAP2.

*  Applicability:
*     CmpMap
c        If the supplied Mapping is a CmpMap, then map1 and map2 will be
f        If the supplied Mapping is a CmpMap, then MAP1 and MAP2 will be
*        returned holding pointers to the component Mappings used to
*        create the CmpMap, either in series or parallel. Note, changing
*        the Invert attribute of either of the component Mappings using
*        the returned pointers will have no effect on the supplied CmpMap.
*        This is because the CmpMap remembers and uses the original settings
*        of the Invert attributes (that is, the values of the Invert
*        attributes when the CmpMap was first created). These are the
c        Invert values which are returned in invert1 and invert2.
f        Invert values which are returned in INVERT1 and INVERT2.
*     TranMap
c        If the supplied Mapping is a TranMap, then map1 and map2 will be
f        If the supplied Mapping is a TranMap, then MAP1 and MAP2 will be
*        returned holding pointers to the forward and inverse Mappings
*        represented by the TranMap (zero will be returned for
c        series).
f        SERIES).
*        Note, changing the Invert attribute of
*        either of the component Mappings using the returned pointers will
*        have no effect on the supplied TranMap. This is because the TranMap
*        remembers and uses the original settings of the Invert attributes
*        (that is, the values of the Invert attributes when the TranMap was
*        first created). These are the
c        Invert values which are returned in invert1 and invert2.
f        Invert values which are returned in INVERT1 and INVERT2.
*     Mapping
c        For any class of Mapping other than a CmpMap, map1 will be
c        returned holding a clone of the supplied Mapping pointer, and map2
c        will be returned holding a NULL pointer. Invert1 will be returned
c        holding the current value of the Invert attribute for the supplied
c        Mapping, and invert2 will be returned holding zero.
f        For any class of Mapping other than a CmpMap, MAP1 will be
f        returned holding a clone of the supplied Mapping pointer, and MAP2
f        will be returned holding AST__NULL. INVERT1 will be returned
f        holding the current value of the Invert attribute for the supplied
f        Mapping, and INVERT2 will be returned holding zero.
*     CmpFrame
c        If the supplied Mapping is a CmpFrame, then map1 and map2 will be
f        If the supplied Mapping is a CmpFrame, then MAP1 and MAP2 will be
*        returned holding pointers to the component Frames used to
*        create the CmpFrame. The component Frames are considered to be in
*        applied in parallel.
*     Frame
c        For any class of Frame other than a CmpFrame, map1 will be
c        returned holding a clone of the supplied Frame pointer, and map2
c        will be returned holding a NULL pointer.
f        For any class of Frame other than a CmpFrame, MAP1 will be
f        returned holding a clone of the supplied Frame pointer, and MAP2
f        will be returned holding AST__NULL.

*  Notes:
*     - The returned Invert values should be used in preference to the
*     current values of the Invert attribute in map1 and map2. This is
*     because the attributes may have changed value since the Mappings
*     were combined.
*     - Any changes made to the component Mappings using the returned
*     pointers will be reflected in the supplied Mapping.

*--

*  Implementation Notes:
*     This function implements the public interface for the
*     astDecompose method. It is identical to astDecompose_ except for
*     the following:
*
*     - ID values are returned via the "map1" and "map2" parameters
*     instead of true C pointers. This is required because this
*     conversion cannot be performed by the macro that invokes the
*     function.
*/

/* Check the global error status. */
   if ( !astOK ) return;

/* Invoke the normal astDecompose_ function to decompose the Mapping. */
      astDecompose( this, map1, map2, series, invert1, invert2 );

/* If required, return ID values for the component Mappings. */
   if ( map1 ) *map1 = astMakeId( *map1 );
   if ( map2 ) *map2 = astMakeId( *map2 );

}

void astMapBoxId_( AstMapping *this,
                   const double lbnd_in[], const double ubnd_in[],
                   int forward, int coord_out,
                   double *lbnd_out, double *ubnd_out,
                   double xl[], double xu[], int *status ) {
/*
*++
*  Name:
c     astMapBox
f     AST_MAPBOX

*  Purpose:
*     Find a bounding box for a Mapping.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astMapBox( AstMapping *this,
c                     const double lbnd_in[], const double ubnd_in[],
c                     int forward, int coord_out,
c                     double *lbnd_out, double *ubnd_out,
c                     double xl[], double xu[] );
f     CALL AST_MAPBOX( THIS, LBND_IN, UBND_IN, FORWARD, COORD_OUT,
f                      LBND_OUT, UBND_OUT, XL, XU, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function allows you to find the "bounding box" which just
c     encloses another box after it has been transformed by a Mapping
c     (using either its forward or inverse transformation). A typical
c     use might be to calculate the size of an image after being
c     transformed by a Mapping.
f     This routine allows you to find the "bounding box" which just
f     encloses another box after it has been transformed by a Mapping
f     (using either its forward or inverse transformation). A typical
f     use might be to calculate the size of an image after being
f     transformed by a Mapping.
*
c     The function works on one dimension at a time. When supplied
c     with the lower and upper bounds of a rectangular region (box) of
c     input coordinate space, it finds the lowest and highest values
c     taken by a nominated output coordinate within that
c     region. Optionally, it also returns the input coordinates where
c     these bounding values are attained. It should be used repeatedly
c     to obtain the extent of the bounding box in more than one
c     dimension.
f     The routine works on one dimension at a time. When supplied with
f     the lower and upper bounds of a rectangular region (box) of
f     input coordinate space, it finds the lowest and highest values
f     taken by a nominated output coordinate within that region. It
f     also returns the input coordinates where these bounding values
f     are attained. It should be used repeatedly to obtain the extent
f     of the bounding box in more than one dimension.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping.
c     lbnd_in
f     LBND_IN( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of double, with one element for each
c        Mapping input coordinate. This should contain the lower bound
c        of the input box in each input dimension.
f        An array with one element for each Mapping input
f        coordinate. This should contain the lower bound of the input
f        box in each input dimension.
c     ubnd_in
f     UBND_IN( * ) = DOUBLE PRECISION (Given)
c        Pointer to an array of double, with one element for each
c        Mapping input coordinate. This should contain the upper bound
c        of the input box in each input dimension.
f        An array with one element for each Mapping input
f        coordinate. This should contain the upper bound of the input
f        box in each input dimension.
*
*        Note that it is permissible for the upper bound to be less
*        than the corresponding lower bound, as the values will simply
*        be swapped before use.
c     forward
f     FORWARD = LOGICAL (Given)
c        If this value is non-zero, then the Mapping's forward
c        transformation will be used to transform the input
c        box. Otherwise, its inverse transformation will be used.
f        If this value is .TRUE., then the Mapping's forward
f        transformation will be used to transform the input
f        box. Otherwise, its inverse transformation will be used.
*
c        (If the inverse transformation is selected, then references
c        to "input" and "output" coordinates in this description
c        should be transposed. For example, the size of the "lbnd_in"
c        and "ubnd_in" arrays should match the number of output
c        coordinates, as given by the Mapping's Nout
c        attribute. Similarly, the "coord_out" parameter, below,
c        should nominate one of the Mapping's input coordinates.)
f        (If the inverse transformation is selected, then references
f        to "input" and "output" coordinates in this description
f        should be transposed. For example, the size of the LBND_IN
f        and UBND_IN arrays should match the number of output
f        coordinates, as given by the Mapping's Nout attribute.
f        Similarly, the COORD_OUT argument, below, should nominate one
f        of the Mapping's input coordinates.)
c     coord_out
f     COORD_OUT = INTEGER (Given)
*        The index of the output coordinate for which the lower and
*        upper bounds are required. This value should be at least one,
*        and no larger than the number of Mapping output coordinates.
c     lbnd_out
f     LBND_OUT = DOUBLE PRECISION (Returned)
c        Pointer to a double in which to return the lowest value taken
c        by the nominated output coordinate within the specified
c        region of input coordinate space.
f        The lowest value taken by the nominated output coordinate
f        within the specified region of input coordinate space.
c     ubnd_out
f     UBND_OUT = DOUBLE PRECISION (Returned)
c        Pointer to a double in which to return the highest value
c        taken by the nominated output coordinate within the specified
c        region of input coordinate space.
f        The highest value taken by the nominated output coordinate
f        within the specified region of input coordinate space.
c     xl
f     XL( * ) = DOUBLE PRECISION (Returned)
c        An optional pointer to an array of double, with one element
c        for each Mapping input coordinate. If given, this array will
c        be filled with the coordinates of an input point (although
c        not necessarily a unique one) for which the nominated output
c        coordinate attains the lower bound value returned in
c        "*lbnd_out".
c
c        If these coordinates are not required, a NULL pointer may be
c        supplied.
f        An array with one element for each Mapping input
f        coordinate. This will return the coordinates of an input
f        point (although not necessarily a unique one) for which the
f        nominated output coordinate attains the lower bound value
f        returned in LBND_OUT.
c     xu
f     XU( * ) = DOUBLE PRECISION (Returned)
c        An optional pointer to an array of double, with one element
c        for each Mapping input coordinate. If given, this array will
c        be filled with the coordinates of an input point (although
c        not necessarily a unique one) for which the nominated output
c        coordinate attains the upper bound value returned in
c        "*ubnd_out".
c
c        If these coordinates are not required, a NULL pointer may be
c        supplied.
f        An array with one element for each Mapping input
f        coordinate. This will return the coordinates of an input
f        point (although not necessarily a unique one) for which the
f        nominated output coordinate attains the upper bound value
f        returned in UBND_OUT.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - Any input points which are transformed by the Mapping to give
*     output coordinates containing the value AST__BAD are regarded as
*     invalid and are ignored. They will make no contribution to
*     determining the output bounds, even although the nominated
*     output coordinate might still have a valid value at such points.
c     - An error will occur if the required output bounds cannot be
c     found. Typically, this might happen if all the input points
c     which the function considers turn out to be invalid (see
c     above). The number of points considered before generating such
c     an error is quite large, so this is unlikely to occur by
c     accident unless valid points are restricted to a very small
c     subset of the input coordinate space.
f     - An error will occur if the required output bounds cannot be
f     found. Typically, this might happen if all the input points
f     which the routine considers turn out to be invalid (see
f     above). The number of points considered before generating such
f     an error is quite large, so this is unlikely to occur by
f     accident unless valid points are restricted to a very small
f     subset of the input coordinate space.
c     - The values returned via "lbnd_out", "ubnd_out", "xl" and "xu"
c     will be set to the value AST__BAD if this function should fail
c     for any reason. Their initial values on entry will not be
c     altered if the function is invoked with the AST error status
c     set.
f     - The values returned via LBND_OUT, UBND_OUT, XL and XU will be
f     set to the value AST__BAD if this routine should fail for any
f     reason. Their initial values on entry will not be altered if the
f     routine is invoked with STATUS set to an error value.
*--

*  Implementation Notes:
*     This function implements the public interface for the astMapBox
*     method. It is identical to astMapBox_ except that the nominated
*     output coordinate given in "coord_out" is decremented by one
*     before use.  This is to allow the public interface to use
*     one-based coordinate numbering (internally, zero-based
*     coordinate numbering is used).
*/

/* Check the global error status. */
   if ( !astOK ) return;

/* Invoke the protected version of this function with the "coord_out"
   value decremented. */
   astMapBox( this, lbnd_in, ubnd_in, forward, coord_out - 1,
              lbnd_out, ubnd_out, xl, xu );
}

double astRateId_( AstMapping *this, double *at, int ax1, int ax2, int *status ){
/*
*++
*  Name:
c     astRate
f     AST_RATE

*  Purpose:
*     Calculate the rate of change of a Mapping output.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     double astRate( AstMapping *this, double *at, int ax1, int ax2 )
f     RESULT = AST_RATE( THIS, AT, AX1, AX2, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function
f     This routine
*     evaluates the rate of change of a specified output of the supplied
*     Mapping with respect to a specified input, at a specified input
*     position.
*
*     The result is estimated by interpolating the function using a
*     fourth order polynomial in the neighbourhood of the specified
*     position. The size of the neighbourhood used is chosen to minimise
*     the RMS residual per unit length between the interpolating
*     polynomial and the supplied Mapping function. This method produces
*     good accuracy but can involve evaluating the Mapping 100 or more
*     times.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be applied.
c     at
f     AT( * ) = DOUBLE PRECISION (Given)
c        The address of an
f        An
*        array holding the axis values at the position at which the rate
*        of change is to be evaluated. The number of elements in this
*        array should equal the number of inputs to the Mapping.
c     ax1
f     AX1 = INTEGER (Given)
*        The index of the Mapping output for which the rate of change is to
*        be found (output numbering starts at 1 for the first output).
c     ax2
f     AX2 = INTEGER (Given)
*        The index of the Mapping input which is to be varied in order to
*        find the rate of change (input numbering starts at 1 for the first
*        input).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astRate()
f     AST_RATE = DOUBLE PRECISION
c        The rate of change of Mapping output "ax1" with respect to input
c        "ax2", evaluated at "at", or AST__BAD if the value cannot be
c        calculated.
f        The rate of change of Mapping output AX1 with respect to input
f        AX2, evaluated at AT, or AST__BAD if the value cannot be
f        calculated.

*  Notes:
*     - A value of AST__BAD will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*--

*  Implementation Notes:
*     This function implements the public interface for the astRate
*     method. It is identical to astRate_ except that the nominated
*     coordinates given in "ax1" and "ax2" are decremented by one
*     before use.  This is to allow the public interface to use
*     one-based coordinate numbering (internally, zero-based
*     coordinate numbering is used).
*/

/* Check the global error status. */
   if ( !astOK ) return AST__BAD;

/* Invoke the protected version of this function with the axis indices
   decremented. */
   return astRate( this, at, ax1 - 1, ax2 - 1 );
}

void astMapSplitId_( AstMapping *this, int nin, const int *in, int *out,
                     AstMapping **map, int *status ){
/*
*++
*  Name:
c     astMapSplit
f     AST_MAPSPLIT

*  Purpose:
*     Split a Mapping up into parallel component Mappings.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "mapping.h"
c     void astMapSplit( AstMapping *this, int nin, const int *in, int *out,
c                       AstMapping **map )
f     CALL AST_MAPSPLIT( THIS, NIN, IN, OUT, MAP, STATUS )

*  Class Membership:
*     Mapping method.

*  Description:
c     This function
f     This routine
*     creates a new Mapping which connects specified inputs within a
*     supplied Mapping to the corresponding outputs of the supplied Mapping.
*     This is only possible if the specified inputs correspond to some
*     subset of the Mapping outputs. That is, there must exist a subset of
*     the Mapping outputs for which each output depends only on the selected
*     Mapping inputs, and not on any of the inputs which have not been
*     selected. Also, any output which is not in this subset must not depend
*     on any of the selected inputs. If these conditions are not met by the
*     supplied Mapping, then
c     a NULL
f     an AST__NULL
*     Mapping pointer is returned.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Mapping to be split.
c     nin
f     NIN = INTEGER (Given)
c        The number of inputs to pick from "this".
f        The number of inputs to pick from THIS.
c     in
f     IN( NIN ) = INTEGER (Given)
c        Pointer to an
f        An
*        array holding the indices within the supplied Mapping of the inputs
*        which are to be picked from the Mapping.
c        This array should have "nin" elements.
*        If "Nin" is the number of inputs of the supplied Mapping, then each
*        element should have a value in the range 1 to Nin.
c     out
f     OUT( * ) = INTEGER (Returned)
c        Pointer to an
f        An
*        array in which to return the indices of the outputs of the supplied
*        Mapping which are fed by the picked inputs. A value of one is
*        used to refer to the first Mapping output. The supplied array should
*        have a length at least equal to the number of outputs in the
*        supplied Mapping. The number of values stored in the array on
*        exit will equal the number of outputs in the returned Mapping.
*        The i'th element in the returned array holds the index within
*        the supplied Mapping which corresponds to the i'th output of
*        the returned Mapping.
c     map
f     MAP = INTEGER (Returned)
c        Address of a location at which to return a pointer to the
f        The
*        returned Mapping. This Mapping will have
c        "nin" inputs (the number of outputs may be different to "nin"). NULL
f        NIN inputs (the number of outputs may be different to NIN). AST__NULL
*        is returned if the supplied Mapping has no subset of outputs which
*        depend only on the selected inputs. The returned Mapping is a
*        deep copy of the required parts of the supplied Mapping.

*  Notes:
*     - If this
c     function
f     routine
*     is invoked with the global error status set, or if it should fail for
*     any reason, then
c     a NULL value
f     AST__NULL
*     will be returned for
c     the "map" pointer.
f     MAP.
*--

*  Implementation Notes:
*     - This function implements the astMapSplit method available via the
*     public interface to the Mapping class and uses 1-based axis indices.
*     The protected interface method is provided by the astMapSplit function
*     and uses zero-based axis indices. Also, an ID value is returned for
*     "map" rather than a pointer.
*/

/* Local Variables: */
   int *in_zero;           /* Pointer to array of zero-based input indices */
   int *result;            /* Pointer to array of zero-based output indices*/
   int i;                  /* Axis index */
   int nout;               /* No of outputs */

/* Initialise */
   *map = NULL;

/* Check the global error status. */
   if ( !astOK ) return;

/* Decrement the axis indices by 1. */
   in_zero = astMalloc( sizeof( int )*(size_t) nin );
   if( in_zero ) {
      for( i = 0; i < nin; i++ ) in_zero[ i ] = in[ i ] - 1;

/* Invoked the protected astMapSplit functon. */
      result = astMapSplit( this, nin, in_zero, map );

/* If succesful, copy the output axes to the supplied array. */
      if( result ) {
         nout = astGetNout( *map );
         for( i = 0; i < nout; i++ ) out[ i ] = result[ i ] + 1;

/* Free resurces. */
         result = astFree( result );
      }
      in_zero = astFree( in_zero );
   }

/* Free the returned Mapping if an error has occurred. */
   if( !astOK ) *map = astAnnul( *map );

/* Return an ID value for the Mapping. */
   *map = astMakeId( *map );
}