path: root/ast/axis.h

#if !defined( AXIS_INCLUDED )    /* Include this file only once */
#define AXIS_INCLUDED
/*
*+
*  Name:
*     axis.h

*  Type:
*     C include file.

*  Purpose:
*     Define the interface to the Axis class.

*  Invocation:
*     #include "axis.h"

*  Description:
*     This include file defines the interface to the Axis class and
*     provides the type definitions, function prototypes and macros,
*     etc.  needed to use this class.
*
*     The Axis class implements the basic behaviour of a coordinate
*     axis, several of which may be assembled to represent a
*     coordinate system.

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

*  Attributes Over-Ridden:
*     None.

*  New Attributes Defined:
*     Bottom (double)
*        Lowest legal value for axis.
*     Digits (integer)
*        Specifies how many digits of precision are required by
*        default when a coordinate value for an Axis is formatted
*        (e.g. using the astAxisFormat method). The Digits value acts
*        as a default only and is over-ridden if a Format string is
*        specified explicitly (using the astSetAxisFormat method). The
*        default supplied by the Axis class for the Digits attribute
*        itself is 7.
*     Direction (integer)
*        Specifies how coordinate values for an Axis should be
*        displayed. By default, it has the value one, indicating that
*        they should be shown in the conventional sense
*        (i.e. increasing left to right for an abscissa and bottom to
*        top for an ordinate). If set to zero, this attribute
*        indicates that the direction should be reversed (as would
*        often be done for an astronomical magnitude or a right
*        ascension axis, for example).
*     Format (string)
*        Specifies the format to be used to display coordinate values
*        for an Axis (i.e. to convert them from binary to character
*        form). The interpretation of this string (e.g. by derived
*        classes) is left to the astAxisFormat method, but the Axis
*        class interprets this parameter as a C "printf" format string
*        which should be capable of formatting a single coordinate
*        value stored as a double (e.g.  "%1.7G"). If no Format string
*        is set, the default supplied by the Axis class is based on
*        the value of the Digits attribute.
*     Label (string)
*        Specifies the label to be attached to an Axis when it is
*        represented in (e.g.) a graph. It is intended purely for
*        interpretation by human readers and not by software. The
*        default supplied by the Axis class is the string "Coordinate
*        Axis".
*     Symbol (string)
*        Specifies the symbol to be used to represent coordinate
*        values for an Axis in "short form", such as in algebraic
*        expressions where a full description of the Axis would be
*        inappropriate. Examples include "RA" and "Dec" (for Right
*        Ascension and Declination). The default supplied by the Axis
*        class is the string "x".
*     Top (double)
*        Highest legal value for axis.
*     Unit (string)
*        Describes the units used to represent coordinate values on an
*        Axis.  The default supplied by the Axis class is an empty
*        string "".

*  Methods Over-Ridden:
*     Public:
*        None.

*     Protected:
*        astSetAttrib
*           Set an attribute value for an Axis.

*  New Methods Defined:
*     Public:
*        astAxisFormat
*           Format a coordinate value for an Axis.
*        astAxisNorm
*           Normalise an Axis coordinate value.
*        astAxisUnformat
*           Read a formatted coordinate value for an Axis.

*     Protected:
*        astAxisAbbrev
*           Abbreviate a formatted Axis value by skipping leading fields.
*        astAxisDistance
*           Find the distance between two axis values.
*        astAxisFields
*           Identify the fields within a formatted SkyAxis value.
*        astAxisCentre
*           Find a "nice" central axis value.
*        astAxisGap
*           Find a "nice" gap for tabulating Axis values.
*        astAxisOffset
*           Add an increment onto a supplied axis value.
*        astAxisOverlay
*           Overlay the attributes of a template Axis on to another Axis.
*        astClearAxisDigits
*           Clear the Digits attribute for an Axis.
*        astClearAxisDirection
*           Clear the Direction attribute for an Axis.
*        astClearAxisFormat
*           Clear the Format attribute for an Axis.
*        astClearAxisLabel
*           Clear the Label attribute for an Axis.
*        astClearAxisSymbol
*           Clear the Symbol attribute for an Axis.
*        astClearAxisUnit
*           Clear the Unit attribute for an Axis.
*        astGetAxisDigits
*           Get the value of the Digits attribute for an Axis.
*        astGetAxisDirection
*           Get the value of the Direction attribute for an Axis.
*        astGetAxisFormat
*           Get a pointer to the Format attribute for an Axis.
*        astGetAxisLabel
*           Get a pointer to the Label attribute for an Axis.
*        astGetAxisSymbol
*           Get a pointer to the Symbol attribute for an Axis.
*        astGetAxisUnit
*           Get a pointer to the Unit attribute for an Axis.
*        astSetAxisDigits
*           Set the value of the Digits attribute for an Axis.
*        astSetAxisDirection
*           Set the value of the Direction attribute for an Axis.
*        astSetAxisFormat
*           Set the value of the Format attribute for an Axis.
*        astSetAxisLabel
*           Set the value of the Label attribute for an Axis.
*        astSetAxisSymbol
*           Set the value of the Symbol attribute for an Axis.
*        astSetAxisUnit
*           Set the value of the Unit attribute for an Axis.
*        astTestAxisDigits
*           Test whether a value has been set for the Digits attribute of an
*           Axis.
*        astTestAxisDirection
*           Test whether a value has been set for the Direction attribute of an
*           Axis.
*        astTestAxisFormat
*           Test whether a value has been set for the Format attribute of an
*           Axis.
*        astTestAxisLabel
*           Test whether a value has been set for the Label attribute of an
*           Axis.
*        astTestAxisSymbol
*           Test whether a value has been set for the Symbol attribute of an
*           Axis.
*        astTestAxisUnit
*           Test whether a value has been set for the Unit attribute of an
*           Axis.

*  Other Class Functions:
*     Public:
*        astAxis
*           Create an Axis.
*        astIsAAxis
*           Test class membership.

*     Protected:
*        astCheckAxis
*           Validate class membership.
*        astInitAxis
*           Initialise an Axis.
*        astLoadAxis
*           Load an Axis.

*  Macros:
*     None.

*  Type Definitions:
*     Public:
*        AstAxis
*           Axis object type.

*     Protected:
*        AstAxisVtab
*           Axis 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)
*     DSB: B.S. Berry (Starlink)

*  History:
*     1-MAR-1996 (RFWS):
*        Original version.
*     25-APR-1996 (RFWS):
*        Made all attribute access functions protected.
*     10-SEP-1996 (RFWS):
*        Added I/O facilities.
*     11-SEP-1996 (RFWS):
*        Added astAxisGap (written by DSB).
*     25-FEB-1998 (RFWS):
*        Added astAxisUnformat.
*     29-AUG-2001 (DSB):
*        Added AxisDistance and AxisOffset.
*     10-OCT-2002 (DSB):
*        Added Top and Bottom.
*     8-JAN-2003 (DSB):
*        Added protected astInitAxisVtab method.
*     17-APR-2015 (DSB):
*        Added astAxisCentre.
*-
*/

/* Include files. */
/* ============== */
/* Interface definitions. */
/* ---------------------- */
#include "object.h"              /* Base Object class */
#if defined(astCLASS)            /* Protected */
#include "channel.h"
#endif


/* Macros */
/* ====== */
#if defined(astCLASS)
#define AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN 50
#define AST__AXIS_AXISFORMAT_BUFF_LEN 127
#define AST__AXIS_GETAXISNORMUNIT_BUFF_LEN 127
#define AST__AXIS_GETATTRIB_BUFF_LEN 50
#endif

/* Define a dummy __attribute__ macro for use on non-GNU compilers. */
#ifndef __GNUC__
#  define  __attribute__(x)  /*NOTHING*/
#endif

/* Type Definitions. */
/* ================= */
/* Axis structure. */
/* --------------- */
/* This structure contains all information that is unique to each
   object in the class (e.g. its instance variables). */
typedef struct AstAxis {

/* Attributes inherited from the parent class. */
   AstObject object;             /* Parent class structure */

/* Attributes specific to objects in this class. */
   char *label;                  /* Pointer to label string */
   char *format;                 /* Pointer to format string */
   char *symbol;                 /* Pointer to symbol string */
   char *unit;                   /* Pointer to unit string */
   int digits;                   /* Default digits of precision */
   int direction;                /* Plot in conventional direction? */
   double top;                   /* Highest legal axis value */
   double bottom;                /* Lowest legal axis value */
} AstAxis;

/* 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 AstAxisVtab {

/* 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. */
   const char *(* AxisAbbrev)( AstAxis *, const char *, const char *, const char *, int * );
   const char *(* AxisFormat)( AstAxis *, double, int * );
   const char *(* GetAxisFormat)( AstAxis *, int * );
   const char *(* GetAxisLabel)( AstAxis *, int * );
   const char *(* GetAxisSymbol)( AstAxis *, int * );
   const char *(* GetAxisUnit)( AstAxis *, int * );
   const char *(* GetAxisInternalUnit)( AstAxis *, int * );
   const char *(* GetAxisNormUnit)( AstAxis *, int * );
   double (* AxisCentre)( AstAxis *, double, double, int * );
   double (* AxisGap)( AstAxis *, double, int *, int * );
   double (* AxisDistance)( AstAxis *, double, double, int * );
   double (* AxisOffset)( AstAxis *, double, double, int * );
   int (* AxisIn)( AstAxis *, double, double, double, int, int * );
   int (* AxisFields)( AstAxis *, const char *, const char *, int, char **, int *, double *, int * );
   int (* AxisUnformat)( AstAxis *, const char *, double *, int * );
   int (* GetAxisDigits)( AstAxis *, int * );
   int (* GetAxisDirection)( AstAxis *, int * );
   int (* TestAxisDigits)( AstAxis *, int * );
   int (* TestAxisDirection)( AstAxis *, int * );
   int (* TestAxisFormat)( AstAxis *, int * );
   int (* TestAxisLabel)( AstAxis *, int * );
   int (* TestAxisSymbol)( AstAxis *, int * );
   int (* TestAxisUnit)( AstAxis *, int * );
   int (* TestAxisInternalUnit)( AstAxis *, int * );
   int (* TestAxisNormUnit)( AstAxis *, int * );
   void (* AxisNorm)( AstAxis *, double *, int * );
   void (* AxisNormValues)( AstAxis *, int, int, double *, int * );
   void (* AxisOverlay)( AstAxis *, AstAxis *, int * );
   void (* ClearAxisDigits)( AstAxis *, int * );
   void (* ClearAxisDirection)( AstAxis *, int * );
   void (* ClearAxisFormat)( AstAxis *, int * );
   void (* ClearAxisLabel)( AstAxis *, int * );
   void (* ClearAxisSymbol)( AstAxis *, int * );
   void (* ClearAxisUnit)( AstAxis *, int * );
   void (* SetAxisDigits)( AstAxis *, int, int * );
   void (* SetAxisDirection)( AstAxis *, int, int * );
   void (* SetAxisFormat)( AstAxis *, const char *, int * );
   void (* SetAxisLabel)( AstAxis *, const char *, int * );
   void (* SetAxisSymbol)( AstAxis *, const char *, int * );
   void (* SetAxisUnit)( AstAxis *, const char *, int * );

   double (* GetAxisTop)( AstAxis *, int * );
   int (* TestAxisTop)( AstAxis *, int * );
   void (* ClearAxisTop)( AstAxis *, int * );
   void (* SetAxisTop)( AstAxis *, double, int * );

   double (* GetAxisBottom)( AstAxis *, int * );
   int (* TestAxisBottom)( AstAxis *, int * );
   void (* ClearAxisBottom)( AstAxis *, int * );
   void (* SetAxisBottom)( AstAxis *, double, int * );

} AstAxisVtab;

#if defined(THREAD_SAFE)

/* Define a structure holding all data items that are global within the
   object.c file. */

typedef struct AstAxisGlobals {
   AstAxisVtab Class_Vtab;
   int Class_Init;
   char GetDefaultFormat_Buff[ AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN + 1 ];
   char AxisFormat_Buff[ AST__AXIS_AXISFORMAT_BUFF_LEN + 1 ];
   char GetAxisNormUnit_Buff[ AST__AXIS_GETAXISNORMUNIT_BUFF_LEN + 1 ];
   char GetAttrib_Buff[ AST__AXIS_GETATTRIB_BUFF_LEN + 1 ];
} AstAxisGlobals;

#endif


#endif

/* Function prototypes. */
/* ==================== */
/* Prototypes for standard class functions. */
/* ---------------------------------------- */
astPROTO_CHECK(Axis)             /* Check class membership */
astPROTO_ISA(Axis)               /* Test class membership */

/* Constructor. */
#if defined(astCLASS)            /* Protected. */
AstAxis *astAxis_( const char *, int *, ...);
#else
AstAxis *astAxisId_( const char *, ... )__attribute__((format(printf,1,2)));
#endif

#if defined(astCLASS)            /* Protected */

/* Initialiser. */
AstAxis *astInitAxis_( void *, size_t, int, AstAxisVtab *, const char *, int * );

/* Vtab initialiser. */
void astInitAxisVtab_( AstAxisVtab *, const char *, int * );

/* Loader. */
AstAxis *astLoadAxis_( void *, size_t, AstAxisVtab *, const char *,
                       AstChannel *, int * );

/* Thread-safe initialiser for all global data used by this module. */
#if defined(THREAD_SAFE)
void astInitAxisGlobals_( AstAxisGlobals * );
#endif

#endif

/* Prototypes for member functions. */
/* -------------------------------- */
const char *astAxisFormat_( AstAxis *, double, int * );
int astAxisUnformat_( AstAxis *, const char *, double *, int * );
void astAxisNorm_( AstAxis *, double *, int * );
void astAxisNormValues_( AstAxis *, int, int, double *, int * );

#if defined(astCLASS)            /* Protected */
const char *astAxisAbbrev_( AstAxis *, const char *, const char *, const char *, int * );
const char *astGetAxisFormat_( AstAxis *, int * );
const char *astGetAxisLabel_( AstAxis *, int * );
const char *astGetAxisSymbol_( AstAxis *, int * );
const char *astGetAxisUnit_( AstAxis *, int * );
const char *astGetAxisNormUnit_( AstAxis *, int * );
const char *astGetAxisInternalUnit_( AstAxis *, int * );
double astAxisCentre_( AstAxis *, double, double, int * );
double astAxisGap_( AstAxis *, double, int *, int * );
double astAxisDistance_( AstAxis *, double, double, int * );
double astAxisOffset_( AstAxis *, double, double, int * );
int astGetAxisDigits_( AstAxis *, int * );
int astGetAxisDirection_( AstAxis *, int * );
int astTestAxisDigits_( AstAxis *, int * );
int astTestAxisDirection_( AstAxis *, int * );
int astAxisFields_( AstAxis *, const char *, const char *, int, char **, int *, double *, int * );
int astAxisIn_( AstAxis *, double, double, double, int, int * );
int astTestAxisFormat_( AstAxis *, int * );
int astTestAxisLabel_( AstAxis *, int * );
int astTestAxisSymbol_( AstAxis *, int * );
int astTestAxisUnit_( AstAxis *, int * );
int astTestAxisNormUnit_( AstAxis *, int * );
int astTestAxisInternalUnit_( AstAxis *, int * );
void astAxisOverlay_( AstAxis *, AstAxis *, int * );
void astClearAxisDigits_( AstAxis *, int * );
void astClearAxisDirection_( AstAxis *, int * );
void astClearAxisFormat_( AstAxis *, int * );
void astClearAxisLabel_( AstAxis *, int * );
void astClearAxisSymbol_( AstAxis *, int * );
void astClearAxisUnit_( AstAxis *, int * );
void astSetAxisDigits_( AstAxis *, int, int * );
void astSetAxisDirection_( AstAxis *, int, int * );
void astSetAxisFormat_( AstAxis *, const char *, int * );
void astSetAxisLabel_( AstAxis *, const char *, int * );
void astSetAxisSymbol_( AstAxis *, const char *, int * );
void astSetAxisUnit_( AstAxis *, const char *, int * );

double astGetAxisTop_( AstAxis *, int * );
int astTestAxisTop_( AstAxis *, int * );
void astClearAxisTop_( AstAxis *, int * );
void astSetAxisTop_( AstAxis *, double, int * );

double astGetAxisBottom_( AstAxis *, int * );
int astTestAxisBottom_( AstAxis *, int * );
void astClearAxisBottom_( AstAxis *, int * );
void astSetAxisBottom_( AstAxis *, double, 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 astCheckAxis(this) astINVOKE_CHECK(Axis,this,0)
#define astVerifyAxis(this) astINVOKE_CHECK(Axis,this,1)

/* Test class membership. */
#define astIsAAxis(this) astINVOKE_ISA(Axis,this)

/* Constructor. */
#if defined(astCLASS)            /* Protected. */
#define astAxis astINVOKE(F,astAxis_)
#else
#define astAxis astINVOKE(F,astAxisId_)
#endif

#if defined(astCLASS)            /* Protected. */

/* Initialiser. */
#define astInitAxis(mem,size,init,vtab,name) \
astINVOKE(O,astInitAxis_(mem,size,init,vtab,name,STATUS_PTR))

/* Vtab Initialiser. */
#define astInitAxisVtab(vtab,name) astINVOKE(V,astInitAxisVtab_(vtab,name,STATUS_PTR))
/* Loader. */
#define astLoadAxis(mem,size,vtab,name,channel) \
astINVOKE(O,astLoadAxis_(mem,size,vtab,name,astCheckChannel(channel),STATUS_PTR))
#endif

/* Interfaces to public member functions. */
/* -------------------------------------- */
/* Here we make use of astCheckAxis to validate Axis pointers before
   use. This provides a contextual error report if a pointer to the
   wrong sort of object is supplied. */
#define astAxisFormat(this,value) \
astINVOKE(V,astAxisFormat_(astCheckAxis(this),value,STATUS_PTR))
#define astAxisNorm(this,value) \
astINVOKE(V,astAxisNorm_(astCheckAxis(this),value,STATUS_PTR))
#define astAxisNormValues(this,oper,nval,values) \
astINVOKE(V,astAxisNormValues_(astCheckAxis(this),oper,nval,values,STATUS_PTR))
#define astAxisUnformat(this,string,value) \
astINVOKE(V,astAxisUnformat_(astCheckAxis(this),string,value,STATUS_PTR))

#if defined(astCLASS)            /* Protected */
#define astAxisAbbrev(this,fmt,str1,str2) \
astINVOKE(V,astAxisAbbrev_(astCheckAxis(this),fmt,str1,str2,STATUS_PTR))
#define astAxisCentre(this,value,gap) \
astINVOKE(V,astAxisCentre_(astCheckAxis(this),value,gap,STATUS_PTR))
#define astAxisGap(this,gap,ntick) \
astINVOKE(V,astAxisGap_(astCheckAxis(this),gap,ntick,STATUS_PTR))
#define astAxisFields(this,fmt,str,maxfld,fields,nc,val) \
astINVOKE(V,astAxisFields_(astCheckAxis(this),fmt,str,maxfld,fields,nc,val,STATUS_PTR))
#define astAxisIn(this,lo,hi,val,closed) \
astINVOKE(V,astAxisIn_(astCheckAxis(this),lo,hi,val,closed,STATUS_PTR))
#define astAxisDistance(this,v1,v2) \
astINVOKE(V,astAxisDistance_(astCheckAxis(this),v1,v2,STATUS_PTR))
#define astAxisOffset(this,v1,dist) \
astINVOKE(V,astAxisOffset_(astCheckAxis(this),v1,dist,STATUS_PTR))
#define astAxisOverlay(template,result) \
astINVOKE(V,astAxisOverlay_(astCheckAxis(template),astCheckAxis(result),STATUS_PTR))
#define astClearAxisDigits(this) \
astINVOKE(V,astClearAxisDigits_(astCheckAxis(this),STATUS_PTR))
#define astClearAxisDirection(this) \
astINVOKE(V,astClearAxisDirection_(astCheckAxis(this),STATUS_PTR))
#define astClearAxisFormat(this) \
astINVOKE(V,astClearAxisFormat_(astCheckAxis(this),STATUS_PTR))
#define astClearAxisLabel(this) \
astINVOKE(V,astClearAxisLabel_(astCheckAxis(this),STATUS_PTR))
#define astClearAxisSymbol(this) \
astINVOKE(V,astClearAxisSymbol_(astCheckAxis(this),STATUS_PTR))
#define astClearAxisUnit(this) \
astINVOKE(V,astClearAxisUnit_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisDigits(this) \
astINVOKE(V,astGetAxisDigits_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisDirection(this) \
astINVOKE(V,astGetAxisDirection_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisFormat(this) \
astINVOKE(V,astGetAxisFormat_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisLabel(this) \
astINVOKE(V,astGetAxisLabel_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisSymbol(this) \
astINVOKE(V,astGetAxisSymbol_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisUnit(this) \
astINVOKE(V,astGetAxisUnit_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisNormUnit(this) \
astINVOKE(V,astGetAxisInternalUnit_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisInternalUnit(this) \
astINVOKE(V,astGetAxisInternalUnit_(astCheckAxis(this),STATUS_PTR))
#define astSetAxisDigits(this,digits) \
astINVOKE(V,astSetAxisDigits_(astCheckAxis(this),digits,STATUS_PTR))
#define astSetAxisDirection(this,direction) \
astINVOKE(V,astSetAxisDirection_(astCheckAxis(this),direction,STATUS_PTR))
#define astSetAxisFormat(this,format) \
astINVOKE(V,astSetAxisFormat_(astCheckAxis(this),format,STATUS_PTR))
#define astSetAxisLabel(this,label) \
astINVOKE(V,astSetAxisLabel_(astCheckAxis(this),label,STATUS_PTR))
#define astSetAxisSymbol(this,symbol) \
astINVOKE(V,astSetAxisSymbol_(astCheckAxis(this),symbol,STATUS_PTR))
#define astSetAxisUnit(this,unit) \
astINVOKE(V,astSetAxisUnit_(astCheckAxis(this),unit,STATUS_PTR))
#define astTestAxisDigits(this) \
astINVOKE(V,astTestAxisDigits_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisDirection(this) \
astINVOKE(V,astTestAxisDirection_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisFormat(this) \
astINVOKE(V,astTestAxisFormat_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisLabel(this) \
astINVOKE(V,astTestAxisLabel_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisSymbol(this) \
astINVOKE(V,astTestAxisSymbol_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisUnit(this) \
astINVOKE(V,astTestAxisUnit_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisNormUnit(this) \
astINVOKE(V,astTestAxisNormUnit_(astCheckAxis(this),STATUS_PTR))
#define astTestAxisInternalUnit(this) \
astINVOKE(V,astTestAxisInternalUnit_(astCheckAxis(this),STATUS_PTR))

#define astClearAxisTop(this) \
astINVOKE(V,astClearAxisTop_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisTop(this) \
astINVOKE(V,astGetAxisTop_(astCheckAxis(this),STATUS_PTR))
#define astSetAxisTop(this,top) \
astINVOKE(V,astSetAxisTop_(astCheckAxis(this),top,STATUS_PTR))
#define astTestAxisTop(this) \
astINVOKE(V,astTestAxisTop_(astCheckAxis(this),STATUS_PTR))

#define astClearAxisBottom(this) \
astINVOKE(V,astClearAxisBottom_(astCheckAxis(this),STATUS_PTR))
#define astGetAxisBottom(this) \
astINVOKE(V,astGetAxisBottom_(astCheckAxis(this),STATUS_PTR))
#define astSetAxisBottom(this,bottom) \
astINVOKE(V,astSetAxisBottom_(astCheckAxis(this),bottom,STATUS_PTR))
#define astTestAxisBottom(this) \
astINVOKE(V,astTestAxisBottom_(astCheckAxis(this),STATUS_PTR))

#endif
#endif