Merge commit '7fde2daeed593684120d75de07598154f3ddaf2c' as 'ast'

1 files changed, 856 insertions, 0 deletions

diff --git a/ast/mapping.h b/ast/mapping.h
new file mode 100644
index 0000000..7b63fa2
--- /dev/null
+++ b/ast/mapping.h
@@ -0,0 +1,856 @@
+#if !defined( MAPPING_INCLUDED ) /* Include this file only once */
+#define MAPPING_INCLUDED
+/*
+*++
+*  Name:
+*     mapping.h
+
+*  Type:
+*     C include file.
+
+*  Purpose:
+*     Define the interface to the Mapping class.
+
+*  Invocation:
+*     #include "mapping.h"
+
+*  Description:
+*     This include file defines the interface to the Mapping class and
+*     provides the type definitions, function prototypes and macros, etc.
+*     needed to use this class.
+*
+*     The Mapping class provides basic facilities for transforming a
+*     set of points to give a new set of points and for resampling
+*     grids of data. However, it does not have a constructor
+*     function. This is because the class only forms a template for
+*     deriving new classes which themselves implement specific forms
+*     of coordinate transformation. They do this by extending the
+*     protected astTransform method provided by this class.
+
+*  Inheritance:
+*     The Mapping class inherits from the Object class.
+
+*  Attributes Over-Ridden:
+*     None.
+
+*  New Attributes Defined:
+*     Nin (integer)
+*        A read-only attribute giving 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).
+*     Nout (integer)
+*        A read-only attribute giving 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).
+*     Invert (integer)
+*        A boolean value (0 or 1) which controls which of a Mapping's
+*        two possible coordinate transformations is considered the
+*        "forward" transformation and which is the "inverse"
+*        transformation. If this value is zero (the default), the
+*        behaviour will be as defined when the Mapping was first
+*        created.  If it is non-zero, the transformations will be
+*        inter-changed, so that the Mapping displays the inverse of
+*        its original behaviour.
+*
+*        Note that inverting the boolean sense of the Invert attribute
+*        will cause the values of the Nin/Nout and
+*        TranForward/TranInverse attributes to be interchanged.
+*     Report (integer)
+*        A boolean value (0 or 1) which controls whether to report
+*        coordinate values when a Mapping is used to transform a set
+*        of points. If this value is zero (the default), no report is
+*        made. If it is non-zero, the coordinates of each point
+*        (before and after transformation) are reported by writing
+*        them to standard output.
+*
+*        This attribute is intended as an aid to debugging and to save
+*        having to report values explicitly in simple programs.
+*        Unlike other attributes, the value of the Report attribute is
+*        not inherited when a Mapping is copied (its value is
+*        initially undefined, and therefore defaults to zero, in any
+*        copy).
+*     IsSimple (boolean)
+*        A read-only attribute indicating if the Mapping has been
+*        simpified.
+*     TranForward (integer)
+*        A read-only boolean value (0 or 1) which indicates whether a
+*        Mapping is able to transform coordinates in the "forward"
+*        direction (i.e. converting input coordinates into output
+*        coordinates).
+*     TranInverse (integer)
+*        A read-only boolean value (0 or 1) which indicates whether a
+*        Mapping is able to transform coordinates in the "inverse"
+*        direction (i.e. converting output coordinates back into input
+*        coordinates).
+
+*  Methods Over-Ridden:
+*     Public:
+*        None.
+*
+*     Protected:
+*        astClearAttrib
+*           Clear an attribute value for a Mapping.
+*        astGetAttrib
+*           Get an attribute value for a Mapping.
+*        astSetAttrib
+*           Set an attribute value for a Mapping.
+*        astTestAttrib
+*           Test if an attribute value has been set for a Mapping.
+
+*  New Methods Defined:
+*     Public:
+*        astDecompose
+*           Decompose a Mapping into two component Mappings.
+*        astInvert
+*           Invert a Mapping.
+*        astLinearApprox
+*           Form a linear approximation to a Mapping
+*        astMapBox
+*           Find a bounding box for a Mapping.
+*        astQuadApprox
+*           Form a quadratic approximation to a Mapping
+*        astRate
+*           Find rate of change of a Mapping output
+*        astRebin<X>
+*           Rebin a region of a data grid.
+*        astRebinSeq<X>
+*           Rebin a region of a sequence of data grids.
+*        astResample<X>
+*           Resample a region of a data grid.
+*        astSimplify
+*           Simplify a Mapping.
+*        astTran1
+*           Transform 1-dimensional coordinates.
+*        astTran2
+*           Transform 2-dimensional coordinates.
+*        astTranGrid
+*           Transform an N-dimensional regular grid of positions.
+*        astTranN
+*           Transform N-dimensional coordinates.
+*        astTranP (C only)
+*           Transform N-dimensional coordinates held in separate arrays.
+*
+*     Protected:
+*        astClearInvert
+*           Clear the Invert attribute value for a Mapping.
+*        astClearReport
+*           Clear the Report attribute value for a Mapping.
+*        astGetInvert
+*           Get the Invert attribute value for a Mapping.
+*        astGetIsSimple
+*           Get the IsSimple attribute.
+*        astGetNin
+*           Get the number of input coordinates for a Mapping.
+*        astGetNout
+*           Get the number of output coordinates for a Mapping.
+*        astGetReport
+*           Get the Report attribute value for a Mapping.
+*        astGetTranForward
+*           Determine if a Mapping can perform a "forward" coordinate
+*           transformation.
+*        astGetTranInverse
+*           Determine if a Mapping can perform an "inverse" coordinate
+*           transformation.
+*        astMapList
+*           Decompose a Mapping into a sequence of simpler Mappings.
+*        astMapSplit
+*           Select a subset of Mapping inputs.
+*        astMapMerge
+*           Simplify a sequence of Mappings.
+*        astReportPoints
+*           Report the effect of transforming a set of points using a Mapping.
+*        astSetInvert
+*           Set the Invert attribute value for a Mapping.
+*        astSetReport
+*           Set the Report attribute value for a Mapping.
+*        astTestInvert
+*           Test if an Invert attribute value has been set for a Mapping.
+*        astTestReport
+*           Test if an Report attribute value has been set for a Mapping.
+*        astTransform
+*           Transform a set of points.
+
+*  Other Class Functions:
+*     Public:
+*        astIsAMapping
+*           Test class membership.
+*
+*     Protected:
+*        astCheckMapping
+*           Validate class membership.
+*        astInitMapping
+*           Initialise a Mapping.
+*        astInitMappingVtab
+*           Initialise the virtual function table for the Mapping class.
+*        astLoadMapping
+*           Load a Mapping.
+
+*  Macros:
+*     Public:
+*        AST__BLOCKAVE
+*           Block averaging interpolation.
+*        AST__GAUSS
+*           Use exp(-k*x*x) spreading.
+*        AST__LINEAR
+*           Simple linear interpolation.
+*        AST__NEAREST
+*           Use nearest pixel centre.
+*        AST__SINC
+*           Use sinc(pi*x) interpolation.
+*        AST__SINCCOS
+*           Use sinc(pi*x)*cos(k*pi*x) interpolation.
+*        AST__SINCGAUSS
+*           Use sinc(pi*x)*exp(-k*x*x) interpolation.
+*        AST__SINCSINC
+*           Use sinc(pi*x)*sinc(k*pi*x) interpolation.
+*        AST__SOMB
+*           Use somb(pi*x) interpolation.
+*        AST__SOMBCOS
+*           Use somb(pi*x)*cos(k*pi*x) interpolation.
+*        AST__UINTERP
+*           Use general user-defined sub-pixel interpolation algorithm.
+*        AST__UKERN1
+*           Use user-defined 1-d interpolation kernel.
+*        AST__URESAMP1, 2, 3 & 4
+*           Flags reserved for user-defined purposes.
+*        AST__USEBAD
+*           Recognise bad pixels?
+*        AST__CONSERVEFLUX
+*           Conserve flux in astResample?
+*        AST__REBININIT
+*           Initialise a new sequnece of calls to astRebinSeq<X>
+*        AST__REBINEND
+*           End a sequnece of calls to astRebinSeq<X>
+*        AST__NOBAD
+*           Leave bad output pixels unchanged in calls to astResample<X>
+*        AST__USEVAR
+*           Use variance arrays?
+
+*  Type Definitions:
+*     Public:
+*        AstMapping
+*           Mapping object type.
+*
+*     Protected:
+*        AstMappingVtab
+*           Mapping virtual function table type.
+
+*  Feature Test Macros:
+*     astCLASS
+*        If the astCLASS macro is undefined, only public symbols are
+*        made available, otherwise protected symbols (for use in other
+*        class implementations) are defined. This macro also affects
+*        the reporting of error context information, which is only
+*        provided for external calls to the AST library.
+
+*  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:
+*     30-JAN-1996 (RFWS):
+*        Original version.
+*     12-JUL-1996 (RFWS):
+*        Updated to support the external interface plus various other
+*        additions.
+*     12-DEC-1996 (RFWS):
+*        Added the astMapList method.
+*     13-DEC-1996 (RFWS):
+*        Added the astMapMerge method.
+*     13-DEC-1996 (RFWS):
+*        Added the astSimplify method.
+*     28-MAY-1998 (RFWS):
+*        Added the astMapBox method.
+*     12-NOV-1998 (RFWS):
+*        Added astResample<X> and associated code.
+*     24-NOV-2000 (MBT):
+*        Added AST__BLOCKAVE interpolation scheme.
+*     9-JAN-2001 (DSB):
+*        Changed in and out arguments for TranN from type "double (*)[]"
+*        to "double *".
+*     8-JAN-2003 (DSB):
+*        Added protected astInitMappingVtab method.
+*     10-JUL-2003 (DSB):
+*        Added method astRate.
+*     20-SEP-2004 (DSB):
+*        Added method astLinearApprox.
+*     30-JUN-2005 (DSB):
+*        Added method astRebin
+*     1-SEP-2005 (DSB):
+*        Added method astRebinSeq
+*     31-JAN-2006 (DSB):
+*        Added IsSimple attribute.
+*     2-MAR-2006 (DSB):
+*        Use HAVE_LONG_DOUBLE in place of AST_LONG_DOUBLE
+*     8-MAR-2006 (DSB):
+*        Add astTranGrid.
+*     5-MAY-2009 (DSB):
+*        Add astRemoveRegions.
+*     26-FEB-2010 (DSB):
+*        Added method astQuadApprox.
+*--
+*/
+
+/* Include files. */
+/* ============== */
+
+/* Configuration results */
+/* --------------------- */
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* Interface definitions. */
+/* ---------------------- */
+#include "object.h"              /* Base Object class */
+#include "pointset.h"            /* Sets of points/coordinates */
+#include "channel.h"             /* I/O channels */
+
+/* C header files. */
+/* --------------- */
+#include <stddef.h>
+#include <stdint.h>
+
+/* Macros. */
+/* ======= */
+
+/* Sizes of global arrays */
+
+#if defined(astCLASS) || defined(astFORTRAN77)
+#define STATUS_PTR status
+#else
+#define STATUS_PTR astGetStatusPtr
+#endif
+#define AST__MAPPING_GETATTRIB_BUFF_LEN 50
+#define AST__MAPPING_RATEFUN_MAX_CACHE  5
+
+/* Resampling flags. */
+/* ----------------- */
+/* These macros define flag values which may be passed to
+   astResample<X> (via the "flags" argument) to provide control over
+   resampling operations. */
+#define AST__URESAMP1 (1)        /* Flags reserved for user-defined purposes */
+#define AST__URESAMP2 (2)
+#define AST__URESAMP3 (4)
+#define AST__URESAMP4 (8)
+#define AST__USEVAR (16)         /* Use variance arrays? */
+#define AST__USEBAD (32)         /* Recognise bad pixels? */
+#define AST__CONSERVEFLUX (64)   /* Conserve flux? */
+#define AST__REBININIT (128)     /* Initialise a new sequence of calls to astRebinSeq? */
+#define AST__REBINEND (256)      /* End a sequence of calls to astRebinSeq? */
+#define AST__GENVAR (512)        /* Generate output variances when rebinning? */
+#define AST__VARWGT (1024)       /* Use input variances as weights? */
+#define AST__NOBAD (2048)        /* Leave bad output values unchanged? */
+#define AST__DISVAR (4096)       /* Generate distribution (not mean) variance? */
+#define AST__NONORM (8192)       /* No normalisation required at end? */
+
+/* These macros identify standard sub-pixel interpolation algorithms
+   for use by astResample<X>. They are used by giving the macro's
+   value for the "interp" argument. */
+#define AST__UKERN1 (1)          /* User-supplied 1-d interpolation kernel */
+#if 0                            /* Not yet implemented */
+#define AST__UKERNN (2)          /* User-supplied n-d interpolation kernel */
+#endif
+#define AST__UINTERP (3)         /* User-supplied interpolation function */
+#define AST__NEAREST (4)         /* Use pixel with nearest centre */
+#define AST__LINEAR (5)          /* Simple linear interpolation */
+#define AST__SINC (6)            /* sinc(pi*x) interpolation */
+#define AST__SINCSINC (7)        /* sinc(pi*x)*sinc(k*pi*x) interpolation */
+#define AST__SINCCOS (8)         /* sinc(pi*x)*cos(k*pi*x) interpolation */
+#define AST__SINCGAUSS (9)       /* sinc(pi*x)*exp(-k*x*x) interpolation */
+#define AST__BLOCKAVE (10)       /* Block averaging interpolation */
+#define AST__GAUSS (11)          /* exp(-k*x*x) spreading */
+#define AST__SOMB (12)           /* somp(pi*x) interpolation */
+#define AST__SOMBCOS (13)        /* somp(pi*x)*cos(k*pi*x) interpolation */
+
+/* 64 bit types */
+#if HAVE_INT64_T && HAVE_UINT64_T
+#include <stdint.h>
+typedef int64_t INT_BIG;
+typedef uint64_t UINT_BIG;
+
+#elif SIZEOF_LONG == 8
+typedef long int INT_BIG;
+typedef unsigned long int UINT_BIG;
+
+#elif SIZEOF_LONG_LONG == 8
+typedef long long int INT_BIG;
+typedef unsigned long long int UINT_BIG;
+
+#else
+#define INT_BIG  "no int64_t type available"
+#define UINT_BIG "no uint64_t type available"
+#endif
+
+/* Flags defining the meaning of each bit in the "flags" field of the
+   Mapping structure. */
+#if defined(astCLASS)         /* Protected */
+#define AST__ISSIMPLE_FLAG 1  /* Mapping has been simplified */
+#define AST__FROZEN_FLAG 2    /* Mapping cannot be nominated for simplification */
+#endif
+
+
+/* Type Definitions. */
+/* ================= */
+/* Mapping structure. */
+/* ------------------ */
+/* This structure contains all information that is unique to each
+   object in the class (e.g. its instance variables). */
+typedef struct AstMapping {
+
+/* Attributes inherited from the parent class. */
+   AstObject object;             /* Parent class structure */
+
+/* Attributes specific to objects in this class. */
+   char invert;                   /* Mapping inverted? */
+   char flags;                    /* Bit-wise flags describing the Mapping */
+   int nin;                       /* Number of input coordinates */
+   int nout;                      /* Number of output coordinates */
+   char report;                   /* Report when converting coordinates? */
+   char tran_forward;             /* Forward transformation defined? */
+   char tran_inverse;             /* Inverse transformation defined? */
+} AstMapping;
+
+/* Virtual function table. */
+/* ----------------------- */
+/* This table contains all information that is the same for all
+   objects in the class (e.g. pointers to its virtual functions). */
+#if defined(astCLASS)            /* Protected */
+typedef struct AstMappingVtab {
+
+/* Properties (e.g. methods) inherited from the parent class. */
+   AstObjectVtab object_vtab;    /* Parent class virtual function table */
+
+/* A Unique identifier to determine class membership. */
+   AstClassIdentifier id;
+
+/* Properties (e.g. methods) specific to this class. */
+   AstMapping *(* RemoveRegions)( AstMapping *, int * );
+   AstMapping *(* Simplify)( AstMapping *, int * );
+   AstPointSet *(* Transform)( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
+   double (* Rate)( AstMapping *, double *, int, int, int * );
+   int (* DoNotSimplify)( AstMapping *, int * );
+   int (* GetInvert)( AstMapping *, int * );
+   int (* GetIsSimple)( AstMapping *, int * );
+   int (* GetNin)( AstMapping *, int * );
+   int (* GetNout)( AstMapping *, int * );
+   int (* GetReport)( AstMapping *, int * );
+   int (* GetTranForward)( AstMapping *, int * );
+   int (* GetTranInverse)( AstMapping *, int * );
+   int (* GetIsLinear)( AstMapping *, int * );
+   int (* LinearApprox)( AstMapping *, const double *, const double *, double, double *, int * );
+   int (* MapMerge)( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
+   int (* QuadApprox)( AstMapping *, const double[2], const double[2], int, int, double *, double *, int * );
+   int (* TestInvert)( AstMapping *, int * );
+   int (* TestReport)( AstMapping *, int * );
+   void (* ClearInvert)( AstMapping *, int * );
+   void (* ClearReport)( AstMapping *, int * );
+   void (* Decompose)( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
+   void (* Invert)( struct AstMapping *, int * );
+   void (* MapBox)( AstMapping *, const double [], const double [], int, int, double *, double *, double [], double [], int * );
+   int (* MapList)( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
+   int *(* MapSplit)( AstMapping *, int, const int *, AstMapping **, int * );
+   void (* ReportPoints)( AstMapping *, int, AstPointSet *, AstPointSet *, int * );
+   void (* SetInvert)( AstMapping *, int, int * );
+   void (* SetReport)( AstMapping *, int, int * );
+   void (* Tran1)( AstMapping *, int, const double [], int, double [], int * );
+   void (* Tran2)( AstMapping *, int, const double [], const double [], int, double [], double [], int * );
+   void (* TranGrid)( AstMapping *, int, const int[], const int[], double, int, int, int, int, double *, int * );
+   void (* TranN)( AstMapping *, int, int, int, const double *, int, int, int, double *, int * );
+   void (* TranP)( AstMapping *, int, int, const double *[], int, int, double *[], int * );
+
+#define DECLARE_GENERIC_ALL(X,Xtype) \
+   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 * ); \
+
+DECLARE_GENERIC_ALL(B,signed char)
+DECLARE_GENERIC_ALL(D,double)
+DECLARE_GENERIC_ALL(F,float)
+DECLARE_GENERIC_ALL(I,int)
+DECLARE_GENERIC_ALL(K,INT_BIG)
+DECLARE_GENERIC_ALL(L,long int)
+DECLARE_GENERIC_ALL(S,short int)
+DECLARE_GENERIC_ALL(UB,unsigned char)
+DECLARE_GENERIC_ALL(UI,unsigned int)
+DECLARE_GENERIC_ALL(UK,UINT_BIG)
+DECLARE_GENERIC_ALL(UL,unsigned long int)
+DECLARE_GENERIC_ALL(US,unsigned short int)
+
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+DECLARE_GENERIC_ALL(LD,long double)
+#endif
+
+#undef DECLARE_GENERIC_ALL
+
+#define DECLARE_GENERIC_DFI(X,Xtype) \
+   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 * ); \
+   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 * );
+
+DECLARE_GENERIC_DFI(D,double)
+DECLARE_GENERIC_DFI(F,float)
+DECLARE_GENERIC_DFI(I,int)
+DECLARE_GENERIC_DFI(B,signed char)
+DECLARE_GENERIC_DFI(UB,unsigned char)
+
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+DECLARE_GENERIC_DFI(LD,long double)
+#endif
+
+#undef DECLARE_GENERIC_DFI
+
+} AstMappingVtab;
+
+
+#if defined(THREAD_SAFE)
+
+/* Define a structure holding all data items that are global within this
+   class. */
+typedef struct AstMappingGlobals {
+   AstMappingVtab Class_Vtab;
+   int Class_Init;
+   char GetAttrib_Buff[ AST__MAPPING_GETATTRIB_BUFF_LEN + 1 ];
+   AstMapping *Unsimplified_Mapping;
+   int Rate_Disabled;
+   AstPointSet *RateFun_Pset1_Cache[ AST__MAPPING_RATEFUN_MAX_CACHE ];
+   AstPointSet *RateFun_Pset2_Cache[ AST__MAPPING_RATEFUN_MAX_CACHE ];
+   int RateFun_Next_Slot;
+   int RateFun_Pset_Size[ AST__MAPPING_RATEFUN_MAX_CACHE ];
+} AstMappingGlobals;
+
+#endif
+#endif
+
+/* Function prototypes. */
+/* ==================== */
+/* Prototypes for standard class functions. */
+/* ---------------------------------------- */
+astPROTO_CHECK(Mapping)          /* Check class membership */
+astPROTO_ISA(Mapping)            /* Test class membership */
+
+/* NB. There is no constructor function for this class. */
+
+#if defined(astCLASS)            /* Protected */
+
+/* Initialiser. */
+AstMapping *astInitMapping_( void *, size_t, int, AstMappingVtab *,
+                             const char *, int, int, int, int, int * );
+
+/* Vtab initialiser. */
+void astInitMappingVtab_( AstMappingVtab *, const char *, int * );
+
+/* Loader. */
+AstMapping *astLoadMapping_( void *, size_t, AstMappingVtab *,
+                             const char *, AstChannel *channel, int * );
+
+/* Thread-safe initialiser for all global data used by this module. */
+#if defined(THREAD_SAFE)
+void astInitMappingGlobals_( AstMappingGlobals * );
+#endif
+#endif
+
+/* Prototypes for member functions. */
+/* -------------------------------- */
+#define PROTO_GENERIC_ALL(X,Xtype) \
+   int astResample##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 * ); \
+
+PROTO_GENERIC_ALL(B,signed char)
+PROTO_GENERIC_ALL(D,double)
+PROTO_GENERIC_ALL(F,float)
+PROTO_GENERIC_ALL(I,int)
+PROTO_GENERIC_ALL(K,INT_BIG)
+PROTO_GENERIC_ALL(L,long int)
+PROTO_GENERIC_ALL(S,short int)
+PROTO_GENERIC_ALL(UB,unsigned char)
+PROTO_GENERIC_ALL(UI,unsigned int)
+PROTO_GENERIC_ALL(UK,UINT_BIG)
+PROTO_GENERIC_ALL(UL,unsigned long int)
+PROTO_GENERIC_ALL(US,unsigned short int)
+
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+PROTO_GENERIC_ALL(LD,long double)
+#endif
+
+#undef PROTO_GENERIC_ALL
+
+#define PROTO_GENERIC_DFI(X,Xtype) \
+   void astRebin##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 * ); \
+   void astRebinSeq##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 * );
+
+PROTO_GENERIC_DFI(D,double)
+PROTO_GENERIC_DFI(F,float)
+PROTO_GENERIC_DFI(I,int)
+PROTO_GENERIC_DFI(B,signed char)
+PROTO_GENERIC_DFI(UB,unsigned char)
+
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+PROTO_GENERIC_DFI(LD,long double)
+#endif
+
+#undef PROTO_GENERIC_DFI
+
+AstMapping *astRemoveRegions_( AstMapping *, int * );
+AstMapping *astSimplify_( AstMapping *, int * );
+void astInvert_( AstMapping *, int * );
+int astLinearApprox_( AstMapping *, const double *, const double *, double, double *, int * );
+int astQuadApprox_( AstMapping *, const double[2], const double[2], int, int, double *, double *, int * );
+void astTran1_( AstMapping *, int, const double [], int, double [], int * );
+void astTran2_( AstMapping *, int, const double [], const double [], int, double [], double [], int * );
+void astTranGrid_( AstMapping *, int, const int[], const int[], double, int, int, int, int, double *, int * );
+void astTranN_( AstMapping *, int, int, int, const double *, int, int, int, double *, int * );
+void astTranP_( AstMapping *, int, int, const double *[], int, int, double *[], int * );
+
+#if defined(astCLASS)            /* Protected */
+void astDecompose_( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
+void astMapBox_( AstMapping *, const double [], const double [], int, int, double *, double *, double [], double [], int * );
+double astRate_( AstMapping *, double *, int, int, int * );
+int *astMapSplit_( AstMapping *, int, const int *, AstMapping **, int * );
+#else
+void astDecomposeId_( AstMapping *, AstMapping **, AstMapping **, int *, int *, int *, int * );
+void astMapBoxId_( 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 * );
+#endif
+
+#if defined(astCLASS)            /* Protected */
+int astRateState_( int, int * );
+AstPointSet *astTransform_( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
+int astGetInvert_( AstMapping *, int * );
+int astGetIsSimple_( AstMapping *, int * );
+int astGetNin_( AstMapping *, int * );
+int astGetNout_( AstMapping *, int * );
+int astGetReport_( AstMapping *, int * );
+int astGetTranForward_( AstMapping *, int * );
+int astGetTranInverse_( AstMapping *, int * );
+int astGetIsLinear_( AstMapping *, int * );
+int astDoNotSimplify_( AstMapping *, int * );
+int astMapMerge_( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
+int astTestInvert_( AstMapping *, int * );
+int astTestReport_( AstMapping *, int * );
+void astClearInvert_( AstMapping *, int * );
+void astClearReport_( AstMapping *, int * );
+int astMapList_( AstMapping *, int, int, int *, AstMapping ***, int **, int * );
+void astReportPoints_( AstMapping *, int, AstPointSet *, AstPointSet *, int * );
+void astSetInvert_( AstMapping *, int, int * );
+void astSetReport_( AstMapping *, int, int * );
+#endif
+
+/* Function interfaces. */
+/* ==================== */
+/* These macros are wrap-ups for the functions defined by this class to make
+   them easier to invoke (e.g. to avoid type mis-matches when passing pointers
+   to objects from derived classes). */
+
+/* Interfaces to standard class functions. */
+/* --------------------------------------- */
+/* Some of these functions provide validation, so we cannot use them to
+   validate their own arguments. We must use a cast when passing object
+   pointers (so that they can accept objects from derived classes). */
+
+/* Check class membership. */
+#define astCheckMapping(this) astINVOKE_CHECK(Mapping,this,0)
+#define astVerifyMapping(this) astINVOKE_CHECK(Mapping,this,1)
+
+/* Test class membership. */
+#define astIsAMapping(this) astINVOKE_ISA(Mapping,this)
+
+/* NB. There is no constructor function for this class. */
+
+#if defined(astCLASS)            /* Protected */
+
+/* Initialiser. */
+#define astInitMapping(mem,size,init,vtab,name,nin,nout,tran_forward,tran_inverse) \
+astINVOKE(O,astInitMapping_(mem,size,init,vtab,name,nin,nout,tran_forward,tran_inverse,STATUS_PTR))
+
+/* Vtab Initialiser. */
+#define astInitMappingVtab(vtab,name) astINVOKE(V,astInitMappingVtab_(vtab,name,STATUS_PTR))
+/* Loader. */
+#define astLoadMapping(mem,size,vtab,name,channel) \
+astINVOKE(O,astLoadMapping_(mem,size,vtab,name,astCheckChannel(channel),STATUS_PTR))
+#endif
+
+/* Interfaces to member functions. */
+/* ------------------------------- */
+/* Here we make use of astCheckMapping (et al.) to validate Mapping
+   pointers before use. This provides a contextual error report if a
+   pointer to the wrong sort of object is supplied. */
+#if HAVE_LONG_DOUBLE     /* Not normally implemented */
+#define astResampleLD(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) \
+astINVOKE(V,astResampleLD_(astCheckMapping(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_PTR))
+#endif
+
+#define astInvert(this) \
+astINVOKE(V,astInvert_(astCheckMapping(this),STATUS_PTR))
+#define astLinearApprox(this,lbnd,ubnd,tol,fit) \
+astINVOKE(V,astLinearApprox_(astCheckMapping(this),lbnd,ubnd,tol,fit,STATUS_PTR))
+#define astQuadApprox(this,lbnd,ubnd,nx,ny,fit,rms) \
+astINVOKE(V,astQuadApprox_(astCheckMapping(this),lbnd,ubnd,nx,ny,fit,rms,STATUS_PTR))
+#define astRebinD(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) \
+astINVOKE(V,astRebinD_(astCheckMapping(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_PTR))
+#define astRebinF(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) \
+astINVOKE(V,astRebinF_(astCheckMapping(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_PTR))
+#define astRebinI(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) \
+astINVOKE(V,astRebinI_(astCheckMapping(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_PTR))
+#define astRebinB(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) \
+astINVOKE(V,astRebinB_(astCheckMapping(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_PTR))
+#define astRebinUB(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) \
+astINVOKE(V,astRebinUB_(astCheckMapping(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_PTR))
+#define astRebinSeqD(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) \
+astINVOKE(V,astRebinSeqD_(astCheckMapping(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_PTR))
+#define astRebinSeqF(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) \
+astINVOKE(V,astRebinSeqF_(astCheckMapping(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_PTR))
+#define astRebinSeqI(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) \
+astINVOKE(V,astRebinSeqI_(astCheckMapping(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_PTR))
+#define astRebinSeqB(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) \
+astINVOKE(V,astRebinSeqB_(astCheckMapping(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_PTR))
+#define astRebinSeqUB(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) \
+astINVOKE(V,astRebinSeqUB_(astCheckMapping(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_PTR))
+#define astResampleD(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) \
+astINVOKE(V,astResampleD_(astCheckMapping(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_PTR))
+#define astResampleF(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) \
+astINVOKE(V,astResampleF_(astCheckMapping(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_PTR))
+#define astResampleL(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) \
+astINVOKE(V,astResampleL_(astCheckMapping(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_PTR))
+#define astResampleUL(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) \
+astINVOKE(V,astResampleUL_(astCheckMapping(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_PTR))
+#define astResampleI(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) \
+astINVOKE(V,astResampleI_(astCheckMapping(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_PTR))
+#define astResampleUI(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) \
+astINVOKE(V,astResampleUI_(astCheckMapping(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_PTR))
+#define astResampleK(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) \
+astINVOKE(V,astResampleK_(astCheckMapping(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_PTR))
+#define astResampleUK(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) \
+astINVOKE(V,astResampleUK_(astCheckMapping(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_PTR))
+#define astResampleS(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) \
+astINVOKE(V,astResampleS_(astCheckMapping(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_PTR))
+#define astResampleUS(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) \
+astINVOKE(V,astResampleUS_(astCheckMapping(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_PTR))
+#define astResampleB(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) \
+astINVOKE(V,astResampleB_(astCheckMapping(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_PTR))
+#define astResampleUB(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) \
+astINVOKE(V,astResampleUB_(astCheckMapping(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_PTR))
+#define astRemoveRegions(this) astINVOKE(O,astRemoveRegions_(astCheckMapping(this),STATUS_PTR))
+#define astSimplify(this) astINVOKE(O,astSimplify_(astCheckMapping(this),STATUS_PTR))
+#define astTran1(this,npoint,xin,forward,xout) \
+astINVOKE(V,astTran1_(astCheckMapping(this),npoint,xin,forward,xout,STATUS_PTR))
+#define astTran2(this,npoint,xin,yin,forward,xout,yout) \
+astINVOKE(V,astTran2_(astCheckMapping(this),npoint,xin,yin,forward,xout,yout,STATUS_PTR))
+#define astTranGrid(this,ncoord_in,lbnd,ubnd,tol,maxpix,forward,ncoord_out,outdim,out) \
+astINVOKE(V,astTranGrid_(astCheckMapping(this),ncoord_in,lbnd,ubnd,tol,maxpix,forward,ncoord_out,outdim,out,STATUS_PTR))
+#define astTranN(this,npoint,ncoord_in,indim,in,forward,ncoord_out,outdim,out) \
+astINVOKE(V,astTranN_(astCheckMapping(this),npoint,ncoord_in,indim,in,forward,ncoord_out,outdim,out,STATUS_PTR))
+#define astTranP(this,npoint,ncoord_in,ptr_in,forward,ncoord_out,ptr_out) \
+astINVOKE(V,astTranP_(astCheckMapping(this),npoint,ncoord_in,ptr_in,forward,ncoord_out,ptr_out,STATUS_PTR))
+
+#if defined(astCLASS)            /* Protected */
+#define astDecompose(this,map1,map2,series,inv1,inv2) \
+astINVOKE(V,astDecompose_(astCheckMapping(this),(AstMapping **)(map1),(AstMapping **)(map2),series,inv1,inv2,STATUS_PTR))
+#define astMapBox(this,lbnd_in,ubnd_in,forward,coord_out,lbnd_out,ubnd_out,xl,xu) \
+astINVOKE(V,astMapBox_(astCheckMapping(this),lbnd_in,ubnd_in,forward,coord_out,lbnd_out,ubnd_out,xl,xu,STATUS_PTR))
+#define astRate(this,at,ax1,ax2) \
+astINVOKE(V,astRate_(astCheckMapping(this),at,ax1,ax2,STATUS_PTR))
+#define astMapSplit(this,nin,in,map) \
+astINVOKE(V,astMapSplit_(this,nin,in,map,STATUS_PTR))
+#else
+#define astDecompose(this,map1,map2,series,inv1,inv2) \
+astINVOKE(V,astDecomposeId_(astCheckMapping(this),(AstMapping **)(map1),(AstMapping **)(map2),series,inv1,inv2,STATUS_PTR))
+#define astMapBox(this,lbnd_in,ubnd_in,forward,coord_out,lbnd_out,ubnd_out,xl,xu) \
+astINVOKE(V,astMapBoxId_(astCheckMapping(this),lbnd_in,ubnd_in,forward,coord_out,lbnd_out,ubnd_out,xl,xu,STATUS_PTR))
+#define astRate(this,at,ax1,ax2) \
+astINVOKE(V,astRateId_(astCheckMapping(this),at,ax1,ax2,STATUS_PTR))
+#define astMapSplit(this,nin,in,out,map) \
+astINVOKE(V,astMapSplitId_(astCheckMapping(this),nin,in,out,map,STATUS_PTR))
+#endif
+
+#if defined(astCLASS)            /* Protected */
+#define astRateState(disabled) astRateState_(disabled,STATUS_PTR)
+#define astClearInvert(this) \
+astINVOKE(V,astClearInvert_(astCheckMapping(this),STATUS_PTR))
+#define astClearReport(this) \
+astINVOKE(V,astClearReport_(astCheckMapping(this),STATUS_PTR))
+#define astGetInvert(this) \
+astINVOKE(V,astGetInvert_(astCheckMapping(this),STATUS_PTR))
+#define astGetIsSimple(this) \
+astINVOKE(V,astGetIsSimple_(astCheckMapping(this),STATUS_PTR))
+#define astGetNin(this) \
+astINVOKE(V,astGetNin_(astCheckMapping(this),STATUS_PTR))
+#define astGetNout(this) \
+astINVOKE(V,astGetNout_(astCheckMapping(this),STATUS_PTR))
+#define astGetReport(this) \
+astINVOKE(V,astGetReport_(astCheckMapping(this),STATUS_PTR))
+#define astGetTranForward(this) \
+astINVOKE(V,astGetTranForward_(astCheckMapping(this),STATUS_PTR))
+#define astGetTranInverse(this) \
+astINVOKE(V,astGetTranInverse_(astCheckMapping(this),STATUS_PTR))
+#define astGetIsLinear(this) \
+astINVOKE(V,astGetIsLinear_(astCheckMapping(this),STATUS_PTR))
+#define astMapList(this,series,invert,nmap,map_list,invert_list) \
+astINVOKE(V,astMapList_(this,series,invert,nmap,map_list,invert_list,STATUS_PTR))
+#define astMapMerge(this,where,series,nmap,map_list,invert_list) \
+astINVOKE(V,astMapMerge_(astCheckMapping(this),where,series,nmap,map_list,invert_list,STATUS_PTR))
+#define astReportPoints(this,forward,in_points,out_points) \
+astINVOKE(V,astReportPoints_(astCheckMapping(this),forward,astCheckPointSet(in_points),astCheckPointSet(out_points),STATUS_PTR))
+#define astSetInvert(this,value) \
+astINVOKE(V,astSetInvert_(astCheckMapping(this),value,STATUS_PTR))
+#define astSetReport(this,value) \
+astINVOKE(V,astSetReport_(astCheckMapping(this),value,STATUS_PTR))
+#define astTestInvert(this) \
+astINVOKE(V,astTestInvert_(astCheckMapping(this),STATUS_PTR))
+#define astTestReport(this) \
+astINVOKE(V,astTestReport_(astCheckMapping(this),STATUS_PTR))
+#define astDoNotSimplify(this) \
+astINVOKE(V,astDoNotSimplify_(astCheckMapping(this),STATUS_PTR))
+
+/* Since a NULL PointSet pointer is acceptable here, we must omit the argument
+   checking in that case. (But unfortunately, "out" then gets evaluated
+   twice - this is unlikely to matter, but is there a better way?) */
+#define astTransform(this,in,forward,out) \
+astINVOKE(O,astTransform_(astCheckMapping(this),astCheckPointSet(in),forward,(out)?astCheckPointSet(out):NULL,STATUS_PTR))
+#endif
+#endif
+
+
+
+
+