• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

plplotcmodulePYTHON_wrap.c

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.40
00004  * 
00005  * This file is not intended to be easily readable and contains a number of 
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG 
00008  * interface file instead. 
00009  * ----------------------------------------------------------------------------- */
00010 
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00013 
00014 /* -----------------------------------------------------------------------------
00015  *  This section contains generic SWIG labels for method/variable
00016  *  declarations/attributes, and other compiler dependent labels.
00017  * ----------------------------------------------------------------------------- */
00018 
00019 /* template workaround for compilers that cannot correctly implement the C++ standard */
00020 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00021 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00022 #  define SWIGTEMPLATEDISAMBIGUATOR template
00023 # elif defined(__HP_aCC)
00024 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
00025 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
00026 #  define SWIGTEMPLATEDISAMBIGUATOR template
00027 # else
00028 #  define SWIGTEMPLATEDISAMBIGUATOR
00029 # endif
00030 #endif
00031 
00032 /* inline attribute */
00033 #ifndef SWIGINLINE
00034 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00035 #   define SWIGINLINE inline
00036 # else
00037 #   define SWIGINLINE
00038 # endif
00039 #endif
00040 
00041 /* attribute recognised by some compilers to avoid 'unused' warnings */
00042 #ifndef SWIGUNUSED
00043 # if defined(__GNUC__)
00044 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00045 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00046 #   else
00047 #     define SWIGUNUSED
00048 #   endif
00049 # elif defined(__ICC)
00050 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00051 # else
00052 #   define SWIGUNUSED 
00053 # endif
00054 #endif
00055 
00056 #ifndef SWIG_MSC_UNSUPPRESS_4505
00057 # if defined(_MSC_VER)
00058 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
00059 # endif 
00060 #endif
00061 
00062 #ifndef SWIGUNUSEDPARM
00063 # ifdef __cplusplus
00064 #   define SWIGUNUSEDPARM(p)
00065 # else
00066 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00067 # endif
00068 #endif
00069 
00070 /* internal SWIG method */
00071 #ifndef SWIGINTERN
00072 # define SWIGINTERN static SWIGUNUSED
00073 #endif
00074 
00075 /* internal inline SWIG method */
00076 #ifndef SWIGINTERNINLINE
00077 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00078 #endif
00079 
00080 /* exporting methods */
00081 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00082 #  ifndef GCC_HASCLASSVISIBILITY
00083 #    define GCC_HASCLASSVISIBILITY
00084 #  endif
00085 #endif
00086 
00087 #ifndef SWIGEXPORT
00088 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00089 #   if defined(STATIC_LINKED)
00090 #     define SWIGEXPORT
00091 #   else
00092 #     define SWIGEXPORT __declspec(dllexport)
00093 #   endif
00094 # else
00095 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00096 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00097 #   else
00098 #     define SWIGEXPORT
00099 #   endif
00100 # endif
00101 #endif
00102 
00103 /* calling conventions for Windows */
00104 #ifndef SWIGSTDCALL
00105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00106 #   define SWIGSTDCALL __stdcall
00107 # else
00108 #   define SWIGSTDCALL
00109 # endif 
00110 #endif
00111 
00112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00114 # define _CRT_SECURE_NO_DEPRECATE
00115 #endif
00116 
00117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
00118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00119 # define _SCL_SECURE_NO_DEPRECATE
00120 #endif
00121 
00122 
00123 
00124 /* Python.h has to appear first */
00125 #include <Python.h>
00126 
00127 /* -----------------------------------------------------------------------------
00128  * swigrun.swg
00129  *
00130  * This file contains generic C API SWIG runtime support for pointer
00131  * type checking.
00132  * ----------------------------------------------------------------------------- */
00133 
00134 /* This should only be incremented when either the layout of swig_type_info changes,
00135    or for whatever reason, the runtime changes incompatibly */
00136 #define SWIG_RUNTIME_VERSION "4"
00137 
00138 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00139 #ifdef SWIG_TYPE_TABLE
00140 # define SWIG_QUOTE_STRING(x) #x
00141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00143 #else
00144 # define SWIG_TYPE_TABLE_NAME
00145 #endif
00146 
00147 /*
00148   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00149   creating a static or dynamic library from the SWIG runtime code.
00150   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
00151   
00152   But only do this if strictly necessary, ie, if you have problems
00153   with your compiler or suchlike.
00154 */
00155 
00156 #ifndef SWIGRUNTIME
00157 # define SWIGRUNTIME SWIGINTERN
00158 #endif
00159 
00160 #ifndef SWIGRUNTIMEINLINE
00161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00162 #endif
00163 
00164 /*  Generic buffer size */
00165 #ifndef SWIG_BUFFER_SIZE
00166 # define SWIG_BUFFER_SIZE 1024
00167 #endif
00168 
00169 /* Flags for pointer conversions */
00170 #define SWIG_POINTER_DISOWN        0x1
00171 #define SWIG_CAST_NEW_MEMORY       0x2
00172 
00173 /* Flags for new pointer objects */
00174 #define SWIG_POINTER_OWN           0x1
00175 
00176 
00177 /* 
00178    Flags/methods for returning states.
00179    
00180    The SWIG conversion methods, as ConvertPtr, return and integer 
00181    that tells if the conversion was successful or not. And if not,
00182    an error code can be returned (see swigerrors.swg for the codes).
00183    
00184    Use the following macros/flags to set or process the returning
00185    states.
00186    
00187    In old versions of SWIG, code such as the following was usually written:
00188 
00189      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00190        // success code
00191      } else {
00192        //fail code
00193      }
00194 
00195    Now you can be more explicit:
00196 
00197     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00198     if (SWIG_IsOK(res)) {
00199       // success code
00200     } else {
00201       // fail code
00202     }
00203 
00204    which is the same really, but now you can also do
00205 
00206     Type *ptr;
00207     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00208     if (SWIG_IsOK(res)) {
00209       // success code
00210       if (SWIG_IsNewObj(res) {
00211         ...
00212         delete *ptr;
00213       } else {
00214         ...
00215       }
00216     } else {
00217       // fail code
00218     }
00219     
00220    I.e., now SWIG_ConvertPtr can return new objects and you can
00221    identify the case and take care of the deallocation. Of course that
00222    also requires SWIG_ConvertPtr to return new result values, such as
00223 
00224       int SWIG_ConvertPtr(obj, ptr,...) {         
00225         if (<obj is ok>) {                             
00226           if (<need new object>) {                     
00227             *ptr = <ptr to new allocated object>; 
00228             return SWIG_NEWOBJ;                
00229           } else {                                     
00230             *ptr = <ptr to old object>;        
00231             return SWIG_OLDOBJ;                
00232           }                                    
00233         } else {                                       
00234           return SWIG_BADOBJ;                  
00235         }                                              
00236       }
00237 
00238    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00239    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00240    SWIG errors code.
00241 
00242    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00243    allows to return the 'cast rank', for example, if you have this
00244 
00245        int food(double)
00246        int fooi(int);
00247 
00248    and you call
00249  
00250       food(1)   // cast rank '1'  (1 -> 1.0)
00251       fooi(1)   // cast rank '0'
00252 
00253    just use the SWIG_AddCast()/SWIG_CheckState()
00254 */
00255 
00256 #define SWIG_OK                    (0) 
00257 #define SWIG_ERROR                 (-1)
00258 #define SWIG_IsOK(r)               (r >= 0)
00259 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
00260 
00261 /* The CastRankLimit says how many bits are used for the cast rank */
00262 #define SWIG_CASTRANKLIMIT         (1 << 8)
00263 /* The NewMask denotes the object was created (using new/malloc) */
00264 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00265 /* The TmpMask is for in/out typemaps that use temporal objects */
00266 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00267 /* Simple returning values */
00268 #define SWIG_BADOBJ                (SWIG_ERROR)
00269 #define SWIG_OLDOBJ                (SWIG_OK)
00270 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
00271 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
00272 /* Check, add and del mask methods */
00273 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00274 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00275 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00276 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00277 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00278 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00279 
00280 /* Cast-Rank Mode */
00281 #if defined(SWIG_CASTRANK_MODE)
00282 #  ifndef SWIG_TypeRank
00283 #    define SWIG_TypeRank             unsigned long
00284 #  endif
00285 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
00286 #    define SWIG_MAXCASTRANK          (2)
00287 #  endif
00288 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
00289 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
00290 SWIGINTERNINLINE int SWIG_AddCast(int r) { 
00291   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00292 }
00293 SWIGINTERNINLINE int SWIG_CheckState(int r) { 
00294   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
00295 }
00296 #else /* no cast-rank mode */
00297 #  define SWIG_AddCast
00298 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00299 #endif
00300 
00301 
00302 #include <string.h>
00303 
00304 #ifdef __cplusplus
00305 extern "C" {
00306 #endif
00307 
00308 typedef void *(*swig_converter_func)(void *, int *);
00309 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00310 
00311 /* Structure to store information on one type */
00312 typedef struct swig_type_info {
00313   const char             *name;                 /* mangled name of this type */
00314   const char             *str;                  /* human readable name of this type */
00315   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
00316   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
00317   void                   *clientdata;           /* language specific type data */
00318   int                    owndata;               /* flag if the structure owns the clientdata */
00319 } swig_type_info;
00320 
00321 /* Structure to store a type and conversion function used for casting */
00322 typedef struct swig_cast_info {
00323   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
00324   swig_converter_func     converter;            /* function to cast the void pointers */
00325   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
00326   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
00327 } swig_cast_info;
00328 
00329 /* Structure used to store module information
00330  * Each module generates one structure like this, and the runtime collects
00331  * all of these structures and stores them in a circularly linked list.*/
00332 typedef struct swig_module_info {
00333   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
00334   size_t                 size;                  /* Number of types in this module */
00335   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
00336   swig_type_info         **type_initial;        /* Array of initially generated type structures */
00337   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
00338   void                    *clientdata;          /* Language specific module data */
00339 } swig_module_info;
00340 
00341 /* 
00342   Compare two type names skipping the space characters, therefore
00343   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00344 
00345   Return 0 when the two name types are equivalent, as in
00346   strncmp, but skipping ' '.
00347 */
00348 SWIGRUNTIME int
00349 SWIG_TypeNameComp(const char *f1, const char *l1,
00350                   const char *f2, const char *l2) {
00351   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00352     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00353     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00354     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00355   }
00356   return (int)((l1 - f1) - (l2 - f2));
00357 }
00358 
00359 /*
00360   Check type equivalence in a name list like <name1>|<name2>|...
00361   Return 0 if not equal, 1 if equal
00362 */
00363 SWIGRUNTIME int
00364 SWIG_TypeEquiv(const char *nb, const char *tb) {
00365   int equiv = 0;
00366   const char* te = tb + strlen(tb);
00367   const char* ne = nb;
00368   while (!equiv && *ne) {
00369     for (nb = ne; *ne; ++ne) {
00370       if (*ne == '|') break;
00371     }
00372     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00373     if (*ne) ++ne;
00374   }
00375   return equiv;
00376 }
00377 
00378 /*
00379   Check type equivalence in a name list like <name1>|<name2>|...
00380   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
00381 */
00382 SWIGRUNTIME int
00383 SWIG_TypeCompare(const char *nb, const char *tb) {
00384   int equiv = 0;
00385   const char* te = tb + strlen(tb);
00386   const char* ne = nb;
00387   while (!equiv && *ne) {
00388     for (nb = ne; *ne; ++ne) {
00389       if (*ne == '|') break;
00390     }
00391     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00392     if (*ne) ++ne;
00393   }
00394   return equiv;
00395 }
00396 
00397 
00398 /*
00399   Check the typename
00400 */
00401 SWIGRUNTIME swig_cast_info *
00402 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00403   if (ty) {
00404     swig_cast_info *iter = ty->cast;
00405     while (iter) {
00406       if (strcmp(iter->type->name, c) == 0) {
00407         if (iter == ty->cast)
00408           return iter;
00409         /* Move iter to the top of the linked list */
00410         iter->prev->next = iter->next;
00411         if (iter->next)
00412           iter->next->prev = iter->prev;
00413         iter->next = ty->cast;
00414         iter->prev = 0;
00415         if (ty->cast) ty->cast->prev = iter;
00416         ty->cast = iter;
00417         return iter;
00418       }
00419       iter = iter->next;
00420     }
00421   }
00422   return 0;
00423 }
00424 
00425 /* 
00426   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
00427 */
00428 SWIGRUNTIME swig_cast_info *
00429 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
00430   if (ty) {
00431     swig_cast_info *iter = ty->cast;
00432     while (iter) {
00433       if (iter->type == from) {
00434         if (iter == ty->cast)
00435           return iter;
00436         /* Move iter to the top of the linked list */
00437         iter->prev->next = iter->next;
00438         if (iter->next)
00439           iter->next->prev = iter->prev;
00440         iter->next = ty->cast;
00441         iter->prev = 0;
00442         if (ty->cast) ty->cast->prev = iter;
00443         ty->cast = iter;
00444         return iter;
00445       }
00446       iter = iter->next;
00447     }
00448   }
00449   return 0;
00450 }
00451 
00452 /*
00453   Cast a pointer up an inheritance hierarchy
00454 */
00455 SWIGRUNTIMEINLINE void *
00456 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00457   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00458 }
00459 
00460 /* 
00461    Dynamic pointer casting. Down an inheritance hierarchy
00462 */
00463 SWIGRUNTIME swig_type_info *
00464 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00465   swig_type_info *lastty = ty;
00466   if (!ty || !ty->dcast) return ty;
00467   while (ty && (ty->dcast)) {
00468     ty = (*ty->dcast)(ptr);
00469     if (ty) lastty = ty;
00470   }
00471   return lastty;
00472 }
00473 
00474 /*
00475   Return the name associated with this type
00476 */
00477 SWIGRUNTIMEINLINE const char *
00478 SWIG_TypeName(const swig_type_info *ty) {
00479   return ty->name;
00480 }
00481 
00482 /*
00483   Return the pretty name associated with this type,
00484   that is an unmangled type name in a form presentable to the user.
00485 */
00486 SWIGRUNTIME const char *
00487 SWIG_TypePrettyName(const swig_type_info *type) {
00488   /* The "str" field contains the equivalent pretty names of the
00489      type, separated by vertical-bar characters.  We choose
00490      to print the last name, as it is often (?) the most
00491      specific. */
00492   if (!type) return NULL;
00493   if (type->str != NULL) {
00494     const char *last_name = type->str;
00495     const char *s;
00496     for (s = type->str; *s; s++)
00497       if (*s == '|') last_name = s+1;
00498     return last_name;
00499   }
00500   else
00501     return type->name;
00502 }
00503 
00504 /* 
00505    Set the clientdata field for a type
00506 */
00507 SWIGRUNTIME void
00508 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00509   swig_cast_info *cast = ti->cast;
00510   /* if (ti->clientdata == clientdata) return; */
00511   ti->clientdata = clientdata;
00512   
00513   while (cast) {
00514     if (!cast->converter) {
00515       swig_type_info *tc = cast->type;
00516       if (!tc->clientdata) {
00517         SWIG_TypeClientData(tc, clientdata);
00518       }
00519     }    
00520     cast = cast->next;
00521   }
00522 }
00523 SWIGRUNTIME void
00524 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00525   SWIG_TypeClientData(ti, clientdata);
00526   ti->owndata = 1;
00527 }
00528   
00529 /*
00530   Search for a swig_type_info structure only by mangled name
00531   Search is a O(log #types)
00532   
00533   We start searching at module start, and finish searching when start == end.  
00534   Note: if start == end at the beginning of the function, we go all the way around
00535   the circular list.
00536 */
00537 SWIGRUNTIME swig_type_info *
00538 SWIG_MangledTypeQueryModule(swig_module_info *start, 
00539                             swig_module_info *end, 
00540                             const char *name) {
00541   swig_module_info *iter = start;
00542   do {
00543     if (iter->size) {
00544       register size_t l = 0;
00545       register size_t r = iter->size - 1;
00546       do {
00547         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
00548         register size_t i = (l + r) >> 1; 
00549         const char *iname = iter->types[i]->name;
00550         if (iname) {
00551           register int compare = strcmp(name, iname);
00552           if (compare == 0) {       
00553             return iter->types[i];
00554           } else if (compare < 0) {
00555             if (i) {
00556               r = i - 1;
00557             } else {
00558               break;
00559             }
00560           } else if (compare > 0) {
00561             l = i + 1;
00562           }
00563         } else {
00564           break; /* should never happen */
00565         }
00566       } while (l <= r);
00567     }
00568     iter = iter->next;
00569   } while (iter != end);
00570   return 0;
00571 }
00572 
00573 /*
00574   Search for a swig_type_info structure for either a mangled name or a human readable name.
00575   It first searches the mangled names of the types, which is a O(log #types)
00576   If a type is not found it then searches the human readable names, which is O(#types).
00577   
00578   We start searching at module start, and finish searching when start == end.  
00579   Note: if start == end at the beginning of the function, we go all the way around
00580   the circular list.
00581 */
00582 SWIGRUNTIME swig_type_info *
00583 SWIG_TypeQueryModule(swig_module_info *start, 
00584                      swig_module_info *end, 
00585                      const char *name) {
00586   /* STEP 1: Search the name field using binary search */
00587   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00588   if (ret) {
00589     return ret;
00590   } else {
00591     /* STEP 2: If the type hasn't been found, do a complete search
00592        of the str field (the human readable name) */
00593     swig_module_info *iter = start;
00594     do {
00595       register size_t i = 0;
00596       for (; i < iter->size; ++i) {
00597         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00598           return iter->types[i];
00599       }
00600       iter = iter->next;
00601     } while (iter != end);
00602   }
00603   
00604   /* neither found a match */
00605   return 0;
00606 }
00607 
00608 /* 
00609    Pack binary data into a string
00610 */
00611 SWIGRUNTIME char *
00612 SWIG_PackData(char *c, void *ptr, size_t sz) {
00613   static const char hex[17] = "0123456789abcdef";
00614   register const unsigned char *u = (unsigned char *) ptr;
00615   register const unsigned char *eu =  u + sz;
00616   for (; u != eu; ++u) {
00617     register unsigned char uu = *u;
00618     *(c++) = hex[(uu & 0xf0) >> 4];
00619     *(c++) = hex[uu & 0xf];
00620   }
00621   return c;
00622 }
00623 
00624 /* 
00625    Unpack binary data from a string
00626 */
00627 SWIGRUNTIME const char *
00628 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00629   register unsigned char *u = (unsigned char *) ptr;
00630   register const unsigned char *eu = u + sz;
00631   for (; u != eu; ++u) {
00632     register char d = *(c++);
00633     register unsigned char uu;
00634     if ((d >= '0') && (d <= '9'))
00635       uu = ((d - '0') << 4);
00636     else if ((d >= 'a') && (d <= 'f'))
00637       uu = ((d - ('a'-10)) << 4);
00638     else 
00639       return (char *) 0;
00640     d = *(c++);
00641     if ((d >= '0') && (d <= '9'))
00642       uu |= (d - '0');
00643     else if ((d >= 'a') && (d <= 'f'))
00644       uu |= (d - ('a'-10));
00645     else 
00646       return (char *) 0;
00647     *u = uu;
00648   }
00649   return c;
00650 }
00651 
00652 /* 
00653    Pack 'void *' into a string buffer.
00654 */
00655 SWIGRUNTIME char *
00656 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00657   char *r = buff;
00658   if ((2*sizeof(void *) + 2) > bsz) return 0;
00659   *(r++) = '_';
00660   r = SWIG_PackData(r,&ptr,sizeof(void *));
00661   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00662   strcpy(r,name);
00663   return buff;
00664 }
00665 
00666 SWIGRUNTIME const char *
00667 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00668   if (*c != '_') {
00669     if (strcmp(c,"NULL") == 0) {
00670       *ptr = (void *) 0;
00671       return name;
00672     } else {
00673       return 0;
00674     }
00675   }
00676   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00677 }
00678 
00679 SWIGRUNTIME char *
00680 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00681   char *r = buff;
00682   size_t lname = (name ? strlen(name) : 0);
00683   if ((2*sz + 2 + lname) > bsz) return 0;
00684   *(r++) = '_';
00685   r = SWIG_PackData(r,ptr,sz);
00686   if (lname) {
00687     strncpy(r,name,lname+1);
00688   } else {
00689     *r = 0;
00690   }
00691   return buff;
00692 }
00693 
00694 SWIGRUNTIME const char *
00695 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00696   if (*c != '_') {
00697     if (strcmp(c,"NULL") == 0) {
00698       memset(ptr,0,sz);
00699       return name;
00700     } else {
00701       return 0;
00702     }
00703   }
00704   return SWIG_UnpackData(++c,ptr,sz);
00705 }
00706 
00707 #ifdef __cplusplus
00708 }
00709 #endif
00710 
00711 /*  Errors in SWIG */
00712 #define  SWIG_UnknownError         -1 
00713 #define  SWIG_IOError              -2 
00714 #define  SWIG_RuntimeError         -3 
00715 #define  SWIG_IndexError           -4 
00716 #define  SWIG_TypeError            -5 
00717 #define  SWIG_DivisionByZero       -6 
00718 #define  SWIG_OverflowError        -7 
00719 #define  SWIG_SyntaxError          -8 
00720 #define  SWIG_ValueError           -9 
00721 #define  SWIG_SystemError          -10
00722 #define  SWIG_AttributeError       -11
00723 #define  SWIG_MemoryError          -12 
00724 #define  SWIG_NullReferenceError   -13
00725 
00726 
00727 
00728 /* Compatibility macros for Python 3 */
00729 #if PY_VERSION_HEX >= 0x03000000
00730 
00731 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
00732 #define PyInt_Check(x) PyLong_Check(x)
00733 #define PyInt_AsLong(x) PyLong_AsLong(x)
00734 #define PyInt_FromLong(x) PyLong_FromLong(x)
00735 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
00736 
00737 #endif
00738 
00739 #ifndef Py_TYPE
00740 #  define Py_TYPE(op) ((op)->ob_type)
00741 #endif
00742 
00743 /* SWIG APIs for compatibility of both Python 2 & 3 */
00744 
00745 #if PY_VERSION_HEX >= 0x03000000
00746 #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
00747 #else
00748 #  define SWIG_Python_str_FromFormat PyString_FromFormat
00749 #endif
00750 
00751 
00752 /* Warning: This function will allocate a new string in Python 3,
00753  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
00754  */
00755 SWIGINTERN char*
00756 SWIG_Python_str_AsChar(PyObject *str)
00757 {
00758 #if PY_VERSION_HEX >= 0x03000000
00759   char *cstr;
00760   char *newstr;
00761   Py_ssize_t len;
00762   str = PyUnicode_AsUTF8String(str);
00763   PyBytes_AsStringAndSize(str, &cstr, &len);
00764   newstr = (char *) malloc(len+1);
00765   memcpy(newstr, cstr, len+1);
00766   Py_XDECREF(str);
00767   return newstr;
00768 #else
00769   return PyString_AsString(str);
00770 #endif
00771 }
00772 
00773 #if PY_VERSION_HEX >= 0x03000000
00774 #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
00775 #else
00776 #  define SWIG_Python_str_DelForPy3(x) 
00777 #endif
00778 
00779 
00780 SWIGINTERN PyObject*
00781 SWIG_Python_str_FromChar(const char *c)
00782 {
00783 #if PY_VERSION_HEX >= 0x03000000
00784   return PyUnicode_FromString(c); 
00785 #else
00786   return PyString_FromString(c);
00787 #endif
00788 }
00789 
00790 /* Add PyOS_snprintf for old Pythons */
00791 #if PY_VERSION_HEX < 0x02020000
00792 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00793 #  define PyOS_snprintf _snprintf
00794 # else
00795 #  define PyOS_snprintf snprintf
00796 # endif
00797 #endif
00798 
00799 /* A crude PyString_FromFormat implementation for old Pythons */
00800 #if PY_VERSION_HEX < 0x02020000
00801 
00802 #ifndef SWIG_PYBUFFER_SIZE
00803 # define SWIG_PYBUFFER_SIZE 1024
00804 #endif
00805 
00806 static PyObject *
00807 PyString_FromFormat(const char *fmt, ...) {
00808   va_list ap;
00809   char buf[SWIG_PYBUFFER_SIZE * 2];
00810   int res;
00811   va_start(ap, fmt);
00812   res = vsnprintf(buf, sizeof(buf), fmt, ap);
00813   va_end(ap);
00814   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00815 }
00816 #endif
00817 
00818 /* Add PyObject_Del for old Pythons */
00819 #if PY_VERSION_HEX < 0x01060000
00820 # define PyObject_Del(op) PyMem_DEL((op))
00821 #endif
00822 #ifndef PyObject_DEL
00823 # define PyObject_DEL PyObject_Del
00824 #endif
00825 
00826 /* A crude PyExc_StopIteration exception for old Pythons */
00827 #if PY_VERSION_HEX < 0x02020000
00828 # ifndef PyExc_StopIteration
00829 #  define PyExc_StopIteration PyExc_RuntimeError
00830 # endif
00831 # ifndef PyObject_GenericGetAttr
00832 #  define PyObject_GenericGetAttr 0
00833 # endif
00834 #endif
00835 
00836 /* Py_NotImplemented is defined in 2.1 and up. */
00837 #if PY_VERSION_HEX < 0x02010000
00838 # ifndef Py_NotImplemented
00839 #  define Py_NotImplemented PyExc_RuntimeError
00840 # endif
00841 #endif
00842 
00843 /* A crude PyString_AsStringAndSize implementation for old Pythons */
00844 #if PY_VERSION_HEX < 0x02010000
00845 # ifndef PyString_AsStringAndSize
00846 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00847 # endif
00848 #endif
00849 
00850 /* PySequence_Size for old Pythons */
00851 #if PY_VERSION_HEX < 0x02000000
00852 # ifndef PySequence_Size
00853 #  define PySequence_Size PySequence_Length
00854 # endif
00855 #endif
00856 
00857 /* PyBool_FromLong for old Pythons */
00858 #if PY_VERSION_HEX < 0x02030000
00859 static
00860 PyObject *PyBool_FromLong(long ok)
00861 {
00862   PyObject *result = ok ? Py_True : Py_False;
00863   Py_INCREF(result);
00864   return result;
00865 }
00866 #endif
00867 
00868 /* Py_ssize_t for old Pythons */
00869 /* This code is as recommended by: */
00870 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
00871 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00872 typedef int Py_ssize_t;
00873 # define PY_SSIZE_T_MAX INT_MAX
00874 # define PY_SSIZE_T_MIN INT_MIN
00875 #endif
00876 
00877 /* -----------------------------------------------------------------------------
00878  * error manipulation
00879  * ----------------------------------------------------------------------------- */
00880 
00881 SWIGRUNTIME PyObject*
00882 SWIG_Python_ErrorType(int code) {
00883   PyObject* type = 0;
00884   switch(code) {
00885   case SWIG_MemoryError:
00886     type = PyExc_MemoryError;
00887     break;
00888   case SWIG_IOError:
00889     type = PyExc_IOError;
00890     break;
00891   case SWIG_RuntimeError:
00892     type = PyExc_RuntimeError;
00893     break;
00894   case SWIG_IndexError:
00895     type = PyExc_IndexError;
00896     break;
00897   case SWIG_TypeError:
00898     type = PyExc_TypeError;
00899     break;
00900   case SWIG_DivisionByZero:
00901     type = PyExc_ZeroDivisionError;
00902     break;
00903   case SWIG_OverflowError:
00904     type = PyExc_OverflowError;
00905     break;
00906   case SWIG_SyntaxError:
00907     type = PyExc_SyntaxError;
00908     break;
00909   case SWIG_ValueError:
00910     type = PyExc_ValueError;
00911     break;
00912   case SWIG_SystemError:
00913     type = PyExc_SystemError;
00914     break;
00915   case SWIG_AttributeError:
00916     type = PyExc_AttributeError;
00917     break;
00918   default:
00919     type = PyExc_RuntimeError;
00920   }
00921   return type;
00922 }
00923 
00924 
00925 SWIGRUNTIME void
00926 SWIG_Python_AddErrorMsg(const char* mesg)
00927 {
00928   PyObject *type = 0;
00929   PyObject *value = 0;
00930   PyObject *traceback = 0;
00931 
00932   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00933   if (value) {
00934     char *tmp;
00935     PyObject *old_str = PyObject_Str(value);
00936     PyErr_Clear();
00937     Py_XINCREF(type);
00938 
00939     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
00940     SWIG_Python_str_DelForPy3(tmp);
00941     Py_DECREF(old_str);
00942     Py_DECREF(value);
00943   } else {
00944     PyErr_SetString(PyExc_RuntimeError, mesg);
00945   }
00946 }
00947 
00948 #if defined(SWIG_PYTHON_NO_THREADS)
00949 #  if defined(SWIG_PYTHON_THREADS)
00950 #    undef SWIG_PYTHON_THREADS
00951 #  endif
00952 #endif
00953 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
00954 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00955 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
00956 #      define SWIG_PYTHON_USE_GIL
00957 #    endif
00958 #  endif
00959 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
00960 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
00961 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
00962 #    endif
00963 #    ifdef __cplusplus /* C++ code */
00964        class SWIG_Python_Thread_Block {
00965          bool status;
00966          PyGILState_STATE state;
00967        public:
00968          void end() { if (status) { PyGILState_Release(state); status = false;} }
00969          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
00970          ~SWIG_Python_Thread_Block() { end(); }
00971        };
00972        class SWIG_Python_Thread_Allow {
00973          bool status;
00974          PyThreadState *save;
00975        public:
00976          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
00977          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
00978          ~SWIG_Python_Thread_Allow() { end(); }
00979        };
00980 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
00981 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
00982 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
00983 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
00984 #    else /* C code */
00985 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
00986 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
00987 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
00988 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
00989 #    endif
00990 #  else /* Old thread way, not implemented, user must provide it */
00991 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
00992 #      define SWIG_PYTHON_INITIALIZE_THREADS
00993 #    endif
00994 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
00995 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00996 #    endif
00997 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
00998 #      define SWIG_PYTHON_THREAD_END_BLOCK
00999 #    endif
01000 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
01001 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01002 #    endif
01003 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
01004 #      define SWIG_PYTHON_THREAD_END_ALLOW
01005 #    endif
01006 #  endif
01007 #else /* No thread support */
01008 #  define SWIG_PYTHON_INITIALIZE_THREADS
01009 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01010 #  define SWIG_PYTHON_THREAD_END_BLOCK
01011 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01012 #  define SWIG_PYTHON_THREAD_END_ALLOW
01013 #endif
01014 
01015 /* -----------------------------------------------------------------------------
01016  * Python API portion that goes into the runtime
01017  * ----------------------------------------------------------------------------- */
01018 
01019 #ifdef __cplusplus
01020 extern "C" {
01021 #if 0
01022 } /* cc-mode */
01023 #endif
01024 #endif
01025 
01026 /* -----------------------------------------------------------------------------
01027  * Constant declarations
01028  * ----------------------------------------------------------------------------- */
01029 
01030 /* Constant Types */
01031 #define SWIG_PY_POINTER 4
01032 #define SWIG_PY_BINARY  5
01033 
01034 /* Constant information structure */
01035 typedef struct swig_const_info {
01036   int type;
01037   char *name;
01038   long lvalue;
01039   double dvalue;
01040   void   *pvalue;
01041   swig_type_info **ptype;
01042 } swig_const_info;
01043 
01044 
01045 /* -----------------------------------------------------------------------------
01046  * Wrapper of PyInstanceMethod_New() used in Python 3
01047  * It is exported to the generated module, used for -fastproxy
01048  * ----------------------------------------------------------------------------- */
01049 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
01050 {
01051 #if PY_VERSION_HEX >= 0x03000000
01052   return PyInstanceMethod_New(func);
01053 #else
01054   return NULL;
01055 #endif
01056 }
01057 
01058 #ifdef __cplusplus
01059 #if 0
01060 { /* cc-mode */
01061 #endif
01062 }
01063 #endif
01064 
01065 
01066 /* -----------------------------------------------------------------------------
01067  * See the LICENSE file for information on copyright, usage and redistribution
01068  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01069  *
01070  * pyrun.swg
01071  *
01072  * This file contains the runtime support for Python modules
01073  * and includes code for managing global variables and pointer
01074  * type checking.
01075  *
01076  * ----------------------------------------------------------------------------- */
01077 
01078 /* Common SWIG API */
01079 
01080 /* for raw pointers */
01081 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01082 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
01083 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01084 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
01085 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
01086 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
01087 #define swig_owntype                                    int
01088 
01089 /* for raw packed data */
01090 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01091 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01092 
01093 /* for class or struct pointers */
01094 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
01095 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
01096 
01097 /* for C or C++ function pointers */
01098 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
01099 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
01100 
01101 /* for C++ member pointers, ie, member methods */
01102 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01103 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01104 
01105 
01106 /* Runtime API */
01107 
01108 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
01109 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
01110 #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
01111 
01112 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
01113 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
01114 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
01115 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
01116 #define SWIG_fail                                       goto fail                                          
01117 
01118 
01119 /* Runtime API implementation */
01120 
01121 /* Error manipulation */
01122 
01123 SWIGINTERN void 
01124 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01125   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
01126   PyErr_SetObject(errtype, obj);
01127   Py_DECREF(obj);
01128   SWIG_PYTHON_THREAD_END_BLOCK;
01129 }
01130 
01131 SWIGINTERN void 
01132 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01133   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01134   PyErr_SetString(errtype, (char *) msg);
01135   SWIG_PYTHON_THREAD_END_BLOCK;
01136 }
01137 
01138 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01139 
01140 /* Set a constant value */
01141 
01142 SWIGINTERN void
01143 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
01144   PyDict_SetItemString(d, (char*) name, obj);
01145   Py_DECREF(obj);                            
01146 }
01147 
01148 /* Append a value to the result obj */
01149 
01150 SWIGINTERN PyObject*
01151 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01152 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01153   if (!result) {
01154     result = obj;
01155   } else if (result == Py_None) {
01156     Py_DECREF(result);
01157     result = obj;
01158   } else {
01159     if (!PyList_Check(result)) {
01160       PyObject *o2 = result;
01161       result = PyList_New(1);
01162       PyList_SetItem(result, 0, o2);
01163     }
01164     PyList_Append(result,obj);
01165     Py_DECREF(obj);
01166   }
01167   return result;
01168 #else
01169   PyObject*   o2;
01170   PyObject*   o3;
01171   if (!result) {
01172     result = obj;
01173   } else if (result == Py_None) {
01174     Py_DECREF(result);
01175     result = obj;
01176   } else {
01177     if (!PyTuple_Check(result)) {
01178       o2 = result;
01179       result = PyTuple_New(1);
01180       PyTuple_SET_ITEM(result, 0, o2);
01181     }
01182     o3 = PyTuple_New(1);
01183     PyTuple_SET_ITEM(o3, 0, obj);
01184     o2 = result;
01185     result = PySequence_Concat(o2, o3);
01186     Py_DECREF(o2);
01187     Py_DECREF(o3);
01188   }
01189   return result;
01190 #endif
01191 }
01192 
01193 /* Unpack the argument tuple */
01194 
01195 SWIGINTERN int
01196 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
01197 {
01198   if (!args) {
01199     if (!min && !max) {
01200       return 1;
01201     } else {
01202       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
01203                    name, (min == max ? "" : "at least "), (int)min);
01204       return 0;
01205     }
01206   }  
01207   if (!PyTuple_Check(args)) {
01208     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01209     return 0;
01210   } else {
01211     register Py_ssize_t l = PyTuple_GET_SIZE(args);
01212     if (l < min) {
01213       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01214                    name, (min == max ? "" : "at least "), (int)min, (int)l);
01215       return 0;
01216     } else if (l > max) {
01217       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01218                    name, (min == max ? "" : "at most "), (int)max, (int)l);
01219       return 0;
01220     } else {
01221       register int i;
01222       for (i = 0; i < l; ++i) {
01223         objs[i] = PyTuple_GET_ITEM(args, i);
01224       }
01225       for (; l < max; ++l) {
01226         objs[l] = 0;
01227       }
01228       return i + 1;
01229     }    
01230   }
01231 }
01232 
01233 /* A functor is a function object with one single object argument */
01234 #if PY_VERSION_HEX >= 0x02020000
01235 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
01236 #else
01237 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
01238 #endif
01239 
01240 /*
01241   Helper for static pointer initialization for both C and C++ code, for example
01242   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
01243 */
01244 #ifdef __cplusplus
01245 #define SWIG_STATIC_POINTER(var)  var
01246 #else
01247 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
01248 #endif
01249 
01250 /* -----------------------------------------------------------------------------
01251  * Pointer declarations
01252  * ----------------------------------------------------------------------------- */
01253 
01254 /* Flags for new pointer objects */
01255 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
01256 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01257 
01258 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
01259 
01260 #ifdef __cplusplus
01261 extern "C" {
01262 #if 0
01263 } /* cc-mode */
01264 #endif
01265 #endif
01266 
01267 /*  How to access Py_None */
01268 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01269 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
01270 #    ifndef SWIG_PYTHON_BUILD_NONE
01271 #      define SWIG_PYTHON_BUILD_NONE
01272 #    endif
01273 #  endif
01274 #endif
01275 
01276 #ifdef SWIG_PYTHON_BUILD_NONE
01277 #  ifdef Py_None
01278 #   undef Py_None
01279 #   define Py_None SWIG_Py_None()
01280 #  endif
01281 SWIGRUNTIMEINLINE PyObject * 
01282 _SWIG_Py_None(void)
01283 {
01284   PyObject *none = Py_BuildValue((char*)"");
01285   Py_DECREF(none);
01286   return none;
01287 }
01288 SWIGRUNTIME PyObject * 
01289 SWIG_Py_None(void)
01290 {
01291   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01292   return none;
01293 }
01294 #endif
01295 
01296 /* The python void return value */
01297 
01298 SWIGRUNTIMEINLINE PyObject * 
01299 SWIG_Py_Void(void)
01300 {
01301   PyObject *none = Py_None;
01302   Py_INCREF(none);
01303   return none;
01304 }
01305 
01306 /* SwigPyClientData */
01307 
01308 typedef struct {
01309   PyObject *klass;
01310   PyObject *newraw;
01311   PyObject *newargs;
01312   PyObject *destroy;
01313   int delargs;
01314   int implicitconv;
01315 } SwigPyClientData;
01316 
01317 SWIGRUNTIMEINLINE int 
01318 SWIG_Python_CheckImplicit(swig_type_info *ty)
01319 {
01320   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
01321   return data ? data->implicitconv : 0;
01322 }
01323 
01324 SWIGRUNTIMEINLINE PyObject *
01325 SWIG_Python_ExceptionType(swig_type_info *desc) {
01326   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
01327   PyObject *klass = data ? data->klass : 0;
01328   return (klass ? klass : PyExc_RuntimeError);
01329 }
01330 
01331 
01332 SWIGRUNTIME SwigPyClientData * 
01333 SwigPyClientData_New(PyObject* obj)
01334 {
01335   if (!obj) {
01336     return 0;
01337   } else {
01338     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
01339     /* the klass element */
01340     data->klass = obj;
01341     Py_INCREF(data->klass);
01342     /* the newraw method and newargs arguments used to create a new raw instance */
01343     if (PyClass_Check(obj)) {
01344       data->newraw = 0;
01345       data->newargs = obj;
01346       Py_INCREF(obj);
01347     } else {
01348 #if (PY_VERSION_HEX < 0x02020000)
01349       data->newraw = 0;
01350 #else
01351       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01352 #endif
01353       if (data->newraw) {
01354         Py_INCREF(data->newraw);
01355         data->newargs = PyTuple_New(1);
01356         PyTuple_SetItem(data->newargs, 0, obj);
01357       } else {
01358         data->newargs = obj;
01359       }
01360       Py_INCREF(data->newargs);
01361     }
01362     /* the destroy method, aka as the C++ delete method */
01363     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01364     if (PyErr_Occurred()) {
01365       PyErr_Clear();
01366       data->destroy = 0;
01367     }
01368     if (data->destroy) {
01369       int flags;
01370       Py_INCREF(data->destroy);
01371       flags = PyCFunction_GET_FLAGS(data->destroy);
01372 #ifdef METH_O
01373       data->delargs = !(flags & (METH_O));
01374 #else
01375       data->delargs = 0;
01376 #endif
01377     } else {
01378       data->delargs = 0;
01379     }
01380     data->implicitconv = 0;
01381     return data;
01382   }
01383 }
01384 
01385 SWIGRUNTIME void 
01386 SwigPyClientData_Del(SwigPyClientData* data)
01387 {
01388   Py_XDECREF(data->newraw);
01389   Py_XDECREF(data->newargs);
01390   Py_XDECREF(data->destroy);
01391 }
01392 
01393 /* =============== SwigPyObject =====================*/
01394 
01395 typedef struct {
01396   PyObject_HEAD
01397   void *ptr;
01398   swig_type_info *ty;
01399   int own;
01400   PyObject *next;
01401 } SwigPyObject;
01402 
01403 SWIGRUNTIME PyObject *
01404 SwigPyObject_long(SwigPyObject *v)
01405 {
01406   return PyLong_FromVoidPtr(v->ptr);
01407 }
01408 
01409 SWIGRUNTIME PyObject *
01410 SwigPyObject_format(const char* fmt, SwigPyObject *v)
01411 {
01412   PyObject *res = NULL;
01413   PyObject *args = PyTuple_New(1);
01414   if (args) {
01415     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
01416       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
01417       if (ofmt) {
01418 #if PY_VERSION_HEX >= 0x03000000
01419         res = PyUnicode_Format(ofmt,args);
01420 #else
01421         res = PyString_Format(ofmt,args);
01422 #endif
01423         Py_DECREF(ofmt);
01424       }
01425       Py_DECREF(args);
01426     }
01427   }
01428   return res;
01429 }
01430 
01431 SWIGRUNTIME PyObject *
01432 SwigPyObject_oct(SwigPyObject *v)
01433 {
01434   return SwigPyObject_format("%o",v);
01435 }
01436 
01437 SWIGRUNTIME PyObject *
01438 SwigPyObject_hex(SwigPyObject *v)
01439 {
01440   return SwigPyObject_format("%x",v);
01441 }
01442 
01443 SWIGRUNTIME PyObject *
01444 #ifdef METH_NOARGS
01445 SwigPyObject_repr(SwigPyObject *v)
01446 #else
01447 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
01448 #endif
01449 {
01450   const char *name = SWIG_TypePrettyName(v->ty);
01451   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
01452   if (v->next) {
01453 #ifdef METH_NOARGS
01454     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
01455 #else
01456     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
01457 #endif
01458 #if PY_VERSION_HEX >= 0x03000000
01459     PyObject *joined = PyUnicode_Concat(repr, nrep);
01460     Py_DecRef(repr);
01461     Py_DecRef(nrep);
01462     repr = joined;
01463 #else
01464     PyString_ConcatAndDel(&repr,nrep);
01465 #endif
01466   }
01467   return repr;  
01468 }
01469 
01470 SWIGRUNTIME int
01471 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01472 {
01473   char *str;
01474 #ifdef METH_NOARGS
01475   PyObject *repr = SwigPyObject_repr(v);
01476 #else
01477   PyObject *repr = SwigPyObject_repr(v, NULL);
01478 #endif
01479   if (repr) {
01480     str = SWIG_Python_str_AsChar(repr); 
01481     fputs(str, fp);
01482     SWIG_Python_str_DelForPy3(str);
01483     Py_DECREF(repr);
01484     return 0; 
01485   } else {
01486     return 1; 
01487   }
01488 }
01489 
01490 SWIGRUNTIME PyObject *
01491 SwigPyObject_str(SwigPyObject *v)
01492 {
01493   char result[SWIG_BUFFER_SIZE];
01494   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
01495     SWIG_Python_str_FromChar(result) : 0;
01496 }
01497 
01498 SWIGRUNTIME int
01499 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
01500 {
01501   void *i = v->ptr;
01502   void *j = w->ptr;
01503   return (i < j) ? -1 : ((i > j) ? 1 : 0);
01504 }
01505 
01506 /* Added for Python 3.x, would it also be useful for Python 2.x? */
01507 SWIGRUNTIME PyObject*
01508 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
01509 {
01510   PyObject* res;
01511   if( op != Py_EQ && op != Py_NE ) {
01512     Py_INCREF(Py_NotImplemented);
01513     return Py_NotImplemented;
01514   }
01515   if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
01516     res = Py_True;
01517   else
01518     res = Py_False;
01519   Py_INCREF(res);
01520   return res;  
01521 }
01522 
01523 
01524 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
01525 
01526 SWIGRUNTIME PyTypeObject*
01527 SwigPyObject_type(void) {
01528   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
01529   return type;
01530 }
01531 
01532 SWIGRUNTIMEINLINE int
01533 SwigPyObject_Check(PyObject *op) {
01534   return (Py_TYPE(op) == SwigPyObject_type())
01535     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
01536 }
01537 
01538 SWIGRUNTIME PyObject *
01539 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
01540 
01541 SWIGRUNTIME void
01542 SwigPyObject_dealloc(PyObject *v)
01543 {
01544   SwigPyObject *sobj = (SwigPyObject *) v;
01545   PyObject *next = sobj->next;
01546   if (sobj->own == SWIG_POINTER_OWN) {
01547     swig_type_info *ty = sobj->ty;
01548     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
01549     PyObject *destroy = data ? data->destroy : 0;
01550     if (destroy) {
01551       /* destroy is always a VARARGS method */
01552       PyObject *res;
01553       if (data->delargs) {
01554         /* we need to create a temporary object to carry the destroy operation */
01555         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
01556         res = SWIG_Python_CallFunctor(destroy, tmp);
01557         Py_DECREF(tmp);
01558       } else {
01559         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01560         PyObject *mself = PyCFunction_GET_SELF(destroy);
01561         res = ((*meth)(mself, v));
01562       }
01563       Py_XDECREF(res);
01564     } 
01565 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01566     else {
01567       const char *name = SWIG_TypePrettyName(ty);
01568       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
01569     }
01570 #endif
01571   } 
01572   Py_XDECREF(next);
01573   PyObject_DEL(v);
01574 }
01575 
01576 SWIGRUNTIME PyObject* 
01577 SwigPyObject_append(PyObject* v, PyObject* next)
01578 {
01579   SwigPyObject *sobj = (SwigPyObject *) v;
01580 #ifndef METH_O
01581   PyObject *tmp = 0;
01582   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01583   next = tmp;
01584 #endif
01585   if (!SwigPyObject_Check(next)) {
01586     return NULL;
01587   }
01588   sobj->next = next;
01589   Py_INCREF(next);
01590   return SWIG_Py_Void();
01591 }
01592 
01593 SWIGRUNTIME PyObject* 
01594 #ifdef METH_NOARGS
01595 SwigPyObject_next(PyObject* v)
01596 #else
01597 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01598 #endif
01599 {
01600   SwigPyObject *sobj = (SwigPyObject *) v;
01601   if (sobj->next) {    
01602     Py_INCREF(sobj->next);
01603     return sobj->next;
01604   } else {
01605     return SWIG_Py_Void();
01606   }
01607 }
01608 
01609 SWIGINTERN PyObject*
01610 #ifdef METH_NOARGS
01611 SwigPyObject_disown(PyObject *v)
01612 #else
01613 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01614 #endif
01615 {
01616   SwigPyObject *sobj = (SwigPyObject *)v;
01617   sobj->own = 0;
01618   return SWIG_Py_Void();
01619 }
01620 
01621 SWIGINTERN PyObject*
01622 #ifdef METH_NOARGS
01623 SwigPyObject_acquire(PyObject *v)
01624 #else
01625 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01626 #endif
01627 {
01628   SwigPyObject *sobj = (SwigPyObject *)v;
01629   sobj->own = SWIG_POINTER_OWN;
01630   return SWIG_Py_Void();
01631 }
01632 
01633 SWIGINTERN PyObject*
01634 SwigPyObject_own(PyObject *v, PyObject *args)
01635 {
01636   PyObject *val = 0;
01637 #if (PY_VERSION_HEX < 0x02020000)
01638   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01639 #else
01640   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
01641 #endif
01642     {
01643       return NULL;
01644     } 
01645   else
01646     {
01647       SwigPyObject *sobj = (SwigPyObject *)v;
01648       PyObject *obj = PyBool_FromLong(sobj->own);
01649       if (val) {
01650 #ifdef METH_NOARGS
01651         if (PyObject_IsTrue(val)) {
01652           SwigPyObject_acquire(v);
01653         } else {
01654           SwigPyObject_disown(v);
01655         }
01656 #else
01657         if (PyObject_IsTrue(val)) {
01658           SwigPyObject_acquire(v,args);
01659         } else {
01660           SwigPyObject_disown(v,args);
01661         }
01662 #endif
01663       } 
01664       return obj;
01665     }
01666 }
01667 
01668 #ifdef METH_O
01669 static PyMethodDef
01670 swigobject_methods[] = {
01671   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
01672   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
01673   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01674   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
01675   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
01676   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
01677   {0, 0, 0, 0}  
01678 };
01679 #else
01680 static PyMethodDef
01681 swigobject_methods[] = {
01682   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
01683   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
01684   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
01685   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
01686   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
01687   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
01688   {0, 0, 0, 0}  
01689 };
01690 #endif
01691 
01692 #if PY_VERSION_HEX < 0x02020000
01693 SWIGINTERN PyObject *
01694 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
01695 {
01696   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01697 }
01698 #endif
01699 
01700 SWIGRUNTIME PyTypeObject*
01701 _PySwigObject_type(void) {
01702   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01703   
01704   static PyNumberMethods SwigPyObject_as_number = {
01705     (binaryfunc)0, /*nb_add*/
01706     (binaryfunc)0, /*nb_subtract*/
01707     (binaryfunc)0, /*nb_multiply*/
01708     /* nb_divide removed in Python 3 */
01709 #if PY_VERSION_HEX < 0x03000000
01710     (binaryfunc)0, /*nb_divide*/
01711 #endif
01712     (binaryfunc)0, /*nb_remainder*/
01713     (binaryfunc)0, /*nb_divmod*/
01714     (ternaryfunc)0,/*nb_power*/
01715     (unaryfunc)0,  /*nb_negative*/
01716     (unaryfunc)0,  /*nb_positive*/
01717     (unaryfunc)0,  /*nb_absolute*/
01718     (inquiry)0,    /*nb_nonzero*/
01719     0,             /*nb_invert*/
01720     0,             /*nb_lshift*/
01721     0,             /*nb_rshift*/
01722     0,             /*nb_and*/
01723     0,             /*nb_xor*/
01724     0,             /*nb_or*/
01725 #if PY_VERSION_HEX < 0x03000000
01726     0,   /*nb_coerce*/
01727 #endif
01728     (unaryfunc)SwigPyObject_long, /*nb_int*/
01729 #if PY_VERSION_HEX < 0x03000000
01730     (unaryfunc)SwigPyObject_long, /*nb_long*/
01731 #else
01732     0, /*nb_reserved*/
01733 #endif
01734     (unaryfunc)0,                 /*nb_float*/
01735 #if PY_VERSION_HEX < 0x03000000
01736     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
01737     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
01738 #endif
01739 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
01740     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
01741 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
01742     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
01743 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
01744     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
01745 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
01746     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
01747 #endif
01748   };
01749 
01750   static PyTypeObject swigpyobject_type;  
01751   static int type_init = 0;
01752   if (!type_init) {
01753     const PyTypeObject tmp
01754       = {
01755         /* PyObject header changed in Python 3 */
01756 #if PY_VERSION_HEX >= 0x03000000
01757         PyVarObject_HEAD_INIT(&PyType_Type, 0)
01758 #else    
01759         PyObject_HEAD_INIT(NULL)
01760         0,                                  /* ob_size */
01761 #endif
01762         (char *)"SwigPyObject",             /* tp_name */
01763         sizeof(SwigPyObject),               /* tp_basicsize */
01764         0,                                  /* tp_itemsize */
01765         (destructor)SwigPyObject_dealloc,   /* tp_dealloc */
01766         (printfunc)SwigPyObject_print,      /* tp_print */
01767 #if PY_VERSION_HEX < 0x02020000
01768         (getattrfunc)SwigPyObject_getattr,  /* tp_getattr */ 
01769 #else
01770         (getattrfunc)0,                     /* tp_getattr */ 
01771 #endif
01772         (setattrfunc)0,                     /* tp_setattr */ 
01773 #if PY_VERSION_HEX >= 0x03000000
01774     0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
01775 #else
01776         (cmpfunc)SwigPyObject_compare,      /* tp_compare */
01777 #endif
01778         (reprfunc)SwigPyObject_repr,        /* tp_repr */    
01779         &SwigPyObject_as_number,            /* tp_as_number */
01780         0,                                  /* tp_as_sequence */
01781         0,                                  /* tp_as_mapping */
01782         (hashfunc)0,                        /* tp_hash */
01783         (ternaryfunc)0,                     /* tp_call */
01784         (reprfunc)SwigPyObject_str,         /* tp_str */
01785         PyObject_GenericGetAttr,            /* tp_getattro */
01786         0,                                  /* tp_setattro */
01787         0,                                  /* tp_as_buffer */
01788         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
01789         swigobject_doc,                     /* tp_doc */        
01790         0,                                  /* tp_traverse */
01791         0,                                  /* tp_clear */
01792         (richcmpfunc)SwigPyObject_richcompare,           /* tp_richcompare */
01793         0,                                  /* tp_weaklistoffset */
01794 #if PY_VERSION_HEX >= 0x02020000
01795         0,                                  /* tp_iter */
01796         0,                                  /* tp_iternext */
01797         swigobject_methods,                 /* tp_methods */ 
01798         0,                                  /* tp_members */
01799         0,                                  /* tp_getset */             
01800         0,                                  /* tp_base */               
01801         0,                                  /* tp_dict */               
01802         0,                                  /* tp_descr_get */          
01803         0,                                  /* tp_descr_set */          
01804         0,                                  /* tp_dictoffset */         
01805         0,                                  /* tp_init */               
01806         0,                                  /* tp_alloc */              
01807         0,                                  /* tp_new */                
01808         0,                                  /* tp_free */          
01809         0,                                  /* tp_is_gc */  
01810         0,                                  /* tp_bases */   
01811         0,                                  /* tp_mro */
01812         0,                                  /* tp_cache */   
01813         0,                                  /* tp_subclasses */
01814         0,                                  /* tp_weaklist */
01815 #endif
01816 #if PY_VERSION_HEX >= 0x02030000
01817         0,                                  /* tp_del */
01818 #endif
01819 #ifdef COUNT_ALLOCS
01820         0,0,0,0                             /* tp_alloc -> tp_next */
01821 #endif
01822       };
01823     swigpyobject_type = tmp;
01824     /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
01825 #if PY_VERSION_HEX < 0x03000000
01826     swigpyobject_type.ob_type = &PyType_Type;
01827 #endif
01828     type_init = 1;
01829   }
01830   return &swigpyobject_type;
01831 }
01832 
01833 SWIGRUNTIME PyObject *
01834 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
01835 {
01836   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
01837   if (sobj) {
01838     sobj->ptr  = ptr;
01839     sobj->ty   = ty;
01840     sobj->own  = own;
01841     sobj->next = 0;
01842   }
01843   return (PyObject *)sobj;
01844 }
01845 
01846 /* -----------------------------------------------------------------------------
01847  * Implements a simple Swig Packed type, and use it instead of string
01848  * ----------------------------------------------------------------------------- */
01849 
01850 typedef struct {
01851   PyObject_HEAD
01852   void *pack;
01853   swig_type_info *ty;
01854   size_t size;
01855 } SwigPyPacked;
01856 
01857 SWIGRUNTIME int
01858 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01859 {
01860   char result[SWIG_BUFFER_SIZE];
01861   fputs("<Swig Packed ", fp); 
01862   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01863     fputs("at ", fp); 
01864     fputs(result, fp); 
01865   }
01866   fputs(v->ty->name,fp); 
01867   fputs(">", fp);
01868   return 0; 
01869 }
01870   
01871 SWIGRUNTIME PyObject *
01872 SwigPyPacked_repr(SwigPyPacked *v)
01873 {
01874   char result[SWIG_BUFFER_SIZE];
01875   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01876     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01877   } else {
01878     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
01879   }  
01880 }
01881 
01882 SWIGRUNTIME PyObject *
01883 SwigPyPacked_str(SwigPyPacked *v)
01884 {
01885   char result[SWIG_BUFFER_SIZE];
01886   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01887     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
01888   } else {
01889     return SWIG_Python_str_FromChar(v->ty->name);
01890   }  
01891 }
01892 
01893 SWIGRUNTIME int
01894 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
01895 {
01896   size_t i = v->size;
01897   size_t j = w->size;
01898   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
01899   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
01900 }
01901 
01902 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
01903 
01904 SWIGRUNTIME PyTypeObject*
01905 SwigPyPacked_type(void) {
01906   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
01907   return type;
01908 }
01909 
01910 SWIGRUNTIMEINLINE int
01911 SwigPyPacked_Check(PyObject *op) {
01912   return ((op)->ob_type == _PySwigPacked_type()) 
01913     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
01914 }
01915 
01916 SWIGRUNTIME void
01917 SwigPyPacked_dealloc(PyObject *v)
01918 {
01919   if (SwigPyPacked_Check(v)) {
01920     SwigPyPacked *sobj = (SwigPyPacked *) v;
01921     free(sobj->pack);
01922   }
01923   PyObject_DEL(v);
01924 }
01925 
01926 SWIGRUNTIME PyTypeObject*
01927 _PySwigPacked_type(void) {
01928   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
01929   static PyTypeObject swigpypacked_type;
01930   static int type_init = 0;  
01931   if (!type_init) {
01932     const PyTypeObject tmp
01933       = {
01934     /* PyObject header changed in Python 3 */
01935 #if PY_VERSION_HEX>=0x03000000
01936     PyVarObject_HEAD_INIT(&PyType_Type, 0)
01937 #else
01938         PyObject_HEAD_INIT(NULL)
01939     0,                              /* ob_size */       
01940 #endif
01941         (char *)"SwigPyPacked",             /* tp_name */       
01942         sizeof(SwigPyPacked),               /* tp_basicsize */  
01943         0,                                  /* tp_itemsize */   
01944         (destructor)SwigPyPacked_dealloc,   /* tp_dealloc */    
01945         (printfunc)SwigPyPacked_print,      /* tp_print */      
01946         (getattrfunc)0,                     /* tp_getattr */    
01947         (setattrfunc)0,                     /* tp_setattr */    
01948 #if PY_VERSION_HEX>=0x03000000
01949     0, /* tp_reserved in 3.0.1 */
01950 #else
01951     (cmpfunc)SwigPyPacked_compare,          /* tp_compare */
01952 #endif
01953         (reprfunc)SwigPyPacked_repr,        /* tp_repr */
01954         0,                                  /* tp_as_number */
01955         0,                                  /* tp_as_sequence */
01956         0,                                  /* tp_as_mapping */
01957         (hashfunc)0,                        /* tp_hash */
01958         (ternaryfunc)0,                     /* tp_call */
01959         (reprfunc)SwigPyPacked_str,         /* tp_str */
01960         PyObject_GenericGetAttr,            /* tp_getattro */
01961         0,                                  /* tp_setattro */
01962         0,                                  /* tp_as_buffer */
01963         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
01964         swigpacked_doc,                     /* tp_doc */
01965         0,                                  /* tp_traverse */
01966         0,                                  /* tp_clear */
01967         0,                                  /* tp_richcompare */
01968         0,                                  /* tp_weaklistoffset */
01969 #if PY_VERSION_HEX >= 0x02020000
01970         0,                                  /* tp_iter */
01971         0,                                  /* tp_iternext */
01972         0,                                  /* tp_methods */ 
01973         0,                                  /* tp_members */
01974         0,                                  /* tp_getset */             
01975         0,                                  /* tp_base */               
01976         0,                                  /* tp_dict */               
01977         0,                                  /* tp_descr_get */          
01978         0,                                  /* tp_descr_set */          
01979         0,                                  /* tp_dictoffset */         
01980         0,                                  /* tp_init */               
01981         0,                                  /* tp_alloc */              
01982         0,                                  /* tp_new */                
01983         0,                                  /* tp_free */          
01984         0,                                  /* tp_is_gc */  
01985         0,                                  /* tp_bases */   
01986         0,                                  /* tp_mro */
01987         0,                                  /* tp_cache */   
01988         0,                                  /* tp_subclasses */
01989         0,                                  /* tp_weaklist */
01990 #endif
01991 #if PY_VERSION_HEX >= 0x02030000
01992         0,                                  /* tp_del */
01993 #endif
01994 #ifdef COUNT_ALLOCS
01995         0,0,0,0                             /* tp_alloc -> tp_next */
01996 #endif
01997       };
01998     swigpypacked_type = tmp;
01999     /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
02000 #if PY_VERSION_HEX < 0x03000000
02001     swigpypacked_type.ob_type = &PyType_Type;
02002 #endif
02003     type_init = 1;
02004   }
02005   return &swigpypacked_type;
02006 }
02007 
02008 SWIGRUNTIME PyObject *
02009 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
02010 {
02011   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
02012   if (sobj) {
02013     void *pack = malloc(size);
02014     if (pack) {
02015       memcpy(pack, ptr, size);
02016       sobj->pack = pack;
02017       sobj->ty   = ty;
02018       sobj->size = size;
02019     } else {
02020       PyObject_DEL((PyObject *) sobj);
02021       sobj = 0;
02022     }
02023   }
02024   return (PyObject *) sobj;
02025 }
02026 
02027 SWIGRUNTIME swig_type_info *
02028 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
02029 {
02030   if (SwigPyPacked_Check(obj)) {
02031     SwigPyPacked *sobj = (SwigPyPacked *)obj;
02032     if (sobj->size != size) return 0;
02033     memcpy(ptr, sobj->pack, size);
02034     return sobj->ty;
02035   } else {
02036     return 0;
02037   }
02038 }
02039 
02040 /* -----------------------------------------------------------------------------
02041  * pointers/data manipulation
02042  * ----------------------------------------------------------------------------- */
02043 
02044 SWIGRUNTIMEINLINE PyObject *
02045 _SWIG_This(void)
02046 {
02047     return SWIG_Python_str_FromChar("this");
02048 }
02049 
02050 SWIGRUNTIME PyObject *
02051 SWIG_This(void)
02052 {
02053   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
02054   return swig_this;
02055 }
02056 
02057 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
02058 
02059 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
02060 #if PY_VERSION_HEX>=0x03000000
02061 #define SWIG_PYTHON_SLOW_GETSET_THIS 
02062 #endif
02063 
02064 SWIGRUNTIME SwigPyObject *
02065 SWIG_Python_GetSwigThis(PyObject *pyobj) 
02066 {
02067   if (SwigPyObject_Check(pyobj)) {
02068     return (SwigPyObject *) pyobj;
02069   } else {
02070     PyObject *obj = 0;
02071 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
02072     if (PyInstance_Check(pyobj)) {
02073       obj = _PyInstance_Lookup(pyobj, SWIG_This());      
02074     } else {
02075       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
02076       if (dictptr != NULL) {
02077         PyObject *dict = *dictptr;
02078         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
02079       } else {
02080 #ifdef PyWeakref_CheckProxy
02081         if (PyWeakref_CheckProxy(pyobj)) {
02082           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
02083           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
02084         }
02085 #endif
02086         obj = PyObject_GetAttr(pyobj,SWIG_This());
02087         if (obj) {
02088           Py_DECREF(obj);
02089         } else {
02090           if (PyErr_Occurred()) PyErr_Clear();
02091           return 0;
02092         }
02093       }
02094     }
02095 #else
02096     obj = PyObject_GetAttr(pyobj,SWIG_This());
02097     if (obj) {
02098       Py_DECREF(obj);
02099     } else {
02100       if (PyErr_Occurred()) PyErr_Clear();
02101       return 0;
02102     }
02103 #endif
02104     if (obj && !SwigPyObject_Check(obj)) {
02105       /* a PyObject is called 'this', try to get the 'real this'
02106          SwigPyObject from it */ 
02107       return SWIG_Python_GetSwigThis(obj);
02108     }
02109     return (SwigPyObject *)obj;
02110   }
02111 }
02112 
02113 /* Acquire a pointer value */
02114 
02115 SWIGRUNTIME int
02116 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
02117   if (own == SWIG_POINTER_OWN) {
02118     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02119     if (sobj) {
02120       int oldown = sobj->own;
02121       sobj->own = own;
02122       return oldown;
02123     }
02124   }
02125   return 0;
02126 }
02127 
02128 /* Convert a pointer value */
02129 
02130 SWIGRUNTIME int
02131 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
02132   if (!obj) return SWIG_ERROR;
02133   if (obj == Py_None) {
02134     if (ptr) *ptr = 0;
02135     return SWIG_OK;
02136   } else {
02137     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02138     if (own)
02139       *own = 0;
02140     while (sobj) {
02141       void *vptr = sobj->ptr;
02142       if (ty) {
02143         swig_type_info *to = sobj->ty;
02144         if (to == ty) {
02145           /* no type cast needed */
02146           if (ptr) *ptr = vptr;
02147           break;
02148         } else {
02149           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02150           if (!tc) {
02151             sobj = (SwigPyObject *)sobj->next;
02152           } else {
02153             if (ptr) {
02154               int newmemory = 0;
02155               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02156               if (newmemory == SWIG_CAST_NEW_MEMORY) {
02157                 assert(own);
02158                 if (own)
02159                   *own = *own | SWIG_CAST_NEW_MEMORY;
02160               }
02161             }
02162             break;
02163           }
02164         }
02165       } else {
02166         if (ptr) *ptr = vptr;
02167         break;
02168       }
02169     }
02170     if (sobj) {
02171       if (own)
02172         *own = *own | sobj->own;
02173       if (flags & SWIG_POINTER_DISOWN) {
02174         sobj->own = 0;
02175       }
02176       return SWIG_OK;
02177     } else {
02178       int res = SWIG_ERROR;
02179       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
02180         SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
02181         if (data && !data->implicitconv) {
02182           PyObject *klass = data->klass;
02183           if (klass) {
02184             PyObject *impconv;
02185             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
02186             impconv = SWIG_Python_CallFunctor(klass, obj);
02187             data->implicitconv = 0;
02188             if (PyErr_Occurred()) {
02189               PyErr_Clear();
02190               impconv = 0;
02191             }
02192             if (impconv) {
02193               SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
02194               if (iobj) {
02195                 void *vptr;
02196                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02197                 if (SWIG_IsOK(res)) {
02198                   if (ptr) {
02199                     *ptr = vptr;
02200                     /* transfer the ownership to 'ptr' */
02201                     iobj->own = 0;
02202                     res = SWIG_AddCast(res);
02203                     res = SWIG_AddNewMask(res);
02204                   } else {
02205                     res = SWIG_AddCast(res);                
02206                   }
02207                 }
02208               }
02209               Py_DECREF(impconv);
02210             }
02211           }
02212         }
02213       }
02214       return res;
02215     }
02216   }
02217 }
02218 
02219 /* Convert a function ptr value */
02220 
02221 SWIGRUNTIME int
02222 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02223   if (!PyCFunction_Check(obj)) {
02224     return SWIG_ConvertPtr(obj, ptr, ty, 0);
02225   } else {
02226     void *vptr = 0;
02227     
02228     /* here we get the method pointer for callbacks */
02229     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02230     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02231     if (desc)
02232       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02233     if (!desc) 
02234       return SWIG_ERROR;
02235     if (ty) {
02236       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02237       if (tc) {
02238         int newmemory = 0;
02239         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02240         assert(!newmemory); /* newmemory handling not yet implemented */
02241       } else {
02242         return SWIG_ERROR;
02243       }
02244     } else {
02245       *ptr = vptr;
02246     }
02247     return SWIG_OK;
02248   }
02249 }
02250 
02251 /* Convert a packed value value */
02252 
02253 SWIGRUNTIME int
02254 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02255   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
02256   if (!to) return SWIG_ERROR;
02257   if (ty) {
02258     if (to != ty) {
02259       /* check type cast? */
02260       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02261       if (!tc) return SWIG_ERROR;
02262     }
02263   }
02264   return SWIG_OK;
02265 }  
02266 
02267 /* -----------------------------------------------------------------------------
02268  * Create a new pointer object
02269  * ----------------------------------------------------------------------------- */
02270 
02271 /*
02272   Create a new instance object, without calling __init__, and set the
02273   'this' attribute.
02274 */
02275 
02276 SWIGRUNTIME PyObject* 
02277 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
02278 {
02279 #if (PY_VERSION_HEX >= 0x02020000)
02280   PyObject *inst = 0;
02281   PyObject *newraw = data->newraw;
02282   if (newraw) {
02283     inst = PyObject_Call(newraw, data->newargs, NULL);
02284     if (inst) {
02285 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02286       PyObject **dictptr = _PyObject_GetDictPtr(inst);
02287       if (dictptr != NULL) {
02288         PyObject *dict = *dictptr;
02289         if (dict == NULL) {
02290           dict = PyDict_New();
02291           *dictptr = dict;
02292           PyDict_SetItem(dict, SWIG_This(), swig_this);
02293         }
02294       }
02295 #else
02296       PyObject *key = SWIG_This();
02297       PyObject_SetAttr(inst, key, swig_this);
02298 #endif
02299     }
02300   } else {
02301 #if PY_VERSION_HEX >= 0x03000000
02302     inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
02303     PyObject_SetAttr(inst, SWIG_This(), swig_this);
02304     Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
02305 #else
02306     PyObject *dict = PyDict_New();
02307     PyDict_SetItem(dict, SWIG_This(), swig_this);
02308     inst = PyInstance_NewRaw(data->newargs, dict);
02309     Py_DECREF(dict);
02310 #endif
02311   }
02312   return inst;
02313 #else
02314 #if (PY_VERSION_HEX >= 0x02010000)
02315   PyObject *inst;
02316   PyObject *dict = PyDict_New();
02317   PyDict_SetItem(dict, SWIG_This(), swig_this);
02318   inst = PyInstance_NewRaw(data->newargs, dict);
02319   Py_DECREF(dict);
02320   return (PyObject *) inst;
02321 #else
02322   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02323   if (inst == NULL) {
02324     return NULL;
02325   }
02326   inst->in_class = (PyClassObject *)data->newargs;
02327   Py_INCREF(inst->in_class);
02328   inst->in_dict = PyDict_New();
02329   if (inst->in_dict == NULL) {
02330     Py_DECREF(inst);
02331     return NULL;
02332   }
02333 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02334   inst->in_weakreflist = NULL;
02335 #endif
02336 #ifdef Py_TPFLAGS_GC
02337   PyObject_GC_Init(inst);
02338 #endif
02339   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02340   return (PyObject *) inst;
02341 #endif
02342 #endif
02343 }
02344 
02345 SWIGRUNTIME void
02346 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02347 {
02348  PyObject *dict;
02349 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02350  PyObject **dictptr = _PyObject_GetDictPtr(inst);
02351  if (dictptr != NULL) {
02352    dict = *dictptr;
02353    if (dict == NULL) {
02354      dict = PyDict_New();
02355      *dictptr = dict;
02356    }
02357    PyDict_SetItem(dict, SWIG_This(), swig_this);
02358    return;
02359  }
02360 #endif
02361  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02362  PyDict_SetItem(dict, SWIG_This(), swig_this);
02363  Py_DECREF(dict);
02364 } 
02365 
02366 
02367 SWIGINTERN PyObject *
02368 SWIG_Python_InitShadowInstance(PyObject *args) {
02369   PyObject *obj[2];
02370   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
02371     return NULL;
02372   } else {
02373     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02374     if (sthis) {
02375       SwigPyObject_append((PyObject*) sthis, obj[1]);
02376     } else {
02377       SWIG_Python_SetSwigThis(obj[0], obj[1]);
02378     }
02379     return SWIG_Py_Void();
02380   }
02381 }
02382 
02383 /* Create a new pointer object */
02384 
02385 SWIGRUNTIME PyObject *
02386 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
02387   if (!ptr) {
02388     return SWIG_Py_Void();
02389   } else {
02390     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02391     PyObject *robj = SwigPyObject_New(ptr, type, own);
02392     SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
02393     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02394       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02395       if (inst) {
02396         Py_DECREF(robj);
02397         robj = inst;
02398       }
02399     }
02400     return robj;
02401   }
02402 }
02403 
02404 /* Create a new packed object */
02405 
02406 SWIGRUNTIMEINLINE PyObject *
02407 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02408   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02409 }
02410 
02411 /* -----------------------------------------------------------------------------*
02412  *  Get type list 
02413  * -----------------------------------------------------------------------------*/
02414 
02415 #ifdef SWIG_LINK_RUNTIME
02416 void *SWIG_ReturnGlobalTypeList(void *);
02417 #endif
02418 
02419 SWIGRUNTIME swig_module_info *
02420 SWIG_Python_GetModule(void) {
02421   static void *type_pointer = (void *)0;
02422   /* first check if module already created */
02423   if (!type_pointer) {
02424 #ifdef SWIG_LINK_RUNTIME
02425     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02426 #else
02427     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02428                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02429     if (PyErr_Occurred()) {
02430       PyErr_Clear();
02431       type_pointer = (void *)0;
02432     }
02433 #endif
02434   }
02435   return (swig_module_info *) type_pointer;
02436 }
02437 
02438 #if PY_MAJOR_VERSION < 2
02439 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
02440    is copied out of Python/modsupport.c in python version 2.3.4 */
02441 SWIGINTERN int
02442 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02443 {
02444   PyObject *dict;
02445   if (!PyModule_Check(m)) {
02446     PyErr_SetString(PyExc_TypeError,
02447                     "PyModule_AddObject() needs module as first arg");
02448     return SWIG_ERROR;
02449   }
02450   if (!o) {
02451     PyErr_SetString(PyExc_TypeError,
02452                     "PyModule_AddObject() needs non-NULL value");
02453     return SWIG_ERROR;
02454   }
02455   
02456   dict = PyModule_GetDict(m);
02457   if (dict == NULL) {
02458     /* Internal error -- modules must have a dict! */
02459     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02460                  PyModule_GetName(m));
02461     return SWIG_ERROR;
02462   }
02463   if (PyDict_SetItemString(dict, name, o))
02464     return SWIG_ERROR;
02465   Py_DECREF(o);
02466   return SWIG_OK;
02467 }
02468 #endif
02469 
02470 SWIGRUNTIME void
02471 SWIG_Python_DestroyModule(void *vptr)
02472 {
02473   swig_module_info *swig_module = (swig_module_info *) vptr;
02474   swig_type_info **types = swig_module->types;
02475   size_t i;
02476   for (i =0; i < swig_module->size; ++i) {
02477     swig_type_info *ty = types[i];
02478     if (ty->owndata) {
02479       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
02480       if (data) SwigPyClientData_Del(data);
02481     }
02482   }
02483   Py_DECREF(SWIG_This());
02484 }
02485 
02486 SWIGRUNTIME void
02487 SWIG_Python_SetModule(swig_module_info *swig_module) {
02488   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
02489 
02490 #if PY_VERSION_HEX >= 0x03000000
02491  /* Add a dummy module object into sys.modules */
02492   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
02493 #else
02494   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02495                                    swig_empty_runtime_method_table);
02496 #endif
02497   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02498   if (pointer && module) {
02499     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02500   } else {
02501     Py_XDECREF(pointer);
02502   }
02503 }
02504 
02505 /* The python cached type query */
02506 SWIGRUNTIME PyObject *
02507 SWIG_Python_TypeCache(void) {
02508   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02509   return cache;
02510 }
02511 
02512 SWIGRUNTIME swig_type_info *
02513 SWIG_Python_TypeQuery(const char *type)
02514 {
02515   PyObject *cache = SWIG_Python_TypeCache();
02516   PyObject *key = SWIG_Python_str_FromChar(type); 
02517   PyObject *obj = PyDict_GetItem(cache, key);
02518   swig_type_info *descriptor;
02519   if (obj) {
02520     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02521   } else {
02522     swig_module_info *swig_module = SWIG_Python_GetModule();
02523     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02524     if (descriptor) {
02525       obj = PyCObject_FromVoidPtr(descriptor, NULL);
02526       PyDict_SetItem(cache, key, obj);
02527       Py_DECREF(obj);
02528     }
02529   }
02530   Py_DECREF(key);
02531   return descriptor;
02532 }
02533 
02534 /* 
02535    For backward compatibility only
02536 */
02537 #define SWIG_POINTER_EXCEPTION  0
02538 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
02539 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
02540 
02541 SWIGRUNTIME int
02542 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02543 {  
02544   if (PyErr_Occurred()) {
02545     PyObject *type = 0;
02546     PyObject *value = 0;
02547     PyObject *traceback = 0;
02548     PyErr_Fetch(&type, &value, &traceback);
02549     if (value) {
02550       char *tmp;
02551       PyObject *old_str = PyObject_Str(value);
02552       Py_XINCREF(type);
02553       PyErr_Clear();
02554       if (infront) {
02555         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
02556       } else {
02557         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
02558       }
02559       SWIG_Python_str_DelForPy3(tmp);
02560       Py_DECREF(old_str);
02561     }
02562     return 1;
02563   } else {
02564     return 0;
02565   }
02566 }
02567   
02568 SWIGRUNTIME int
02569 SWIG_Python_ArgFail(int argnum)
02570 {
02571   if (PyErr_Occurred()) {
02572     /* add information about failing argument */
02573     char mesg[256];
02574     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02575     return SWIG_Python_AddErrMesg(mesg, 1);
02576   } else {
02577     return 0;
02578   }
02579 }
02580 
02581 SWIGRUNTIMEINLINE const char *
02582 SwigPyObject_GetDesc(PyObject *self)
02583 {
02584   SwigPyObject *v = (SwigPyObject *)self;
02585   swig_type_info *ty = v ? v->ty : 0;
02586   return ty ? ty->str : (char*)"";
02587 }
02588 
02589 SWIGRUNTIME void
02590 SWIG_Python_TypeError(const char *type, PyObject *obj)
02591 {
02592   if (type) {
02593 #if defined(SWIG_COBJECT_TYPES)
02594     if (obj && SwigPyObject_Check(obj)) {
02595       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
02596       if (otype) {
02597         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
02598                      type, otype);
02599         return;
02600       }
02601     } else 
02602 #endif      
02603     {
02604       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
02605       if (otype) {
02606         PyObject *str = PyObject_Str(obj);
02607         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
02608         if (cstr) {
02609           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02610                        type, otype, cstr);
02611           SWIG_Python_str_DelForPy3(cstr);
02612         } else {
02613           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02614                        type, otype);
02615         }
02616         Py_XDECREF(str);
02617         return;
02618       }
02619     }   
02620     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02621   } else {
02622     PyErr_Format(PyExc_TypeError, "unexpected type is received");
02623   }
02624 }
02625 
02626 
02627 /* Convert a pointer value, signal an exception on a type mismatch */
02628 SWIGRUNTIME void *
02629 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
02630   void *result;
02631   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02632     PyErr_Clear();
02633 #if SWIG_POINTER_EXCEPTION
02634     if (flags) {
02635       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02636       SWIG_Python_ArgFail(argnum);
02637     }
02638 #endif
02639   }
02640   return result;
02641 }
02642 
02643 
02644 #ifdef __cplusplus
02645 #if 0
02646 { /* cc-mode */
02647 #endif
02648 }
02649 #endif
02650 
02651 
02652 
02653 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
02654 
02655 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
02656 
02657 
02658 
02659 /* -------- TYPES TABLE (BEGIN) -------- */
02660 
02661 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
02662 #define SWIGTYPE_p_PLcGrid swig_types[1]
02663 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
02664 #define SWIGTYPE_p_char swig_types[3]
02665 #define SWIGTYPE_p_double swig_types[4]
02666 #define SWIGTYPE_p_f_double_double__int swig_types[5]
02667 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
02668 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
02669 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
02670 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
02671 #define SWIGTYPE_p_int swig_types[10]
02672 #define SWIGTYPE_p_p_char swig_types[11]
02673 #define SWIGTYPE_p_p_double swig_types[12]
02674 #define SWIGTYPE_p_unsigned_int swig_types[13]
02675 static swig_type_info *swig_types[15];
02676 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
02677 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02678 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02679 
02680 /* -------- TYPES TABLE (END) -------- */
02681 
02682 #if (PY_VERSION_HEX <= 0x02000000)
02683 # if !defined(SWIG_PYTHON_CLASSIC)
02684 #  error "This python version requires swig to be run with the '-classic' option"
02685 # endif
02686 #endif
02687 
02688 /*-----------------------------------------------
02689               @(target):= _plplotc.so
02690   ------------------------------------------------*/
02691 #if PY_VERSION_HEX >= 0x03000000
02692 #  define SWIG_init    PyInit__plplotc
02693 
02694 #else
02695 #  define SWIG_init    init_plplotc
02696 
02697 #endif
02698 #define SWIG_name    "_plplotc"
02699 
02700 #define SWIGVERSION 0x010340 
02701 #define SWIG_VERSION SWIGVERSION
02702 
02703 
02704 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
02705 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
02706 
02707 
02708 // Change this to the recommended
02709 //#include <Numeric/arrayobject.h>
02710 // once we no longer support python1.5
02711 #include <arrayobject.h>
02712 #include "plplot.h"
02713 #include "plplotP.h"
02714 
02715 #ifdef PL_DOUBLE
02716 #define  PyArray_PLFLT    PyArray_DOUBLE
02717 #else
02718 #define  PyArray_PLFLT    PyArray_FLOAT
02719 #endif
02720 
02721 #ifdef HAVE_NUMPY
02722 #define  PyArray_PLINT    PyArray_INT32
02723 
02724 #ifdef PL_DOUBLE
02725 #define  NPY_PLFLT        NPY_DOUBLE
02726 #else
02727 #define  NPY_PLFLT        NPY_FLOAT
02728 #endif
02729 
02730 #else  // HAVE_NUMPY
02731 #define  PyArray_PLINT    PyArray_INT
02732 #endif
02733 // python-1.5 compatibility mode?
02734 #if !defined ( PySequence_Fast_GET_ITEM )
02735   #define PySequence_Fast_GET_ITEM    PySequence_GetItem
02736 #endif
02737 #define PySequence_Size               PySequence_Length
02738 
02739 
02740     static PLINT Alen = 0;
02741     static PLINT Xlen = 0, Ylen = 0;
02742 
02743 
02744 SWIGINTERN int
02745 SWIG_AsVal_double (PyObject *obj, double *val)
02746 {
02747   int res = SWIG_TypeError;
02748   if (PyFloat_Check(obj)) {
02749     if (val) *val = PyFloat_AsDouble(obj);
02750     return SWIG_OK;
02751   } else if (PyInt_Check(obj)) {
02752     if (val) *val = PyInt_AsLong(obj);
02753     return SWIG_OK;
02754   } else if (PyLong_Check(obj)) {
02755     double v = PyLong_AsDouble(obj);
02756     if (!PyErr_Occurred()) {
02757       if (val) *val = v;
02758       return SWIG_OK;
02759     } else {
02760       PyErr_Clear();
02761     }
02762   }
02763 #ifdef SWIG_PYTHON_CAST_MODE
02764   {
02765     int dispatch = 0;
02766     double d = PyFloat_AsDouble(obj);
02767     if (!PyErr_Occurred()) {
02768       if (val) *val = d;
02769       return SWIG_AddCast(SWIG_OK);
02770     } else {
02771       PyErr_Clear();
02772     }
02773     if (!dispatch) {
02774       long v = PyLong_AsLong(obj);
02775       if (!PyErr_Occurred()) {
02776         if (val) *val = v;
02777         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
02778       } else {
02779         PyErr_Clear();
02780       }
02781     }
02782   }
02783 #endif
02784   return res;
02785 }
02786 
02787 
02788   #define SWIG_From_double   PyFloat_FromDouble 
02789 
02790 
02791     typedef PLINT ( *defined_func )( PLFLT, PLFLT );
02792     typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
02793     typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
02794     typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
02795     typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
02796     typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
02797     typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
02798 
02799 
02800   #define SWIG_From_long   PyInt_FromLong 
02801 
02802 
02803 SWIGINTERNINLINE PyObject *
02804 SWIG_From_int  (int value)
02805 {    
02806   return SWIG_From_long  (value);
02807 }
02808 
02809 
02810 #include <limits.h>
02811 #if !defined(SWIG_NO_LLONG_MAX)
02812 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
02813 #   define LLONG_MAX __LONG_LONG_MAX__
02814 #   define LLONG_MIN (-LLONG_MAX - 1LL)
02815 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
02816 # endif
02817 #endif
02818 
02819 
02820 #include <float.h>
02821 
02822 
02823 #include <math.h>
02824 
02825 
02826 SWIGINTERNINLINE int
02827 SWIG_CanCastAsInteger(double *d, double min, double max) {
02828   double x = *d;
02829   if ((min <= x && x <= max)) {
02830    double fx = floor(x);
02831    double cx = ceil(x);
02832    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
02833    if ((errno == EDOM) || (errno == ERANGE)) {
02834      errno = 0;
02835    } else {
02836      double summ, reps, diff;
02837      if (rd < x) {
02838        diff = x - rd;
02839      } else if (rd > x) {
02840        diff = rd - x;
02841      } else {
02842        return 1;
02843      }
02844      summ = rd + x;
02845      reps = diff/summ;
02846      if (reps < 8*DBL_EPSILON) {
02847        *d = rd;
02848        return 1;
02849      }
02850    }
02851   }
02852   return 0;
02853 }
02854 
02855 
02856 SWIGINTERN int
02857 SWIG_AsVal_long (PyObject *obj, long* val)
02858 {
02859   if (PyInt_Check(obj)) {
02860     if (val) *val = PyInt_AsLong(obj);
02861     return SWIG_OK;
02862   } else if (PyLong_Check(obj)) {
02863     long v = PyLong_AsLong(obj);
02864     if (!PyErr_Occurred()) {
02865       if (val) *val = v;
02866       return SWIG_OK;
02867     } else {
02868       PyErr_Clear();
02869     }
02870   }
02871 #ifdef SWIG_PYTHON_CAST_MODE
02872   {
02873     int dispatch = 0;
02874     long v = PyInt_AsLong(obj);
02875     if (!PyErr_Occurred()) {
02876       if (val) *val = v;
02877       return SWIG_AddCast(SWIG_OK);
02878     } else {
02879       PyErr_Clear();
02880     }
02881     if (!dispatch) {
02882       double d;
02883       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
02884       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
02885         if (val) *val = (long)(d);
02886         return res;
02887       }
02888     }
02889   }
02890 #endif
02891   return SWIG_TypeError;
02892 }
02893 
02894 
02895 SWIGINTERN int
02896 SWIG_AsVal_int (PyObject * obj, int *val)
02897 {
02898   long v;
02899   int res = SWIG_AsVal_long (obj, &v);
02900   if (SWIG_IsOK(res)) {
02901     if ((v < INT_MIN || v > INT_MAX)) {
02902       return SWIG_OverflowError;
02903     } else {
02904       if (val) *val = (int)(v);
02905     }
02906   }  
02907   return res;
02908 }
02909 
02910 
02911 SWIGINTERN int
02912 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
02913 {
02914   if (PyInt_Check(obj)) {
02915     long v = PyInt_AsLong(obj);
02916     if (v >= 0) {
02917       if (val) *val = v;
02918       return SWIG_OK;
02919     } else {
02920       return SWIG_OverflowError;
02921     }
02922   } else if (PyLong_Check(obj)) {
02923     unsigned long v = PyLong_AsUnsignedLong(obj);
02924     if (!PyErr_Occurred()) {
02925       if (val) *val = v;
02926       return SWIG_OK;
02927     } else {
02928       PyErr_Clear();
02929     }
02930   }
02931 #ifdef SWIG_PYTHON_CAST_MODE
02932   {
02933     int dispatch = 0;
02934     unsigned long v = PyLong_AsUnsignedLong(obj);
02935     if (!PyErr_Occurred()) {
02936       if (val) *val = v;
02937       return SWIG_AddCast(SWIG_OK);
02938     } else {
02939       PyErr_Clear();
02940     }
02941     if (!dispatch) {
02942       double d;
02943       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
02944       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
02945         if (val) *val = (unsigned long)(d);
02946         return res;
02947       }
02948     }
02949   }
02950 #endif
02951   return SWIG_TypeError;
02952 }
02953 
02954 
02955 SWIGINTERN int
02956 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
02957 {
02958   unsigned long v;
02959   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
02960   if (SWIG_IsOK(res)) {
02961     if ((v > UINT_MAX)) {
02962       return SWIG_OverflowError;
02963     } else {
02964       if (val) *val = (unsigned int)(v);
02965     }
02966   }  
02967   return res;
02968 }
02969 
02970 
02971 SWIGINTERNINLINE PyObject* 
02972 SWIG_From_unsigned_SS_long  (unsigned long value)
02973 {
02974   return (value > LONG_MAX) ?
02975     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); 
02976 }
02977 
02978 
02979 SWIGINTERNINLINE PyObject *
02980 SWIG_From_unsigned_SS_int  (unsigned int value)
02981 {    
02982   return SWIG_From_unsigned_SS_long  (value);
02983 }
02984 
02985 
02986 SWIGINTERN swig_type_info*
02987 SWIG_pchar_descriptor(void)
02988 {
02989   static int init = 0;
02990   static swig_type_info* info = 0;
02991   if (!init) {
02992     info = SWIG_TypeQuery("_p_char");
02993     init = 1;
02994   }
02995   return info;
02996 }
02997 
02998 
02999 SWIGINTERN int
03000 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
03001 {
03002 #if PY_VERSION_HEX>=0x03000000
03003   if (PyUnicode_Check(obj))
03004 #else  
03005   if (PyString_Check(obj))
03006 #endif
03007   {
03008     char *cstr; Py_ssize_t len;
03009 #if PY_VERSION_HEX>=0x03000000
03010     if (!alloc && cptr) {
03011         /* We can't allow converting without allocation, since the internal
03012            representation of string in Python 3 is UCS-2/UCS-4 but we require
03013            a UTF-8 representation.
03014            TODO(bhy) More detailed explanation */
03015         return SWIG_RuntimeError;
03016     }
03017     obj = PyUnicode_AsUTF8String(obj);
03018     PyBytes_AsStringAndSize(obj, &cstr, &len);
03019     if(alloc) *alloc = SWIG_NEWOBJ;
03020 #else
03021     PyString_AsStringAndSize(obj, &cstr, &len);
03022 #endif
03023     if (cptr) {
03024       if (alloc) {
03025         /* 
03026            In python the user should not be able to modify the inner
03027            string representation. To warranty that, if you define
03028            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
03029            buffer is always returned.
03030 
03031            The default behavior is just to return the pointer value,
03032            so, be careful.
03033         */ 
03034 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
03035         if (*alloc != SWIG_OLDOBJ) 
03036 #else
03037         if (*alloc == SWIG_NEWOBJ) 
03038 #endif
03039           {
03040             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
03041             *alloc = SWIG_NEWOBJ;
03042           }
03043         else {
03044           *cptr = cstr;
03045           *alloc = SWIG_OLDOBJ;
03046         }
03047       } else {
03048         #if PY_VERSION_HEX>=0x03000000
03049         assert(0); /* Should never reach here in Python 3 */
03050         #endif
03051         *cptr = SWIG_Python_str_AsChar(obj);
03052       }
03053     }
03054     if (psize) *psize = len + 1;
03055 #if PY_VERSION_HEX>=0x03000000
03056     Py_XDECREF(obj);
03057 #endif
03058     return SWIG_OK;
03059   } else {
03060     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03061     if (pchar_descriptor) {
03062       void* vptr = 0;
03063       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
03064         if (cptr) *cptr = (char *) vptr;
03065         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
03066         if (alloc) *alloc = SWIG_OLDOBJ;
03067         return SWIG_OK;
03068       }
03069     }
03070   }
03071   return SWIG_TypeError;
03072 }
03073 
03074 
03075 SWIGINTERN int
03076 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
03077 { 
03078   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
03079   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
03080   if (SWIG_IsOK(res)) {
03081     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
03082     if (csize <= size) {
03083       if (val) {
03084         if (csize) memcpy(val, cptr, csize*sizeof(char));
03085         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
03086       }
03087       if (alloc == SWIG_NEWOBJ) {
03088         free((char*)cptr);
03089         res = SWIG_DelNewMask(res);
03090       }      
03091       return res;
03092     }
03093     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
03094   }
03095   return SWIG_TypeError;
03096 }
03097 
03098 
03099 SWIGINTERNINLINE PyObject *
03100 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
03101 {
03102   if (carray) {
03103     if (size > INT_MAX) {
03104       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03105       return pchar_descriptor ? 
03106         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
03107     } else {
03108 #if PY_VERSION_HEX >= 0x03000000
03109       return PyUnicode_FromStringAndSize(carray, (int)(size));
03110 #else
03111       return PyString_FromStringAndSize(carray, (int)(size));
03112 #endif
03113     }
03114   } else {
03115     return SWIG_Py_Void();
03116   }
03117 }
03118 
03119 
03120 
03121 
03122 
03123 #define t_output_helper SWIG_Python_AppendOutput
03124 
03125 
03126 SWIGINTERN int
03127 SWIG_AsVal_char (PyObject * obj, char *val)
03128 {    
03129   int res = SWIG_AsCharArray(obj, val, 1);
03130   if (!SWIG_IsOK(res)) {
03131     long v;
03132     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
03133     if (SWIG_IsOK(res)) {
03134       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
03135         if (val) *val = (char)(v);
03136       } else {
03137         res = SWIG_OverflowError;
03138       }
03139     }
03140   }
03141   return res;
03142 }
03143 
03144 #ifdef __cplusplus
03145 extern "C" {
03146 #endif
03147 
03148 // some really twisted stuff to allow calling a single precision library from python
03149     PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims )
03150     {
03151         PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, PyArray_PLINT,
03152             mindims, maxdims );
03153         if ( !tmp )
03154         {
03155             // could be an incoming long array which can't be "safely" converted, do it anyway
03156             if ( PyArray_Check( in ) )
03157             {
03158                 PyErr_Clear();
03159                 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, PyArray_PLINT );
03160             }
03161         }
03162         return tmp;
03163     }
03164 
03165 
03166 #define myArray_ContiguousFromObject    PyArray_ContiguousFromObject
03167 
03168 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03169   PyObject *resultobj = 0;
03170   PLFLT arg1 ;
03171   PLFLT arg2 ;
03172   PLFLT *arg3 = (PLFLT *) 0 ;
03173   PLFLT *arg4 = (PLFLT *) 0 ;
03174   PLPointer arg5 = (PLPointer) 0 ;
03175   double val1 ;
03176   int ecode1 = 0 ;
03177   double val2 ;
03178   int ecode2 = 0 ;
03179   PLFLT temp3 ;
03180   int res3 = SWIG_TMPOBJ ;
03181   PLFLT temp4 ;
03182   int res4 = SWIG_TMPOBJ ;
03183   PyObject * obj0 = 0 ;
03184   PyObject * obj1 = 0 ;
03185   
03186   arg3 = &temp3;
03187   arg4 = &temp4;
03188   {
03189     arg5 = NULL;
03190   }
03191   if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
03192   ecode1 = SWIG_AsVal_double(obj0, &val1);
03193   if (!SWIG_IsOK(ecode1)) {
03194     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
03195   } 
03196   arg1 = (PLFLT)(val1);
03197   ecode2 = SWIG_AsVal_double(obj1, &val2);
03198   if (!SWIG_IsOK(ecode2)) {
03199     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
03200   } 
03201   arg2 = (PLFLT)(val2);
03202   pltr0(arg1,arg2,arg3,arg4,arg5);
03203   resultobj = SWIG_Py_Void();
03204   if (SWIG_IsTmpObj(res3)) {
03205     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03206   } else {
03207     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03208     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03209   }
03210   if (SWIG_IsTmpObj(res4)) {
03211     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03212   } else {
03213     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03214     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03215   }
03216   return resultobj;
03217 fail:
03218   return NULL;
03219 }
03220 
03221 
03222 
03223     PyArrayObject   *pltr_xg, *pltr_yg;
03224     static PLcGrid  tmpGrid1;
03225     static PLcGrid2 tmpGrid2;
03226 
03227     PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
03228     {
03229         // fprintf(stderr, "marshal PLcGrid1\n");
03230         if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03231         {
03232             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03233             return NULL;
03234         }
03235         pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03236             PyArray_PLFLT, 1, 1 );
03237         pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03238             PyArray_PLFLT, 1, 1 );
03239         if ( pltr_xg == 0 || pltr_yg == 0 )
03240         {
03241             PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
03242             return NULL;
03243         }
03244         tmpGrid1.nx = pltr_xg->dimensions[0];
03245         tmpGrid1.ny = pltr_yg->dimensions[0];
03246         if ( isimg == 0 )
03247         {
03248             if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
03249             {
03250                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03251                 return NULL;
03252             }
03253         }
03254         else
03255         {
03256             if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
03257             {
03258                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03259                 return NULL;
03260             }
03261         }
03262         tmpGrid1.xg = (PLFLT *) pltr_xg->data;
03263         tmpGrid1.yg = (PLFLT *) pltr_yg->data;
03264         return &tmpGrid1;
03265     }
03266 
03267     void cleanup_PLcGrid1( void )
03268     {
03269         // fprintf(stderr, "cleanup PLcGrid1\n");
03270         Py_DECREF( pltr_xg );
03271         Py_DECREF( pltr_yg );
03272     }
03273 
03274     PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
03275     {
03276         int i, size;
03277         // fprintf(stderr, "marshal PLcGrid2\n");
03278         if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03279         {
03280             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03281             return NULL;
03282         }
03283         pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03284             PyArray_PLFLT, 2, 2 );
03285         pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03286             PyArray_PLFLT, 2, 2 );
03287         if ( pltr_xg == 0 || pltr_yg == 0 )
03288         {
03289             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
03290             return NULL;
03291         }
03292         if ( pltr_xg->dimensions[0] != pltr_yg->dimensions[0] ||
03293              pltr_xg->dimensions[1] != pltr_yg->dimensions[1] )
03294         {
03295             PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
03296             return NULL;
03297         }
03298         tmpGrid2.nx = pltr_xg->dimensions[0];
03299         tmpGrid2.ny = pltr_xg->dimensions[1];
03300         if ( isimg == 0 )
03301         {
03302             if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
03303             {
03304                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03305                 return NULL;
03306             }
03307         }
03308         else
03309         {
03310             if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
03311             {
03312                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03313                 return NULL;
03314             }
03315         }
03316         size        = sizeof ( PLFLT ) * tmpGrid2.ny;
03317         tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
03318         for ( i = 0; i < tmpGrid2.nx; i++ )
03319             tmpGrid2.xg[i] = (PLFLT *) ( pltr_xg->data + i * size );
03320         tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * tmpGrid2.nx );
03321         for ( i = 0; i < tmpGrid2.nx; i++ )
03322             tmpGrid2.yg[i] = (PLFLT *) ( pltr_yg->data + i * size );
03323         return &tmpGrid2;
03324     }
03325 
03326     void cleanup_PLcGrid2( void )
03327     {
03328         // fprintf(stderr, "cleanup PLcGrid2\n");
03329         free( tmpGrid2.xg );
03330         free( tmpGrid2.yg );
03331         Py_DECREF( pltr_xg );
03332         Py_DECREF( pltr_yg );
03333     }
03334 
03335 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03336   PyObject *resultobj = 0;
03337   PLFLT arg1 ;
03338   PLFLT arg2 ;
03339   PLFLT *arg3 = (PLFLT *) 0 ;
03340   PLFLT *arg4 = (PLFLT *) 0 ;
03341   PLcGrid *arg5 = (PLcGrid *) 0 ;
03342   double val1 ;
03343   int ecode1 = 0 ;
03344   double val2 ;
03345   int ecode2 = 0 ;
03346   PLFLT temp3 ;
03347   int res3 = SWIG_TMPOBJ ;
03348   PLFLT temp4 ;
03349   int res4 = SWIG_TMPOBJ ;
03350   PyObject * obj0 = 0 ;
03351   PyObject * obj1 = 0 ;
03352   PyObject * obj2 = 0 ;
03353   
03354   arg3 = &temp3;
03355   arg4 = &temp4;
03356   if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
03357   ecode1 = SWIG_AsVal_double(obj0, &val1);
03358   if (!SWIG_IsOK(ecode1)) {
03359     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
03360   } 
03361   arg1 = (PLFLT)(val1);
03362   ecode2 = SWIG_AsVal_double(obj1, &val2);
03363   if (!SWIG_IsOK(ecode2)) {
03364     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
03365   } 
03366   arg2 = (PLFLT)(val2);
03367   {
03368     arg5 = marshal_PLcGrid1( obj2, 0 );
03369     if ( !arg5 )
03370     return NULL;
03371   }
03372   pltr1(arg1,arg2,arg3,arg4,arg5);
03373   resultobj = SWIG_Py_Void();
03374   if (SWIG_IsTmpObj(res3)) {
03375     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03376   } else {
03377     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03378     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03379   }
03380   if (SWIG_IsTmpObj(res4)) {
03381     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03382   } else {
03383     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03384     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03385   }
03386   {
03387     cleanup_PLcGrid1();
03388   }
03389   return resultobj;
03390 fail:
03391   {
03392     cleanup_PLcGrid1();
03393   }
03394   return NULL;
03395 }
03396 
03397 
03398 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03399   PyObject *resultobj = 0;
03400   PLFLT arg1 ;
03401   PLFLT arg2 ;
03402   PLFLT *arg3 = (PLFLT *) 0 ;
03403   PLFLT *arg4 = (PLFLT *) 0 ;
03404   PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
03405   double val1 ;
03406   int ecode1 = 0 ;
03407   double val2 ;
03408   int ecode2 = 0 ;
03409   PLFLT temp3 ;
03410   int res3 = SWIG_TMPOBJ ;
03411   PLFLT temp4 ;
03412   int res4 = SWIG_TMPOBJ ;
03413   PyObject * obj0 = 0 ;
03414   PyObject * obj1 = 0 ;
03415   PyObject * obj2 = 0 ;
03416   
03417   arg3 = &temp3;
03418   arg4 = &temp4;
03419   if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
03420   ecode1 = SWIG_AsVal_double(obj0, &val1);
03421   if (!SWIG_IsOK(ecode1)) {
03422     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
03423   } 
03424   arg1 = (PLFLT)(val1);
03425   ecode2 = SWIG_AsVal_double(obj1, &val2);
03426   if (!SWIG_IsOK(ecode2)) {
03427     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
03428   } 
03429   arg2 = (PLFLT)(val2);
03430   {
03431     arg5 = marshal_PLcGrid2( obj2, 0 );
03432     if ( !arg5 )
03433     return NULL;
03434   }
03435   pltr2(arg1,arg2,arg3,arg4,arg5);
03436   resultobj = SWIG_Py_Void();
03437   if (SWIG_IsTmpObj(res3)) {
03438     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03439   } else {
03440     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03441     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03442   }
03443   if (SWIG_IsTmpObj(res4)) {
03444     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03445   } else {
03446     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03447     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03448   }
03449   {
03450     cleanup_PLcGrid2();
03451   }
03452   return resultobj;
03453 fail:
03454   {
03455     cleanup_PLcGrid2();
03456   }
03457   return NULL;
03458 }
03459 
03460 
03461 
03462     // helper code for handling the callback
03463 #if 0
03464     static PyInterpreterState *save_interp = NULL;
03465 #endif
03466     enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type;
03467     PyObject* python_pltr    = NULL;
03468     PyObject* python_f2eval  = NULL;
03469     PyObject* python_ct      = NULL;
03470     PyObject* python_mapform = NULL;
03471     PyObject* python_label   = NULL;
03472 
03473 #if 0
03474 #define MY_BLOCK_THREADS    {                             \
03475         PyThreadState *prev_state, *new_state;            \
03476         /* need to have started a thread at some stage */ \
03477         /* for the following to work */                   \
03478         PyEval_AcquireLock();                             \
03479         new_state  = PyThreadState_New( save_interp );    \
03480         prev_state = PyThreadState_Swap( new_state );
03481 #define MY_UNBLOCK_THREADS                        \
03482     new_state = PyThreadState_Swap( prev_state ); \
03483     PyThreadState_Clear( new_state );             \
03484     PyEval_ReleaseLock();                         \
03485     PyThreadState_Delete( new_state );            \
03486     }
03487 #else
03488 #define MY_BLOCK_THREADS
03489 #define MY_UNBLOCK_THREADS
03490 #endif
03491 
03492 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
03493 
03494     void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
03495     {
03496         PyObject      *pdata, *arglist, *result;
03497         PyArrayObject *tmp;
03498 
03499         // the data argument is acutally a pointer to a python object
03500         pdata = (PyObject *) data;
03501         if ( data == NULL )
03502         {
03503             pdata = Py_None;
03504         }
03505         if ( python_pltr ) // if not something is terribly wrong
03506         {                  // hold a reference to the data object
03507             Py_XINCREF( pdata );
03508             // grab the Global Interpreter Lock to be sure threads don't mess us up
03509             MY_BLOCK_THREADS
03510             // build the argument list
03511 #ifdef PL_DOUBLE
03512             arglist = Py_BuildValue( "(ddO)", x, y, pdata );
03513 #else
03514             arglist = Py_BuildValue( "(ffO)", x, y, pdata );
03515 #endif
03516             if ( arglist == NULL )
03517             {
03518                 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
03519                 *tx = *ty = 0;
03520                 return;
03521             }
03522             // call the python function
03523             result = PyEval_CallObject( python_pltr, arglist );
03524             // release the argument list
03525             Py_XDECREF( arglist );
03526             // check and unpack the result
03527             if ( result == NULL )
03528             {
03529                 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
03530                 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
03531                 *tx = *ty = 0;
03532             }
03533             else
03534             {
03535                 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, PyArray_PLFLT, 1, 1 );
03536                 if ( tmp == 0 || tmp->dimensions[0] != 2 )
03537                 {
03538                     fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
03539                     PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
03540                     *tx = *ty = 0;
03541                 }
03542                 else
03543                 {
03544                     PLFLT* t = (PLFLT *) tmp->data;
03545                     *tx = t[0];
03546                     *ty = t[1];
03547                     Py_XDECREF( tmp );
03548                 }
03549             }
03550             // release the result
03551             Py_XDECREF( result );
03552             // release the global interpreter lock
03553             MY_UNBLOCK_THREADS
03554         }
03555     }
03556 
03557     PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
03558     {
03559         PyObject *pdata, *arglist, *result;
03560         PLFLT    fresult = 0.0;
03561 
03562         // the data argument is acutally a pointer to a python object
03563         pdata = (PyObject *) data;
03564         if ( python_f2eval ) // if not something is terribly wrong
03565         {                    // hold a reference to the data object
03566             Py_XINCREF( pdata );
03567             // grab the Global Interpreter Lock to be sure threads don't mess us up
03568             MY_BLOCK_THREADS
03569             // build the argument list
03570                 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
03571             // call the python function
03572             result = PyEval_CallObject( python_f2eval, arglist );
03573             // release the argument list
03574             Py_DECREF( arglist );
03575             // check and unpack the result
03576             if ( !PyFloat_Check( result ) )
03577             {
03578                 fprintf( stderr, "f2eval callback must return a float\n" );
03579                 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
03580             }
03581             else
03582             {
03583                 // should I test the type here?
03584                 fresult = (PLFLT) PyFloat_AsDouble( result );
03585             }
03586             // release the result
03587             Py_XDECREF( result );
03588             // release the global interpreter lock
03589             MY_UNBLOCK_THREADS
03590         }
03591         return fresult;
03592     }
03593 
03594     void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
03595     {
03596         PyObject *pdata, *arglist, *result;
03597         char     *pystring;
03598         PLFLT    fresult = 0.0;
03599 
03600         // the data argument is acutally a pointer to a python object
03601         if ( data )
03602             pdata = (PyObject *) data;
03603         else
03604             pdata = Py_None;
03605         if ( python_label ) // if not something is terribly wrong
03606         {                   // hold a reference to the data object
03607             Py_XINCREF( pdata );
03608             // grab the Global Interpreter Lock to be sure threads don't mess us up
03609             MY_BLOCK_THREADS
03610             // build the argument list
03611 #ifdef PL_DOUBLE
03612             arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
03613 #else
03614             arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
03615 #endif
03616             // call the python function
03617             result = PyEval_CallObject( python_label, arglist );
03618             // release the argument list
03619             //Py_DECREF(arglist);
03620             // check and unpack the result
03621             if ( result == NULL )
03622             {
03623                 fprintf( stderr, "label callback failed with 3 arguments\n" );
03624                 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
03625             }
03626             else if ( !PyString_Check( result ) )
03627             {
03628                 fprintf( stderr, "label callback must return a string\n" );
03629                 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
03630             }
03631             else
03632             {
03633                 // should I test the type here?
03634                 pystring = PyString_AsString( result );
03635                 strncpy( string, pystring, len );
03636             }
03637             // release the result
03638             Py_XDECREF( result );
03639             // release the global interpreter lock
03640             MY_UNBLOCK_THREADS
03641         }
03642     }
03643 
03644     void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
03645     {
03646         PyObject *px, *py, *pdata, *arglist, *result;
03647 #ifdef HAVE_NUMPY
03648         npy_intp n;
03649 #else
03650         PLINT    n;
03651 #endif
03652         n = 1;
03653 
03654         // the data argument is acutally a pointer to a python object
03655         pdata = (PyObject *) data;
03656         if ( data == NULL )
03657         {
03658             pdata = Py_None;
03659         }
03660         if ( python_ct ) // if not something is terribly wrong
03661         {                // hold a reference to the data object
03662             Py_XINCREF( pdata );
03663             // grab the Global Interpreter Lock to be sure threads don't mess us up
03664             MY_BLOCK_THREADS
03665             // build the argument list
03666 #ifdef HAVE_NUMPY
03667             px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
03668             py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
03669 #else
03670             px = PyArray_FromDimsAndData( 1, &n, PyArray_PLFLT, (char *) xt );
03671             py = PyArray_FromDimsAndData( 1, &n, PyArray_PLFLT, (char *) yt );
03672 #endif
03673             arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
03674             // call the python function
03675             result = PyEval_CallObject( python_ct, arglist );
03676             // release the argument list
03677             Py_DECREF( arglist );
03678             Py_DECREF( px );
03679             Py_DECREF( py );
03680             Py_DECREF( pdata );
03681             // check and unpack the result
03682             if ( result == NULL )
03683             {
03684                 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
03685                 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
03686             }
03687             // release the result
03688             Py_XDECREF( result );
03689             // release the global interpreter lock
03690             MY_UNBLOCK_THREADS
03691         }
03692     }
03693 
03694     void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
03695     {
03696         PyObject *px, *py, *arglist, *result;
03697         // PyArrayObject *tmpx, *tmpy;
03698 //        PLFLT *xx, *yy;
03699 //        PLINT i;
03700 #ifdef HAVE_NUMPY
03701         npy_intp nn;
03702         nn = n;
03703 #endif
03704 
03705         if ( python_mapform ) // if not something is terribly wrong
03706         {                     // grab the Global Interpreter Lock to be sure threads don't mess us up
03707             MY_BLOCK_THREADS
03708             // build the argument list
03709 #ifdef PL_HAVE_PTHREAD
03710             px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
03711             py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
03712 #else
03713             px = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) x );
03714             py = PyArray_FromDimsAndData( 1, &n, PyArray_FLOAT, (char *) y );
03715 #endif
03716             arglist = Py_BuildValue( "(iOO)", n, px, py );
03717             // call the python function
03718             result = PyEval_CallObject( python_mapform, arglist );
03719             // release the argument list
03720             Py_DECREF( arglist );
03721             Py_DECREF( px );
03722             Py_DECREF( py );
03723             // check and unpack the result
03724             if ( result == NULL )
03725             {
03726                 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
03727                 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
03728             }
03729             // release the result
03730             Py_XDECREF( result );
03731             // release the global interpreter lock
03732             MY_UNBLOCK_THREADS
03733         }
03734     }
03735 
03736 // marshal the pltr function pointer argument
03737     pltr_func marshal_pltr( PyObject* input )
03738     {
03739         pltr_func result = do_pltr_callback;
03740         PyObject  * rep  = PyObject_Repr( input );
03741         if ( rep )
03742         {
03743             char* str = PyString_AsString( rep );
03744             if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
03745             {
03746                 result      = pltr0;
03747                 pltr_type   = CB_0;
03748                 python_pltr = NULL;
03749             }
03750             else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
03751             {
03752                 result      = pltr1;
03753                 pltr_type   = CB_1;
03754                 python_pltr = NULL;
03755             }
03756             else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
03757             {
03758                 result      = pltr2;
03759                 pltr_type   = CB_2;
03760                 python_pltr = NULL;
03761             }
03762             else
03763             {
03764                 python_pltr = input;
03765                 pltr_type   = CB_Python;
03766                 Py_XINCREF( input );
03767             }
03768             Py_DECREF( rep );
03769         }
03770         else
03771         {
03772             python_pltr = input;
03773             pltr_type   = CB_Python;
03774             Py_XINCREF( input );
03775         }
03776         return result;
03777     }
03778 
03779     void cleanup_pltr( void )
03780     {
03781         Py_XDECREF( python_pltr );
03782         python_pltr = 0;
03783     }
03784 
03785 // marshal the ct function pointer argument
03786     ct_func marshal_ct( PyObject* input )
03787     {
03788         ct_func result = do_ct_callback;
03789         python_ct = input;
03790         Py_XINCREF( input );
03791         return result;
03792     }
03793 
03794     void cleanup_ct( void )
03795     {
03796         Py_XDECREF( python_ct );
03797         python_ct = 0;
03798     }
03799 
03800 // marshal the mapform function pointer argument
03801     mapform_func marshal_mapform( PyObject* input )
03802     {
03803         mapform_func result = do_mapform_callback;
03804         python_mapform = input;
03805         Py_XINCREF( input );
03806         return result;
03807     }
03808 
03809     void cleanup_mapform( void )
03810     {
03811         Py_XDECREF( python_mapform );
03812         python_mapform = 0;
03813     }
03814 
03815     PLPointer marshal_PLPointer( PyObject* input, int isimg )
03816     {
03817         PLPointer result = NULL;
03818         switch ( pltr_type )
03819         {
03820         case CB_0:
03821             break;
03822         case CB_1:
03823             if ( input != Py_None )
03824                 result = marshal_PLcGrid1( input, isimg );
03825             break;
03826         case CB_2:
03827             if ( input != Py_None )
03828                 result = marshal_PLcGrid2( input, isimg );
03829             break;
03830         case CB_Python:
03831             Py_XINCREF( input );
03832             result = (PLPointer *) input;
03833             break;
03834         default:
03835             fprintf( stderr, "pltr_type is invalid\n" );
03836         }
03837         return result;
03838     }
03839 
03840     void cleanup_PLPointer( void )
03841     {
03842         switch ( pltr_type )
03843         {
03844         case CB_0:
03845             break;
03846         case CB_1:
03847             cleanup_PLcGrid1();
03848             break;
03849         case CB_2:
03850             cleanup_PLcGrid2();
03851             break;
03852         case CB_Python:
03853             Py_XDECREF( python_pltr );
03854             break;
03855         default:
03856             fprintf( stderr, "pltr_type is invalid\n" );
03857         }
03858         python_pltr = 0;
03859         pltr_type   = CB_0;
03860     }
03861 
03862 
03863 
03864 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03865   PyObject *resultobj = 0;
03866   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03867   int arg2 ;
03868   void *argp1 = 0 ;
03869   int res1 = 0 ;
03870   int val2 ;
03871   int ecode2 = 0 ;
03872   PyObject * obj0 = 0 ;
03873   PyObject * obj1 = 0 ;
03874   
03875   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
03876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
03877   if (!SWIG_IsOK(res1)) {
03878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
03879   }
03880   arg1 = (PLGraphicsIn *)(argp1);
03881   ecode2 = SWIG_AsVal_int(obj1, &val2);
03882   if (!SWIG_IsOK(ecode2)) {
03883     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
03884   } 
03885   arg2 = (int)(val2);
03886   if (arg1) (arg1)->type = arg2;
03887   resultobj = SWIG_Py_Void();
03888   return resultobj;
03889 fail:
03890   return NULL;
03891 }
03892 
03893 
03894 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03895   PyObject *resultobj = 0;
03896   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03897   void *argp1 = 0 ;
03898   int res1 = 0 ;
03899   PyObject * obj0 = 0 ;
03900   int result;
03901   
03902   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
03903   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
03904   if (!SWIG_IsOK(res1)) {
03905     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
03906   }
03907   arg1 = (PLGraphicsIn *)(argp1);
03908   result = (int) ((arg1)->type);
03909   resultobj = SWIG_From_int((int)(result));
03910   return resultobj;
03911 fail:
03912   return NULL;
03913 }
03914 
03915 
03916 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03917   PyObject *resultobj = 0;
03918   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03919   unsigned int arg2 ;
03920   void *argp1 = 0 ;
03921   int res1 = 0 ;
03922   unsigned int val2 ;
03923   int ecode2 = 0 ;
03924   PyObject * obj0 = 0 ;
03925   PyObject * obj1 = 0 ;
03926   
03927   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
03928   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
03929   if (!SWIG_IsOK(res1)) {
03930     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
03931   }
03932   arg1 = (PLGraphicsIn *)(argp1);
03933   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
03934   if (!SWIG_IsOK(ecode2)) {
03935     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
03936   } 
03937   arg2 = (unsigned int)(val2);
03938   if (arg1) (arg1)->state = arg2;
03939   resultobj = SWIG_Py_Void();
03940   return resultobj;
03941 fail:
03942   return NULL;
03943 }
03944 
03945 
03946 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03947   PyObject *resultobj = 0;
03948   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03949   void *argp1 = 0 ;
03950   int res1 = 0 ;
03951   PyObject * obj0 = 0 ;
03952   unsigned int result;
03953   
03954   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
03955   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
03956   if (!SWIG_IsOK(res1)) {
03957     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
03958   }
03959   arg1 = (PLGraphicsIn *)(argp1);
03960   result = (unsigned int) ((arg1)->state);
03961   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
03962   return resultobj;
03963 fail:
03964   return NULL;
03965 }
03966 
03967 
03968 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03969   PyObject *resultobj = 0;
03970   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
03971   unsigned int arg2 ;
03972   void *argp1 = 0 ;
03973   int res1 = 0 ;
03974   unsigned int val2 ;
03975   int ecode2 = 0 ;
03976   PyObject * obj0 = 0 ;
03977   PyObject * obj1 = 0 ;
03978   
03979   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
03980   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
03981   if (!SWIG_IsOK(res1)) {
03982     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
03983   }
03984   arg1 = (PLGraphicsIn *)(argp1);
03985   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
03986   if (!SWIG_IsOK(ecode2)) {
03987     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
03988   } 
03989   arg2 = (unsigned int)(val2);
03990   if (arg1) (arg1)->keysym = arg2;
03991   resultobj = SWIG_Py_Void();
03992   return resultobj;
03993 fail:
03994   return NULL;
03995 }
03996 
03997 
03998 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03999   PyObject *resultobj = 0;
04000   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04001   void *argp1 = 0 ;
04002   int res1 = 0 ;
04003   PyObject * obj0 = 0 ;
04004   unsigned int result;
04005   
04006   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
04007   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04008   if (!SWIG_IsOK(res1)) {
04009     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04010   }
04011   arg1 = (PLGraphicsIn *)(argp1);
04012   result = (unsigned int) ((arg1)->keysym);
04013   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04014   return resultobj;
04015 fail:
04016   return NULL;
04017 }
04018 
04019 
04020 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04021   PyObject *resultobj = 0;
04022   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04023   unsigned int arg2 ;
04024   void *argp1 = 0 ;
04025   int res1 = 0 ;
04026   unsigned int val2 ;
04027   int ecode2 = 0 ;
04028   PyObject * obj0 = 0 ;
04029   PyObject * obj1 = 0 ;
04030   
04031   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
04032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04033   if (!SWIG_IsOK(res1)) {
04034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04035   }
04036   arg1 = (PLGraphicsIn *)(argp1);
04037   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
04038   if (!SWIG_IsOK(ecode2)) {
04039     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
04040   } 
04041   arg2 = (unsigned int)(val2);
04042   if (arg1) (arg1)->button = arg2;
04043   resultobj = SWIG_Py_Void();
04044   return resultobj;
04045 fail:
04046   return NULL;
04047 }
04048 
04049 
04050 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04051   PyObject *resultobj = 0;
04052   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04053   void *argp1 = 0 ;
04054   int res1 = 0 ;
04055   PyObject * obj0 = 0 ;
04056   unsigned int result;
04057   
04058   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
04059   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04060   if (!SWIG_IsOK(res1)) {
04061     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04062   }
04063   arg1 = (PLGraphicsIn *)(argp1);
04064   result = (unsigned int) ((arg1)->button);
04065   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04066   return resultobj;
04067 fail:
04068   return NULL;
04069 }
04070 
04071 
04072 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04073   PyObject *resultobj = 0;
04074   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04075   PLINT arg2 ;
04076   void *argp1 = 0 ;
04077   int res1 = 0 ;
04078   int val2 ;
04079   int ecode2 = 0 ;
04080   PyObject * obj0 = 0 ;
04081   PyObject * obj1 = 0 ;
04082   
04083   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
04084   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04085   if (!SWIG_IsOK(res1)) {
04086     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04087   }
04088   arg1 = (PLGraphicsIn *)(argp1);
04089   ecode2 = SWIG_AsVal_int(obj1, &val2);
04090   if (!SWIG_IsOK(ecode2)) {
04091     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
04092   } 
04093   arg2 = (PLINT)(val2);
04094   if (arg1) (arg1)->subwindow = arg2;
04095   resultobj = SWIG_Py_Void();
04096   return resultobj;
04097 fail:
04098   return NULL;
04099 }
04100 
04101 
04102 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04103   PyObject *resultobj = 0;
04104   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04105   void *argp1 = 0 ;
04106   int res1 = 0 ;
04107   PyObject * obj0 = 0 ;
04108   PLINT result;
04109   
04110   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
04111   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04112   if (!SWIG_IsOK(res1)) {
04113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04114   }
04115   arg1 = (PLGraphicsIn *)(argp1);
04116   result = (PLINT) ((arg1)->subwindow);
04117   resultobj = SWIG_From_int((int)(result));
04118   return resultobj;
04119 fail:
04120   return NULL;
04121 }
04122 
04123 
04124 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04125   PyObject *resultobj = 0;
04126   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04127   char *arg2 ;
04128   void *argp1 = 0 ;
04129   int res1 = 0 ;
04130   char temp2[16] ;
04131   int res2 ;
04132   PyObject * obj0 = 0 ;
04133   PyObject * obj1 = 0 ;
04134   
04135   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
04136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04137   if (!SWIG_IsOK(res1)) {
04138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04139   }
04140   arg1 = (PLGraphicsIn *)(argp1);
04141   res2 = SWIG_AsCharArray(obj1, temp2, 16);
04142   if (!SWIG_IsOK(res2)) {
04143     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
04144   }
04145   arg2 = (char *)(temp2);
04146   if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
04147   else memset(arg1->string,0,16*sizeof(char));
04148   resultobj = SWIG_Py_Void();
04149   return resultobj;
04150 fail:
04151   return NULL;
04152 }
04153 
04154 
04155 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04156   PyObject *resultobj = 0;
04157   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04158   void *argp1 = 0 ;
04159   int res1 = 0 ;
04160   PyObject * obj0 = 0 ;
04161   char *result = 0 ;
04162   
04163   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
04164   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04165   if (!SWIG_IsOK(res1)) {
04166     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04167   }
04168   arg1 = (PLGraphicsIn *)(argp1);
04169   result = (char *)(char *) ((arg1)->string);
04170   {
04171     size_t size = 16;
04172     
04173     while (size && (result[size - 1] == '\0')) --size;
04174     
04175     resultobj = SWIG_FromCharPtrAndSize(result, size);
04176   }
04177   return resultobj;
04178 fail:
04179   return NULL;
04180 }
04181 
04182 
04183 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04184   PyObject *resultobj = 0;
04185   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04186   int arg2 ;
04187   void *argp1 = 0 ;
04188   int res1 = 0 ;
04189   int val2 ;
04190   int ecode2 = 0 ;
04191   PyObject * obj0 = 0 ;
04192   PyObject * obj1 = 0 ;
04193   
04194   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
04195   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04196   if (!SWIG_IsOK(res1)) {
04197     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04198   }
04199   arg1 = (PLGraphicsIn *)(argp1);
04200   ecode2 = SWIG_AsVal_int(obj1, &val2);
04201   if (!SWIG_IsOK(ecode2)) {
04202     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
04203   } 
04204   arg2 = (int)(val2);
04205   if (arg1) (arg1)->pX = arg2;
04206   resultobj = SWIG_Py_Void();
04207   return resultobj;
04208 fail:
04209   return NULL;
04210 }
04211 
04212 
04213 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04214   PyObject *resultobj = 0;
04215   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04216   void *argp1 = 0 ;
04217   int res1 = 0 ;
04218   PyObject * obj0 = 0 ;
04219   int result;
04220   
04221   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
04222   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04223   if (!SWIG_IsOK(res1)) {
04224     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04225   }
04226   arg1 = (PLGraphicsIn *)(argp1);
04227   result = (int) ((arg1)->pX);
04228   resultobj = SWIG_From_int((int)(result));
04229   return resultobj;
04230 fail:
04231   return NULL;
04232 }
04233 
04234 
04235 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04236   PyObject *resultobj = 0;
04237   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04238   int arg2 ;
04239   void *argp1 = 0 ;
04240   int res1 = 0 ;
04241   int val2 ;
04242   int ecode2 = 0 ;
04243   PyObject * obj0 = 0 ;
04244   PyObject * obj1 = 0 ;
04245   
04246   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
04247   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04248   if (!SWIG_IsOK(res1)) {
04249     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04250   }
04251   arg1 = (PLGraphicsIn *)(argp1);
04252   ecode2 = SWIG_AsVal_int(obj1, &val2);
04253   if (!SWIG_IsOK(ecode2)) {
04254     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
04255   } 
04256   arg2 = (int)(val2);
04257   if (arg1) (arg1)->pY = arg2;
04258   resultobj = SWIG_Py_Void();
04259   return resultobj;
04260 fail:
04261   return NULL;
04262 }
04263 
04264 
04265 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04266   PyObject *resultobj = 0;
04267   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04268   void *argp1 = 0 ;
04269   int res1 = 0 ;
04270   PyObject * obj0 = 0 ;
04271   int result;
04272   
04273   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
04274   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04275   if (!SWIG_IsOK(res1)) {
04276     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04277   }
04278   arg1 = (PLGraphicsIn *)(argp1);
04279   result = (int) ((arg1)->pY);
04280   resultobj = SWIG_From_int((int)(result));
04281   return resultobj;
04282 fail:
04283   return NULL;
04284 }
04285 
04286 
04287 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04288   PyObject *resultobj = 0;
04289   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04290   PLFLT arg2 ;
04291   void *argp1 = 0 ;
04292   int res1 = 0 ;
04293   double val2 ;
04294   int ecode2 = 0 ;
04295   PyObject * obj0 = 0 ;
04296   PyObject * obj1 = 0 ;
04297   
04298   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
04299   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04300   if (!SWIG_IsOK(res1)) {
04301     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04302   }
04303   arg1 = (PLGraphicsIn *)(argp1);
04304   ecode2 = SWIG_AsVal_double(obj1, &val2);
04305   if (!SWIG_IsOK(ecode2)) {
04306     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
04307   } 
04308   arg2 = (PLFLT)(val2);
04309   if (arg1) (arg1)->dX = arg2;
04310   resultobj = SWIG_Py_Void();
04311   return resultobj;
04312 fail:
04313   return NULL;
04314 }
04315 
04316 
04317 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04318   PyObject *resultobj = 0;
04319   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04320   void *argp1 = 0 ;
04321   int res1 = 0 ;
04322   PyObject * obj0 = 0 ;
04323   PLFLT result;
04324   
04325   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
04326   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04327   if (!SWIG_IsOK(res1)) {
04328     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04329   }
04330   arg1 = (PLGraphicsIn *)(argp1);
04331   result = (PLFLT) ((arg1)->dX);
04332   resultobj = SWIG_From_double((double)(result));
04333   return resultobj;
04334 fail:
04335   return NULL;
04336 }
04337 
04338 
04339 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04340   PyObject *resultobj = 0;
04341   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04342   PLFLT arg2 ;
04343   void *argp1 = 0 ;
04344   int res1 = 0 ;
04345   double val2 ;
04346   int ecode2 = 0 ;
04347   PyObject * obj0 = 0 ;
04348   PyObject * obj1 = 0 ;
04349   
04350   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
04351   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04352   if (!SWIG_IsOK(res1)) {
04353     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04354   }
04355   arg1 = (PLGraphicsIn *)(argp1);
04356   ecode2 = SWIG_AsVal_double(obj1, &val2);
04357   if (!SWIG_IsOK(ecode2)) {
04358     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
04359   } 
04360   arg2 = (PLFLT)(val2);
04361   if (arg1) (arg1)->dY = arg2;
04362   resultobj = SWIG_Py_Void();
04363   return resultobj;
04364 fail:
04365   return NULL;
04366 }
04367 
04368 
04369 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04370   PyObject *resultobj = 0;
04371   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04372   void *argp1 = 0 ;
04373   int res1 = 0 ;
04374   PyObject * obj0 = 0 ;
04375   PLFLT result;
04376   
04377   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
04378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04379   if (!SWIG_IsOK(res1)) {
04380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04381   }
04382   arg1 = (PLGraphicsIn *)(argp1);
04383   result = (PLFLT) ((arg1)->dY);
04384   resultobj = SWIG_From_double((double)(result));
04385   return resultobj;
04386 fail:
04387   return NULL;
04388 }
04389 
04390 
04391 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04392   PyObject *resultobj = 0;
04393   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04394   PLFLT arg2 ;
04395   void *argp1 = 0 ;
04396   int res1 = 0 ;
04397   double val2 ;
04398   int ecode2 = 0 ;
04399   PyObject * obj0 = 0 ;
04400   PyObject * obj1 = 0 ;
04401   
04402   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
04403   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04404   if (!SWIG_IsOK(res1)) {
04405     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04406   }
04407   arg1 = (PLGraphicsIn *)(argp1);
04408   ecode2 = SWIG_AsVal_double(obj1, &val2);
04409   if (!SWIG_IsOK(ecode2)) {
04410     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
04411   } 
04412   arg2 = (PLFLT)(val2);
04413   if (arg1) (arg1)->wX = arg2;
04414   resultobj = SWIG_Py_Void();
04415   return resultobj;
04416 fail:
04417   return NULL;
04418 }
04419 
04420 
04421 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04422   PyObject *resultobj = 0;
04423   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04424   void *argp1 = 0 ;
04425   int res1 = 0 ;
04426   PyObject * obj0 = 0 ;
04427   PLFLT result;
04428   
04429   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
04430   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04431   if (!SWIG_IsOK(res1)) {
04432     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04433   }
04434   arg1 = (PLGraphicsIn *)(argp1);
04435   result = (PLFLT) ((arg1)->wX);
04436   resultobj = SWIG_From_double((double)(result));
04437   return resultobj;
04438 fail:
04439   return NULL;
04440 }
04441 
04442 
04443 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04444   PyObject *resultobj = 0;
04445   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04446   PLFLT arg2 ;
04447   void *argp1 = 0 ;
04448   int res1 = 0 ;
04449   double val2 ;
04450   int ecode2 = 0 ;
04451   PyObject * obj0 = 0 ;
04452   PyObject * obj1 = 0 ;
04453   
04454   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
04455   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04456   if (!SWIG_IsOK(res1)) {
04457     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04458   }
04459   arg1 = (PLGraphicsIn *)(argp1);
04460   ecode2 = SWIG_AsVal_double(obj1, &val2);
04461   if (!SWIG_IsOK(ecode2)) {
04462     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
04463   } 
04464   arg2 = (PLFLT)(val2);
04465   if (arg1) (arg1)->wY = arg2;
04466   resultobj = SWIG_Py_Void();
04467   return resultobj;
04468 fail:
04469   return NULL;
04470 }
04471 
04472 
04473 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04474   PyObject *resultobj = 0;
04475   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04476   void *argp1 = 0 ;
04477   int res1 = 0 ;
04478   PyObject * obj0 = 0 ;
04479   PLFLT result;
04480   
04481   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
04482   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04483   if (!SWIG_IsOK(res1)) {
04484     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04485   }
04486   arg1 = (PLGraphicsIn *)(argp1);
04487   result = (PLFLT) ((arg1)->wY);
04488   resultobj = SWIG_From_double((double)(result));
04489   return resultobj;
04490 fail:
04491   return NULL;
04492 }
04493 
04494 
04495 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04496   PyObject *resultobj = 0;
04497   PLGraphicsIn *result = 0 ;
04498   
04499   if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
04500   result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
04501   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW |  0 );
04502   return resultobj;
04503 fail:
04504   return NULL;
04505 }
04506 
04507 
04508 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04509   PyObject *resultobj = 0;
04510   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04511   void *argp1 = 0 ;
04512   int res1 = 0 ;
04513   PyObject * obj0 = 0 ;
04514   
04515   if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
04516   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN |  0 );
04517   if (!SWIG_IsOK(res1)) {
04518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04519   }
04520   arg1 = (PLGraphicsIn *)(argp1);
04521   free((char *) arg1);
04522   resultobj = SWIG_Py_Void();
04523   return resultobj;
04524 fail:
04525   return NULL;
04526 }
04527 
04528 
04529 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04530   PyObject *obj;
04531   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04532   SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj));
04533   return SWIG_Py_Void();
04534 }
04535 
04536 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04537   PyObject *resultobj = 0;
04538   PLINT arg1 ;
04539   int val1 ;
04540   int ecode1 = 0 ;
04541   PyObject * obj0 = 0 ;
04542   
04543   if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
04544   ecode1 = SWIG_AsVal_int(obj0, &val1);
04545   if (!SWIG_IsOK(ecode1)) {
04546     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
04547   } 
04548   arg1 = (PLINT)(val1);
04549   plsxwin(arg1);
04550   resultobj = SWIG_Py_Void();
04551   return resultobj;
04552 fail:
04553   return NULL;
04554 }
04555 
04556 
04557 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04558   PyObject *resultobj = 0;
04559   PLINT arg1 ;
04560   PLINT arg2 ;
04561   int val1 ;
04562   int ecode1 = 0 ;
04563   int val2 ;
04564   int ecode2 = 0 ;
04565   PyObject * obj0 = 0 ;
04566   PyObject * obj1 = 0 ;
04567   
04568   if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
04569   ecode1 = SWIG_AsVal_int(obj0, &val1);
04570   if (!SWIG_IsOK(ecode1)) {
04571     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
04572   } 
04573   arg1 = (PLINT)(val1);
04574   ecode2 = SWIG_AsVal_int(obj1, &val2);
04575   if (!SWIG_IsOK(ecode2)) {
04576     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
04577   } 
04578   arg2 = (PLINT)(val2);
04579   pl_setcontlabelformat(arg1,arg2);
04580   resultobj = SWIG_Py_Void();
04581   return resultobj;
04582 fail:
04583   return NULL;
04584 }
04585 
04586 
04587 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04588   PyObject *resultobj = 0;
04589   PLFLT arg1 ;
04590   PLFLT arg2 ;
04591   PLFLT arg3 ;
04592   PLINT arg4 ;
04593   double val1 ;
04594   int ecode1 = 0 ;
04595   double val2 ;
04596   int ecode2 = 0 ;
04597   double val3 ;
04598   int ecode3 = 0 ;
04599   int val4 ;
04600   int ecode4 = 0 ;
04601   PyObject * obj0 = 0 ;
04602   PyObject * obj1 = 0 ;
04603   PyObject * obj2 = 0 ;
04604   PyObject * obj3 = 0 ;
04605   
04606   if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04607   ecode1 = SWIG_AsVal_double(obj0, &val1);
04608   if (!SWIG_IsOK(ecode1)) {
04609     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
04610   } 
04611   arg1 = (PLFLT)(val1);
04612   ecode2 = SWIG_AsVal_double(obj1, &val2);
04613   if (!SWIG_IsOK(ecode2)) {
04614     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
04615   } 
04616   arg2 = (PLFLT)(val2);
04617   ecode3 = SWIG_AsVal_double(obj2, &val3);
04618   if (!SWIG_IsOK(ecode3)) {
04619     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
04620   } 
04621   arg3 = (PLFLT)(val3);
04622   ecode4 = SWIG_AsVal_int(obj3, &val4);
04623   if (!SWIG_IsOK(ecode4)) {
04624     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
04625   } 
04626   arg4 = (PLINT)(val4);
04627   pl_setcontlabelparam(arg1,arg2,arg3,arg4);
04628   resultobj = SWIG_Py_Void();
04629   return resultobj;
04630 fail:
04631   return NULL;
04632 }
04633 
04634 
04635 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04636   PyObject *resultobj = 0;
04637   PLINT arg1 ;
04638   int val1 ;
04639   int ecode1 = 0 ;
04640   PyObject * obj0 = 0 ;
04641   
04642   if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
04643   ecode1 = SWIG_AsVal_int(obj0, &val1);
04644   if (!SWIG_IsOK(ecode1)) {
04645     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
04646   } 
04647   arg1 = (PLINT)(val1);
04648   pladv(arg1);
04649   resultobj = SWIG_Py_Void();
04650   return resultobj;
04651 fail:
04652   return NULL;
04653 }
04654 
04655 
04656 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04657   PyObject *resultobj = 0;
04658   PLFLT arg1 ;
04659   PLFLT arg2 ;
04660   PLFLT arg3 ;
04661   PLFLT arg4 ;
04662   PLFLT arg5 ;
04663   PLFLT arg6 ;
04664   PLFLT arg7 ;
04665   PLBOOL arg8 ;
04666   double val1 ;
04667   int ecode1 = 0 ;
04668   double val2 ;
04669   int ecode2 = 0 ;
04670   double val3 ;
04671   int ecode3 = 0 ;
04672   double val4 ;
04673   int ecode4 = 0 ;
04674   double val5 ;
04675   int ecode5 = 0 ;
04676   double val6 ;
04677   int ecode6 = 0 ;
04678   double val7 ;
04679   int ecode7 = 0 ;
04680   int val8 ;
04681   int ecode8 = 0 ;
04682   PyObject * obj0 = 0 ;
04683   PyObject * obj1 = 0 ;
04684   PyObject * obj2 = 0 ;
04685   PyObject * obj3 = 0 ;
04686   PyObject * obj4 = 0 ;
04687   PyObject * obj5 = 0 ;
04688   PyObject * obj6 = 0 ;
04689   PyObject * obj7 = 0 ;
04690   
04691   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
04692   ecode1 = SWIG_AsVal_double(obj0, &val1);
04693   if (!SWIG_IsOK(ecode1)) {
04694     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
04695   } 
04696   arg1 = (PLFLT)(val1);
04697   ecode2 = SWIG_AsVal_double(obj1, &val2);
04698   if (!SWIG_IsOK(ecode2)) {
04699     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
04700   } 
04701   arg2 = (PLFLT)(val2);
04702   ecode3 = SWIG_AsVal_double(obj2, &val3);
04703   if (!SWIG_IsOK(ecode3)) {
04704     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
04705   } 
04706   arg3 = (PLFLT)(val3);
04707   ecode4 = SWIG_AsVal_double(obj3, &val4);
04708   if (!SWIG_IsOK(ecode4)) {
04709     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
04710   } 
04711   arg4 = (PLFLT)(val4);
04712   ecode5 = SWIG_AsVal_double(obj4, &val5);
04713   if (!SWIG_IsOK(ecode5)) {
04714     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
04715   } 
04716   arg5 = (PLFLT)(val5);
04717   ecode6 = SWIG_AsVal_double(obj5, &val6);
04718   if (!SWIG_IsOK(ecode6)) {
04719     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
04720   } 
04721   arg6 = (PLFLT)(val6);
04722   ecode7 = SWIG_AsVal_double(obj6, &val7);
04723   if (!SWIG_IsOK(ecode7)) {
04724     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
04725   } 
04726   arg7 = (PLFLT)(val7);
04727   ecode8 = SWIG_AsVal_int(obj7, &val8);
04728   if (!SWIG_IsOK(ecode8)) {
04729     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
04730   } 
04731   arg8 = (PLBOOL)(val8);
04732   plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
04733   resultobj = SWIG_Py_Void();
04734   return resultobj;
04735 fail:
04736   return NULL;
04737 }
04738 
04739 
04740 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04741   PyObject *resultobj = 0;
04742   PLFLT arg1 ;
04743   PLFLT arg2 ;
04744   char *arg3 = (char *) 0 ;
04745   PLFLT arg4 ;
04746   PLINT arg5 ;
04747   char *arg6 = (char *) 0 ;
04748   PLFLT arg7 ;
04749   PLINT arg8 ;
04750   double val1 ;
04751   int ecode1 = 0 ;
04752   double val2 ;
04753   int ecode2 = 0 ;
04754   int res3 ;
04755   char *buf3 = 0 ;
04756   int alloc3 = 0 ;
04757   double val4 ;
04758   int ecode4 = 0 ;
04759   int val5 ;
04760   int ecode5 = 0 ;
04761   int res6 ;
04762   char *buf6 = 0 ;
04763   int alloc6 = 0 ;
04764   double val7 ;
04765   int ecode7 = 0 ;
04766   int val8 ;
04767   int ecode8 = 0 ;
04768   PyObject * obj0 = 0 ;
04769   PyObject * obj1 = 0 ;
04770   PyObject * obj2 = 0 ;
04771   PyObject * obj3 = 0 ;
04772   PyObject * obj4 = 0 ;
04773   PyObject * obj5 = 0 ;
04774   PyObject * obj6 = 0 ;
04775   PyObject * obj7 = 0 ;
04776   
04777   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
04778   ecode1 = SWIG_AsVal_double(obj0, &val1);
04779   if (!SWIG_IsOK(ecode1)) {
04780     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
04781   } 
04782   arg1 = (PLFLT)(val1);
04783   ecode2 = SWIG_AsVal_double(obj1, &val2);
04784   if (!SWIG_IsOK(ecode2)) {
04785     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
04786   } 
04787   arg2 = (PLFLT)(val2);
04788   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04789   if (!SWIG_IsOK(res3)) {
04790     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
04791   }
04792   arg3 = (char *)(buf3);
04793   ecode4 = SWIG_AsVal_double(obj3, &val4);
04794   if (!SWIG_IsOK(ecode4)) {
04795     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
04796   } 
04797   arg4 = (PLFLT)(val4);
04798   ecode5 = SWIG_AsVal_int(obj4, &val5);
04799   if (!SWIG_IsOK(ecode5)) {
04800     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
04801   } 
04802   arg5 = (PLINT)(val5);
04803   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
04804   if (!SWIG_IsOK(res6)) {
04805     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
04806   }
04807   arg6 = (char *)(buf6);
04808   ecode7 = SWIG_AsVal_double(obj6, &val7);
04809   if (!SWIG_IsOK(ecode7)) {
04810     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
04811   } 
04812   arg7 = (PLFLT)(val7);
04813   ecode8 = SWIG_AsVal_int(obj7, &val8);
04814   if (!SWIG_IsOK(ecode8)) {
04815     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
04816   } 
04817   arg8 = (PLINT)(val8);
04818   plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
04819   resultobj = SWIG_Py_Void();
04820   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
04821   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
04822   return resultobj;
04823 fail:
04824   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
04825   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
04826   return NULL;
04827 }
04828 
04829 
04830 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04831   PyObject *resultobj = 0;
04832   PLINT arg1 ;
04833   PLFLT *arg2 = (PLFLT *) 0 ;
04834   PLFLT *arg3 = (PLFLT *) 0 ;
04835   PLINT arg4 ;
04836   PyArrayObject *tmp1 ;
04837   PyArrayObject *tmp3 ;
04838   int val4 ;
04839   int ecode4 = 0 ;
04840   PyObject * obj0 = 0 ;
04841   PyObject * obj1 = 0 ;
04842   PyObject * obj2 = 0 ;
04843   
04844   if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
04845   {
04846     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
04847     if ( tmp1 == NULL )
04848     return NULL;
04849     arg1 = Alen = tmp1->dimensions[0];
04850     arg2 = (PLFLT *) tmp1->data;
04851   }
04852   {
04853     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
04854     if ( tmp3 == NULL )
04855     return NULL;
04856     if ( tmp3->dimensions[0] != Alen )
04857     {
04858       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
04859       return NULL;
04860     }
04861     arg3 = (PLFLT *) tmp3->data;
04862   }
04863   ecode4 = SWIG_AsVal_int(obj2, &val4);
04864   if (!SWIG_IsOK(ecode4)) {
04865     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
04866   } 
04867   arg4 = (PLINT)(val4);
04868   plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
04869   resultobj = SWIG_Py_Void();
04870   {
04871     Py_DECREF( tmp1 );
04872   }
04873   {
04874     Py_DECREF( tmp3 );
04875   }
04876   return resultobj;
04877 fail:
04878   {
04879     Py_DECREF( tmp1 );
04880   }
04881   {
04882     Py_DECREF( tmp3 );
04883   }
04884   return NULL;
04885 }
04886 
04887 
04888 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04889   PyObject *resultobj = 0;
04890   PLINT *arg1 = (PLINT *) 0 ;
04891   PLINT *arg2 = (PLINT *) 0 ;
04892   PLINT *arg3 = (PLINT *) 0 ;
04893   PLINT *arg4 = (PLINT *) 0 ;
04894   PLINT *arg5 = (PLINT *) 0 ;
04895   PLFLT *arg6 = (PLFLT *) 0 ;
04896   PLFLT arg7 ;
04897   PLINT temp1 ;
04898   int res1 = SWIG_TMPOBJ ;
04899   PLINT temp2 ;
04900   int res2 = SWIG_TMPOBJ ;
04901   PLINT temp3 ;
04902   int res3 = SWIG_TMPOBJ ;
04903   PLINT temp4 ;
04904   int res4 = SWIG_TMPOBJ ;
04905   PLINT temp5 ;
04906   int res5 = SWIG_TMPOBJ ;
04907   PLFLT temp6 ;
04908   int res6 = SWIG_TMPOBJ ;
04909   double val7 ;
04910   int ecode7 = 0 ;
04911   PyObject * obj0 = 0 ;
04912   
04913   arg1 = &temp1;
04914   arg2 = &temp2;
04915   arg3 = &temp3;
04916   arg4 = &temp4;
04917   arg5 = &temp5;
04918   arg6 = &temp6;
04919   if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
04920   ecode7 = SWIG_AsVal_double(obj0, &val7);
04921   if (!SWIG_IsOK(ecode7)) {
04922     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
04923   } 
04924   arg7 = (PLFLT)(val7);
04925   plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
04926   resultobj = SWIG_Py_Void();
04927   if (SWIG_IsTmpObj(res1)) {
04928     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
04929   } else {
04930     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04931     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
04932   }
04933   if (SWIG_IsTmpObj(res2)) {
04934     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
04935   } else {
04936     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04937     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
04938   }
04939   if (SWIG_IsTmpObj(res3)) {
04940     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
04941   } else {
04942     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04943     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
04944   }
04945   if (SWIG_IsTmpObj(res4)) {
04946     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
04947   } else {
04948     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04949     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
04950   }
04951   if (SWIG_IsTmpObj(res5)) {
04952     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
04953   } else {
04954     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04955     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
04956   }
04957   if (SWIG_IsTmpObj(res6)) {
04958     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
04959   } else {
04960     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
04961     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
04962   }
04963   return resultobj;
04964 fail:
04965   return NULL;
04966 }
04967 
04968 
04969 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04970   PyObject *resultobj = 0;
04971   
04972   if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
04973   plbop();
04974   resultobj = SWIG_Py_Void();
04975   return resultobj;
04976 fail:
04977   return NULL;
04978 }
04979 
04980 
04981 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04982   PyObject *resultobj = 0;
04983   char *arg1 = (char *) 0 ;
04984   PLFLT arg2 ;
04985   PLINT arg3 ;
04986   char *arg4 = (char *) 0 ;
04987   PLFLT arg5 ;
04988   PLINT arg6 ;
04989   int res1 ;
04990   char *buf1 = 0 ;
04991   int alloc1 = 0 ;
04992   double val2 ;
04993   int ecode2 = 0 ;
04994   int val3 ;
04995   int ecode3 = 0 ;
04996   int res4 ;
04997   char *buf4 = 0 ;
04998   int alloc4 = 0 ;
04999   double val5 ;
05000   int ecode5 = 0 ;
05001   int val6 ;
05002   int ecode6 = 0 ;
05003   PyObject * obj0 = 0 ;
05004   PyObject * obj1 = 0 ;
05005   PyObject * obj2 = 0 ;
05006   PyObject * obj3 = 0 ;
05007   PyObject * obj4 = 0 ;
05008   PyObject * obj5 = 0 ;
05009   
05010   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05011   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05012   if (!SWIG_IsOK(res1)) {
05013     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
05014   }
05015   arg1 = (char *)(buf1);
05016   ecode2 = SWIG_AsVal_double(obj1, &val2);
05017   if (!SWIG_IsOK(ecode2)) {
05018     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
05019   } 
05020   arg2 = (PLFLT)(val2);
05021   ecode3 = SWIG_AsVal_int(obj2, &val3);
05022   if (!SWIG_IsOK(ecode3)) {
05023     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
05024   } 
05025   arg3 = (PLINT)(val3);
05026   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
05027   if (!SWIG_IsOK(res4)) {
05028     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
05029   }
05030   arg4 = (char *)(buf4);
05031   ecode5 = SWIG_AsVal_double(obj4, &val5);
05032   if (!SWIG_IsOK(ecode5)) {
05033     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
05034   } 
05035   arg5 = (PLFLT)(val5);
05036   ecode6 = SWIG_AsVal_int(obj5, &val6);
05037   if (!SWIG_IsOK(ecode6)) {
05038     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
05039   } 
05040   arg6 = (PLINT)(val6);
05041   plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
05042   resultobj = SWIG_Py_Void();
05043   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05044   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05045   return resultobj;
05046 fail:
05047   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05048   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05049   return NULL;
05050 }
05051 
05052 
05053 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05054   PyObject *resultobj = 0;
05055   char *arg1 = (char *) 0 ;
05056   char *arg2 = (char *) 0 ;
05057   PLFLT arg3 ;
05058   PLINT arg4 ;
05059   char *arg5 = (char *) 0 ;
05060   char *arg6 = (char *) 0 ;
05061   PLFLT arg7 ;
05062   PLINT arg8 ;
05063   char *arg9 = (char *) 0 ;
05064   char *arg10 = (char *) 0 ;
05065   PLFLT arg11 ;
05066   PLINT arg12 ;
05067   int res1 ;
05068   char *buf1 = 0 ;
05069   int alloc1 = 0 ;
05070   int res2 ;
05071   char *buf2 = 0 ;
05072   int alloc2 = 0 ;
05073   double val3 ;
05074   int ecode3 = 0 ;
05075   int val4 ;
05076   int ecode4 = 0 ;
05077   int res5 ;
05078   char *buf5 = 0 ;
05079   int alloc5 = 0 ;
05080   int res6 ;
05081   char *buf6 = 0 ;
05082   int alloc6 = 0 ;
05083   double val7 ;
05084   int ecode7 = 0 ;
05085   int val8 ;
05086   int ecode8 = 0 ;
05087   int res9 ;
05088   char *buf9 = 0 ;
05089   int alloc9 = 0 ;
05090   int res10 ;
05091   char *buf10 = 0 ;
05092   int alloc10 = 0 ;
05093   double val11 ;
05094   int ecode11 = 0 ;
05095   int val12 ;
05096   int ecode12 = 0 ;
05097   PyObject * obj0 = 0 ;
05098   PyObject * obj1 = 0 ;
05099   PyObject * obj2 = 0 ;
05100   PyObject * obj3 = 0 ;
05101   PyObject * obj4 = 0 ;
05102   PyObject * obj5 = 0 ;
05103   PyObject * obj6 = 0 ;
05104   PyObject * obj7 = 0 ;
05105   PyObject * obj8 = 0 ;
05106   PyObject * obj9 = 0 ;
05107   PyObject * obj10 = 0 ;
05108   PyObject * obj11 = 0 ;
05109   
05110   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
05111   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05112   if (!SWIG_IsOK(res1)) {
05113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
05114   }
05115   arg1 = (char *)(buf1);
05116   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05117   if (!SWIG_IsOK(res2)) {
05118     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
05119   }
05120   arg2 = (char *)(buf2);
05121   ecode3 = SWIG_AsVal_double(obj2, &val3);
05122   if (!SWIG_IsOK(ecode3)) {
05123     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
05124   } 
05125   arg3 = (PLFLT)(val3);
05126   ecode4 = SWIG_AsVal_int(obj3, &val4);
05127   if (!SWIG_IsOK(ecode4)) {
05128     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
05129   } 
05130   arg4 = (PLINT)(val4);
05131   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
05132   if (!SWIG_IsOK(res5)) {
05133     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
05134   }
05135   arg5 = (char *)(buf5);
05136   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
05137   if (!SWIG_IsOK(res6)) {
05138     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
05139   }
05140   arg6 = (char *)(buf6);
05141   ecode7 = SWIG_AsVal_double(obj6, &val7);
05142   if (!SWIG_IsOK(ecode7)) {
05143     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
05144   } 
05145   arg7 = (PLFLT)(val7);
05146   ecode8 = SWIG_AsVal_int(obj7, &val8);
05147   if (!SWIG_IsOK(ecode8)) {
05148     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
05149   } 
05150   arg8 = (PLINT)(val8);
05151   res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
05152   if (!SWIG_IsOK(res9)) {
05153     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
05154   }
05155   arg9 = (char *)(buf9);
05156   res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
05157   if (!SWIG_IsOK(res10)) {
05158     SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
05159   }
05160   arg10 = (char *)(buf10);
05161   ecode11 = SWIG_AsVal_double(obj10, &val11);
05162   if (!SWIG_IsOK(ecode11)) {
05163     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
05164   } 
05165   arg11 = (PLFLT)(val11);
05166   ecode12 = SWIG_AsVal_int(obj11, &val12);
05167   if (!SWIG_IsOK(ecode12)) {
05168     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
05169   } 
05170   arg12 = (PLINT)(val12);
05171   plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
05172   resultobj = SWIG_Py_Void();
05173   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05174   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05175   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05176   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05177   if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05178   if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05179   return resultobj;
05180 fail:
05181   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05182   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05183   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05184   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05185   if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05186   if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05187   return NULL;
05188 }
05189 
05190 
05191 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05192   PyObject *resultobj = 0;
05193   PLFLT arg1 ;
05194   PLFLT arg2 ;
05195   PLFLT *arg3 = (PLFLT *) 0 ;
05196   PLFLT *arg4 = (PLFLT *) 0 ;
05197   PLINT *arg5 = (PLINT *) 0 ;
05198   double val1 ;
05199   int ecode1 = 0 ;
05200   double val2 ;
05201   int ecode2 = 0 ;
05202   PLFLT temp3 ;
05203   int res3 = SWIG_TMPOBJ ;
05204   PLFLT temp4 ;
05205   int res4 = SWIG_TMPOBJ ;
05206   PLINT temp5 ;
05207   int res5 = SWIG_TMPOBJ ;
05208   PyObject * obj0 = 0 ;
05209   PyObject * obj1 = 0 ;
05210   
05211   arg3 = &temp3;
05212   arg4 = &temp4;
05213   arg5 = &temp5;
05214   if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
05215   ecode1 = SWIG_AsVal_double(obj0, &val1);
05216   if (!SWIG_IsOK(ecode1)) {
05217     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
05218   } 
05219   arg1 = (PLFLT)(val1);
05220   ecode2 = SWIG_AsVal_double(obj1, &val2);
05221   if (!SWIG_IsOK(ecode2)) {
05222     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
05223   } 
05224   arg2 = (PLFLT)(val2);
05225   plcalc_world(arg1,arg2,arg3,arg4,arg5);
05226   resultobj = SWIG_Py_Void();
05227   if (SWIG_IsTmpObj(res3)) {
05228     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
05229   } else {
05230     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05231     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
05232   }
05233   if (SWIG_IsTmpObj(res4)) {
05234     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
05235   } else {
05236     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05237     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
05238   }
05239   if (SWIG_IsTmpObj(res5)) {
05240     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
05241   } else {
05242     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05243     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
05244   }
05245   return resultobj;
05246 fail:
05247   return NULL;
05248 }
05249 
05250 
05251 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05252   PyObject *resultobj = 0;
05253   
05254   if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
05255   plclear();
05256   resultobj = SWIG_Py_Void();
05257   return resultobj;
05258 fail:
05259   return NULL;
05260 }
05261 
05262 
05263 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05264   PyObject *resultobj = 0;
05265   PLINT arg1 ;
05266   int val1 ;
05267   int ecode1 = 0 ;
05268   PyObject * obj0 = 0 ;
05269   
05270   if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
05271   ecode1 = SWIG_AsVal_int(obj0, &val1);
05272   if (!SWIG_IsOK(ecode1)) {
05273     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
05274   } 
05275   arg1 = (PLINT)(val1);
05276   plcol0(arg1);
05277   resultobj = SWIG_Py_Void();
05278   return resultobj;
05279 fail:
05280   return NULL;
05281 }
05282 
05283 
05284 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05285   PyObject *resultobj = 0;
05286   PLFLT arg1 ;
05287   double val1 ;
05288   int ecode1 = 0 ;
05289   PyObject * obj0 = 0 ;
05290   
05291   if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
05292   ecode1 = SWIG_AsVal_double(obj0, &val1);
05293   if (!SWIG_IsOK(ecode1)) {
05294     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
05295   } 
05296   arg1 = (PLFLT)(val1);
05297   plcol1(arg1);
05298   resultobj = SWIG_Py_Void();
05299   return resultobj;
05300 fail:
05301   return NULL;
05302 }
05303 
05304 
05305 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05306   PyObject *resultobj = 0;
05307   PLFLT arg1 ;
05308   PLFLT arg2 ;
05309   PLFLT arg3 ;
05310   PLINT arg4 ;
05311   PLBOOL arg5 ;
05312   PLINT arg6 ;
05313   PLINT arg7 ;
05314   PLINT arg8 ;
05315   PLINT arg9 ;
05316   PLINT arg10 ;
05317   PLFLT arg11 ;
05318   double val1 ;
05319   int ecode1 = 0 ;
05320   double val2 ;
05321   int ecode2 = 0 ;
05322   double val3 ;
05323   int ecode3 = 0 ;
05324   int val4 ;
05325   int ecode4 = 0 ;
05326   int val5 ;
05327   int ecode5 = 0 ;
05328   int val6 ;
05329   int ecode6 = 0 ;
05330   int val7 ;
05331   int ecode7 = 0 ;
05332   int val8 ;
05333   int ecode8 = 0 ;
05334   int val9 ;
05335   int ecode9 = 0 ;
05336   int val10 ;
05337   int ecode10 = 0 ;
05338   double val11 ;
05339   int ecode11 = 0 ;
05340   PyObject * obj0 = 0 ;
05341   PyObject * obj1 = 0 ;
05342   PyObject * obj2 = 0 ;
05343   PyObject * obj3 = 0 ;
05344   PyObject * obj4 = 0 ;
05345   PyObject * obj5 = 0 ;
05346   PyObject * obj6 = 0 ;
05347   PyObject * obj7 = 0 ;
05348   PyObject * obj8 = 0 ;
05349   PyObject * obj9 = 0 ;
05350   PyObject * obj10 = 0 ;
05351   
05352   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
05353   ecode1 = SWIG_AsVal_double(obj0, &val1);
05354   if (!SWIG_IsOK(ecode1)) {
05355     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
05356   } 
05357   arg1 = (PLFLT)(val1);
05358   ecode2 = SWIG_AsVal_double(obj1, &val2);
05359   if (!SWIG_IsOK(ecode2)) {
05360     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
05361   } 
05362   arg2 = (PLFLT)(val2);
05363   ecode3 = SWIG_AsVal_double(obj2, &val3);
05364   if (!SWIG_IsOK(ecode3)) {
05365     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
05366   } 
05367   arg3 = (PLFLT)(val3);
05368   ecode4 = SWIG_AsVal_int(obj3, &val4);
05369   if (!SWIG_IsOK(ecode4)) {
05370     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
05371   } 
05372   arg4 = (PLINT)(val4);
05373   ecode5 = SWIG_AsVal_int(obj4, &val5);
05374   if (!SWIG_IsOK(ecode5)) {
05375     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
05376   } 
05377   arg5 = (PLBOOL)(val5);
05378   ecode6 = SWIG_AsVal_int(obj5, &val6);
05379   if (!SWIG_IsOK(ecode6)) {
05380     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
05381   } 
05382   arg6 = (PLINT)(val6);
05383   ecode7 = SWIG_AsVal_int(obj6, &val7);
05384   if (!SWIG_IsOK(ecode7)) {
05385     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
05386   } 
05387   arg7 = (PLINT)(val7);
05388   ecode8 = SWIG_AsVal_int(obj7, &val8);
05389   if (!SWIG_IsOK(ecode8)) {
05390     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
05391   } 
05392   arg8 = (PLINT)(val8);
05393   ecode9 = SWIG_AsVal_int(obj8, &val9);
05394   if (!SWIG_IsOK(ecode9)) {
05395     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
05396   } 
05397   arg9 = (PLINT)(val9);
05398   ecode10 = SWIG_AsVal_int(obj9, &val10);
05399   if (!SWIG_IsOK(ecode10)) {
05400     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
05401   } 
05402   arg10 = (PLINT)(val10);
05403   ecode11 = SWIG_AsVal_double(obj10, &val11);
05404   if (!SWIG_IsOK(ecode11)) {
05405     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
05406   } 
05407   arg11 = (PLFLT)(val11);
05408   plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
05409   resultobj = SWIG_Py_Void();
05410   return resultobj;
05411 fail:
05412   return NULL;
05413 }
05414 
05415 
05416 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05417   PyObject *resultobj = 0;
05418   PLFLT **arg1 = (PLFLT **) 0 ;
05419   PLINT arg2 ;
05420   PLINT arg3 ;
05421   PLINT arg4 ;
05422   PLINT arg5 ;
05423   PLINT arg6 ;
05424   PLINT arg7 ;
05425   PLFLT *arg8 = (PLFLT *) 0 ;
05426   PLINT arg9 ;
05427   pltr_func arg10 = (pltr_func) 0 ;
05428   PLPointer arg11 = (PLPointer) 0 ;
05429   PyArrayObject *tmp1 ;
05430   int val4 ;
05431   int ecode4 = 0 ;
05432   int val5 ;
05433   int ecode5 = 0 ;
05434   int val6 ;
05435   int ecode6 = 0 ;
05436   int val7 ;
05437   int ecode7 = 0 ;
05438   PyArrayObject *tmp8 ;
05439   PyObject * obj0 = 0 ;
05440   PyObject * obj1 = 0 ;
05441   PyObject * obj2 = 0 ;
05442   PyObject * obj3 = 0 ;
05443   PyObject * obj4 = 0 ;
05444   PyObject * obj5 = 0 ;
05445   PyObject * obj6 = 0 ;
05446   PyObject * obj7 = 0 ;
05447   
05448   {
05449     python_pltr = 0;
05450     arg10          = NULL;
05451   }
05452   {
05453     arg11 = NULL;
05454   }
05455   if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
05456   {
05457     int i, size;
05458     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
05459     if ( tmp1 == NULL )
05460     return NULL;
05461     Xlen = arg2 = tmp1->dimensions[0];
05462     Ylen = arg3 = tmp1->dimensions[1];
05463     size = sizeof ( PLFLT ) * arg3;
05464     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
05465     for ( i = 0; i < arg2; i++ )
05466     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
05467   }
05468   ecode4 = SWIG_AsVal_int(obj1, &val4);
05469   if (!SWIG_IsOK(ecode4)) {
05470     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
05471   } 
05472   arg4 = (PLINT)(val4);
05473   ecode5 = SWIG_AsVal_int(obj2, &val5);
05474   if (!SWIG_IsOK(ecode5)) {
05475     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
05476   } 
05477   arg5 = (PLINT)(val5);
05478   ecode6 = SWIG_AsVal_int(obj3, &val6);
05479   if (!SWIG_IsOK(ecode6)) {
05480     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
05481   } 
05482   arg6 = (PLINT)(val6);
05483   ecode7 = SWIG_AsVal_int(obj4, &val7);
05484   if (!SWIG_IsOK(ecode7)) {
05485     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
05486   } 
05487   arg7 = (PLINT)(val7);
05488   {
05489     tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
05490     if ( tmp8 == NULL )
05491     return NULL;
05492     arg9 = tmp8->dimensions[0];
05493     arg8 = (PLFLT *) tmp8->data;
05494   }
05495   if (obj6) {
05496     {
05497       // it must be a callable or None
05498       if ( obj6 == Py_None )
05499       {
05500         arg10 = NULL;
05501       }
05502       else
05503       {
05504         if ( !PyCallable_Check( (PyObject *) obj6 ) )
05505         {
05506           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
05507           return NULL;
05508         }
05509         arg10 = marshal_pltr( obj6 );
05510       }
05511     }
05512   }
05513   if (obj7) {
05514     {
05515       if ( obj7 == Py_None )
05516       arg11 = NULL;
05517       else
05518       {
05519         arg11 = marshal_PLPointer( obj7, 0 );
05520       }
05521     }
05522   }
05523   plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
05524   resultobj = SWIG_Py_Void();
05525   {
05526     Py_DECREF( tmp1 );
05527     free( arg1 );
05528   }
05529   {
05530     Py_DECREF( tmp8 );
05531   }
05532   {
05533     cleanup_pltr();
05534   }
05535   {
05536     cleanup_PLPointer();
05537   }
05538   return resultobj;
05539 fail:
05540   {
05541     Py_DECREF( tmp1 );
05542     free( arg1 );
05543   }
05544   {
05545     Py_DECREF( tmp8 );
05546   }
05547   {
05548     cleanup_pltr();
05549   }
05550   {
05551     cleanup_PLPointer();
05552   }
05553   return NULL;
05554 }
05555 
05556 
05557 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05558   PyObject *resultobj = 0;
05559   PLINT arg1 ;
05560   PLINT arg2 ;
05561   PLINT arg3 ;
05562   PLINT arg4 ;
05563   PLINT arg5 ;
05564   PLFLT arg6 ;
05565   PLFLT *arg7 = (PLFLT *) 0 ;
05566   int val1 ;
05567   int ecode1 = 0 ;
05568   int val2 ;
05569   int ecode2 = 0 ;
05570   int val3 ;
05571   int ecode3 = 0 ;
05572   int val4 ;
05573   int ecode4 = 0 ;
05574   int val5 ;
05575   int ecode5 = 0 ;
05576   double val6 ;
05577   int ecode6 = 0 ;
05578   PLFLT temp7 ;
05579   int res7 = SWIG_TMPOBJ ;
05580   PyObject * obj0 = 0 ;
05581   PyObject * obj1 = 0 ;
05582   PyObject * obj2 = 0 ;
05583   PyObject * obj3 = 0 ;
05584   PyObject * obj4 = 0 ;
05585   PyObject * obj5 = 0 ;
05586   
05587   arg7 = &temp7;
05588   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05589   ecode1 = SWIG_AsVal_int(obj0, &val1);
05590   if (!SWIG_IsOK(ecode1)) {
05591     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
05592   } 
05593   arg1 = (PLINT)(val1);
05594   ecode2 = SWIG_AsVal_int(obj1, &val2);
05595   if (!SWIG_IsOK(ecode2)) {
05596     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
05597   } 
05598   arg2 = (PLINT)(val2);
05599   ecode3 = SWIG_AsVal_int(obj2, &val3);
05600   if (!SWIG_IsOK(ecode3)) {
05601     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
05602   } 
05603   arg3 = (PLINT)(val3);
05604   ecode4 = SWIG_AsVal_int(obj3, &val4);
05605   if (!SWIG_IsOK(ecode4)) {
05606     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
05607   } 
05608   arg4 = (PLINT)(val4);
05609   ecode5 = SWIG_AsVal_int(obj4, &val5);
05610   if (!SWIG_IsOK(ecode5)) {
05611     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
05612   } 
05613   arg5 = (PLINT)(val5);
05614   ecode6 = SWIG_AsVal_double(obj5, &val6);
05615   if (!SWIG_IsOK(ecode6)) {
05616     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
05617   } 
05618   arg6 = (PLFLT)(val6);
05619   plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
05620   resultobj = SWIG_Py_Void();
05621   if (SWIG_IsTmpObj(res7)) {
05622     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
05623   } else {
05624     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05625     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
05626   }
05627   return resultobj;
05628 fail:
05629   return NULL;
05630 }
05631 
05632 
05633 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05634   PyObject *resultobj = 0;
05635   PLINT arg1 ;
05636   PLBOOL arg2 ;
05637   int val1 ;
05638   int ecode1 = 0 ;
05639   int val2 ;
05640   int ecode2 = 0 ;
05641   PyObject * obj0 = 0 ;
05642   PyObject * obj1 = 0 ;
05643   
05644   if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
05645   ecode1 = SWIG_AsVal_int(obj0, &val1);
05646   if (!SWIG_IsOK(ecode1)) {
05647     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
05648   } 
05649   arg1 = (PLINT)(val1);
05650   ecode2 = SWIG_AsVal_int(obj1, &val2);
05651   if (!SWIG_IsOK(ecode2)) {
05652     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
05653   } 
05654   arg2 = (PLBOOL)(val2);
05655   plcpstrm(arg1,arg2);
05656   resultobj = SWIG_Py_Void();
05657   return resultobj;
05658 fail:
05659   return NULL;
05660 }
05661 
05662 
05663 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05664   PyObject *resultobj = 0;
05665   
05666   if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
05667   plend();
05668   resultobj = SWIG_Py_Void();
05669   return resultobj;
05670 fail:
05671   return NULL;
05672 }
05673 
05674 
05675 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05676   PyObject *resultobj = 0;
05677   
05678   if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
05679   plend1();
05680   resultobj = SWIG_Py_Void();
05681   return resultobj;
05682 fail:
05683   return NULL;
05684 }
05685 
05686 
05687 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05688   PyObject *resultobj = 0;
05689   PLFLT arg1 ;
05690   PLFLT arg2 ;
05691   PLFLT arg3 ;
05692   PLFLT arg4 ;
05693   PLINT arg5 ;
05694   PLINT arg6 ;
05695   double val1 ;
05696   int ecode1 = 0 ;
05697   double val2 ;
05698   int ecode2 = 0 ;
05699   double val3 ;
05700   int ecode3 = 0 ;
05701   double val4 ;
05702   int ecode4 = 0 ;
05703   int val5 ;
05704   int ecode5 = 0 ;
05705   int val6 ;
05706   int ecode6 = 0 ;
05707   PyObject * obj0 = 0 ;
05708   PyObject * obj1 = 0 ;
05709   PyObject * obj2 = 0 ;
05710   PyObject * obj3 = 0 ;
05711   PyObject * obj4 = 0 ;
05712   PyObject * obj5 = 0 ;
05713   
05714   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05715   ecode1 = SWIG_AsVal_double(obj0, &val1);
05716   if (!SWIG_IsOK(ecode1)) {
05717     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
05718   } 
05719   arg1 = (PLFLT)(val1);
05720   ecode2 = SWIG_AsVal_double(obj1, &val2);
05721   if (!SWIG_IsOK(ecode2)) {
05722     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
05723   } 
05724   arg2 = (PLFLT)(val2);
05725   ecode3 = SWIG_AsVal_double(obj2, &val3);
05726   if (!SWIG_IsOK(ecode3)) {
05727     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
05728   } 
05729   arg3 = (PLFLT)(val3);
05730   ecode4 = SWIG_AsVal_double(obj3, &val4);
05731   if (!SWIG_IsOK(ecode4)) {
05732     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
05733   } 
05734   arg4 = (PLFLT)(val4);
05735   ecode5 = SWIG_AsVal_int(obj4, &val5);
05736   if (!SWIG_IsOK(ecode5)) {
05737     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
05738   } 
05739   arg5 = (PLINT)(val5);
05740   ecode6 = SWIG_AsVal_int(obj5, &val6);
05741   if (!SWIG_IsOK(ecode6)) {
05742     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
05743   } 
05744   arg6 = (PLINT)(val6);
05745   plenv(arg1,arg2,arg3,arg4,arg5,arg6);
05746   resultobj = SWIG_Py_Void();
05747   return resultobj;
05748 fail:
05749   return NULL;
05750 }
05751 
05752 
05753 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05754   PyObject *resultobj = 0;
05755   PLFLT arg1 ;
05756   PLFLT arg2 ;
05757   PLFLT arg3 ;
05758   PLFLT arg4 ;
05759   PLINT arg5 ;
05760   PLINT arg6 ;
05761   double val1 ;
05762   int ecode1 = 0 ;
05763   double val2 ;
05764   int ecode2 = 0 ;
05765   double val3 ;
05766   int ecode3 = 0 ;
05767   double val4 ;
05768   int ecode4 = 0 ;
05769   int val5 ;
05770   int ecode5 = 0 ;
05771   int val6 ;
05772   int ecode6 = 0 ;
05773   PyObject * obj0 = 0 ;
05774   PyObject * obj1 = 0 ;
05775   PyObject * obj2 = 0 ;
05776   PyObject * obj3 = 0 ;
05777   PyObject * obj4 = 0 ;
05778   PyObject * obj5 = 0 ;
05779   
05780   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05781   ecode1 = SWIG_AsVal_double(obj0, &val1);
05782   if (!SWIG_IsOK(ecode1)) {
05783     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
05784   } 
05785   arg1 = (PLFLT)(val1);
05786   ecode2 = SWIG_AsVal_double(obj1, &val2);
05787   if (!SWIG_IsOK(ecode2)) {
05788     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
05789   } 
05790   arg2 = (PLFLT)(val2);
05791   ecode3 = SWIG_AsVal_double(obj2, &val3);
05792   if (!SWIG_IsOK(ecode3)) {
05793     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
05794   } 
05795   arg3 = (PLFLT)(val3);
05796   ecode4 = SWIG_AsVal_double(obj3, &val4);
05797   if (!SWIG_IsOK(ecode4)) {
05798     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
05799   } 
05800   arg4 = (PLFLT)(val4);
05801   ecode5 = SWIG_AsVal_int(obj4, &val5);
05802   if (!SWIG_IsOK(ecode5)) {
05803     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
05804   } 
05805   arg5 = (PLINT)(val5);
05806   ecode6 = SWIG_AsVal_int(obj5, &val6);
05807   if (!SWIG_IsOK(ecode6)) {
05808     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
05809   } 
05810   arg6 = (PLINT)(val6);
05811   plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
05812   resultobj = SWIG_Py_Void();
05813   return resultobj;
05814 fail:
05815   return NULL;
05816 }
05817 
05818 
05819 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05820   PyObject *resultobj = 0;
05821   
05822   if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
05823   pleop();
05824   resultobj = SWIG_Py_Void();
05825   return resultobj;
05826 fail:
05827   return NULL;
05828 }
05829 
05830 
05831 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05832   PyObject *resultobj = 0;
05833   PLINT arg1 ;
05834   PLFLT *arg2 = (PLFLT *) 0 ;
05835   PLFLT *arg3 = (PLFLT *) 0 ;
05836   PLFLT *arg4 = (PLFLT *) 0 ;
05837   PyArrayObject *tmp1 ;
05838   PyArrayObject *tmp3 ;
05839   PyArrayObject *tmp4 ;
05840   PyObject * obj0 = 0 ;
05841   PyObject * obj1 = 0 ;
05842   PyObject * obj2 = 0 ;
05843   
05844   if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
05845   {
05846     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05847     if ( tmp1 == NULL )
05848     return NULL;
05849     arg1 = Alen = tmp1->dimensions[0];
05850     arg2 = (PLFLT *) tmp1->data;
05851   }
05852   {
05853     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
05854     if ( tmp3 == NULL )
05855     return NULL;
05856     if ( tmp3->dimensions[0] != Alen )
05857     {
05858       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05859       return NULL;
05860     }
05861     arg3 = (PLFLT *) tmp3->data;
05862   }
05863   {
05864     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
05865     if ( tmp4 == NULL )
05866     return NULL;
05867     if ( tmp4->dimensions[0] != Alen )
05868     {
05869       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05870       return NULL;
05871     }
05872     arg4 = (PLFLT *) tmp4->data;
05873   }
05874   plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
05875   resultobj = SWIG_Py_Void();
05876   {
05877     Py_DECREF( tmp1 );
05878   }
05879   {
05880     Py_DECREF( tmp3 );
05881   }
05882   {
05883     Py_DECREF( tmp4 );
05884   }
05885   return resultobj;
05886 fail:
05887   {
05888     Py_DECREF( tmp1 );
05889   }
05890   {
05891     Py_DECREF( tmp3 );
05892   }
05893   {
05894     Py_DECREF( tmp4 );
05895   }
05896   return NULL;
05897 }
05898 
05899 
05900 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05901   PyObject *resultobj = 0;
05902   PLINT arg1 ;
05903   PLFLT *arg2 = (PLFLT *) 0 ;
05904   PLFLT *arg3 = (PLFLT *) 0 ;
05905   PLFLT *arg4 = (PLFLT *) 0 ;
05906   PyArrayObject *tmp1 ;
05907   PyArrayObject *tmp3 ;
05908   PyArrayObject *tmp4 ;
05909   PyObject * obj0 = 0 ;
05910   PyObject * obj1 = 0 ;
05911   PyObject * obj2 = 0 ;
05912   
05913   if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
05914   {
05915     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05916     if ( tmp1 == NULL )
05917     return NULL;
05918     arg1 = Alen = tmp1->dimensions[0];
05919     arg2 = (PLFLT *) tmp1->data;
05920   }
05921   {
05922     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
05923     if ( tmp3 == NULL )
05924     return NULL;
05925     if ( tmp3->dimensions[0] != Alen )
05926     {
05927       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05928       return NULL;
05929     }
05930     arg3 = (PLFLT *) tmp3->data;
05931   }
05932   {
05933     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
05934     if ( tmp4 == NULL )
05935     return NULL;
05936     if ( tmp4->dimensions[0] != Alen )
05937     {
05938       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05939       return NULL;
05940     }
05941     arg4 = (PLFLT *) tmp4->data;
05942   }
05943   plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
05944   resultobj = SWIG_Py_Void();
05945   {
05946     Py_DECREF( tmp1 );
05947   }
05948   {
05949     Py_DECREF( tmp3 );
05950   }
05951   {
05952     Py_DECREF( tmp4 );
05953   }
05954   return resultobj;
05955 fail:
05956   {
05957     Py_DECREF( tmp1 );
05958   }
05959   {
05960     Py_DECREF( tmp3 );
05961   }
05962   {
05963     Py_DECREF( tmp4 );
05964   }
05965   return NULL;
05966 }
05967 
05968 
05969 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05970   PyObject *resultobj = 0;
05971   
05972   if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
05973   plfamadv();
05974   resultobj = SWIG_Py_Void();
05975   return resultobj;
05976 fail:
05977   return NULL;
05978 }
05979 
05980 
05981 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05982   PyObject *resultobj = 0;
05983   PLINT arg1 ;
05984   PLFLT *arg2 = (PLFLT *) 0 ;
05985   PLFLT *arg3 = (PLFLT *) 0 ;
05986   PyArrayObject *tmp1 ;
05987   PyArrayObject *tmp3 ;
05988   PyObject * obj0 = 0 ;
05989   PyObject * obj1 = 0 ;
05990   
05991   if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
05992   {
05993     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
05994     if ( tmp1 == NULL )
05995     return NULL;
05996     arg1 = Alen = tmp1->dimensions[0];
05997     arg2 = (PLFLT *) tmp1->data;
05998   }
05999   {
06000     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06001     if ( tmp3 == NULL )
06002     return NULL;
06003     if ( tmp3->dimensions[0] != Alen )
06004     {
06005       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06006       return NULL;
06007     }
06008     arg3 = (PLFLT *) tmp3->data;
06009   }
06010   plfill(arg1,(double const *)arg2,(double const *)arg3);
06011   resultobj = SWIG_Py_Void();
06012   {
06013     Py_DECREF( tmp1 );
06014   }
06015   {
06016     Py_DECREF( tmp3 );
06017   }
06018   return resultobj;
06019 fail:
06020   {
06021     Py_DECREF( tmp1 );
06022   }
06023   {
06024     Py_DECREF( tmp3 );
06025   }
06026   return NULL;
06027 }
06028 
06029 
06030 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06031   PyObject *resultobj = 0;
06032   PLINT arg1 ;
06033   PLFLT *arg2 = (PLFLT *) 0 ;
06034   PLFLT *arg3 = (PLFLT *) 0 ;
06035   PLFLT *arg4 = (PLFLT *) 0 ;
06036   PyArrayObject *tmp1 ;
06037   PyArrayObject *tmp3 ;
06038   PyArrayObject *tmp4 ;
06039   PyObject * obj0 = 0 ;
06040   PyObject * obj1 = 0 ;
06041   PyObject * obj2 = 0 ;
06042   
06043   if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
06044   {
06045     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06046     if ( tmp1 == NULL )
06047     return NULL;
06048     arg1 = Alen = tmp1->dimensions[0];
06049     arg2 = (PLFLT *) tmp1->data;
06050   }
06051   {
06052     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06053     if ( tmp3 == NULL )
06054     return NULL;
06055     if ( tmp3->dimensions[0] != Alen )
06056     {
06057       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06058       return NULL;
06059     }
06060     arg3 = (PLFLT *) tmp3->data;
06061   }
06062   {
06063     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
06064     if ( tmp4 == NULL )
06065     return NULL;
06066     if ( tmp4->dimensions[0] != Alen )
06067     {
06068       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06069       return NULL;
06070     }
06071     arg4 = (PLFLT *) tmp4->data;
06072   }
06073   plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
06074   resultobj = SWIG_Py_Void();
06075   {
06076     Py_DECREF( tmp1 );
06077   }
06078   {
06079     Py_DECREF( tmp3 );
06080   }
06081   {
06082     Py_DECREF( tmp4 );
06083   }
06084   return resultobj;
06085 fail:
06086   {
06087     Py_DECREF( tmp1 );
06088   }
06089   {
06090     Py_DECREF( tmp3 );
06091   }
06092   {
06093     Py_DECREF( tmp4 );
06094   }
06095   return NULL;
06096 }
06097 
06098 
06099 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06100   PyObject *resultobj = 0;
06101   PLINT arg1 ;
06102   PLFLT *arg2 = (PLFLT *) 0 ;
06103   PLFLT *arg3 = (PLFLT *) 0 ;
06104   PLFLT arg4 ;
06105   PyArrayObject *tmp1 ;
06106   PyArrayObject *tmp3 ;
06107   double val4 ;
06108   int ecode4 = 0 ;
06109   PyObject * obj0 = 0 ;
06110   PyObject * obj1 = 0 ;
06111   PyObject * obj2 = 0 ;
06112   
06113   if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
06114   {
06115     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06116     if ( tmp1 == NULL )
06117     return NULL;
06118     arg1 = Alen = tmp1->dimensions[0];
06119     arg2 = (PLFLT *) tmp1->data;
06120   }
06121   {
06122     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06123     if ( tmp3 == NULL )
06124     return NULL;
06125     if ( tmp3->dimensions[0] != Alen )
06126     {
06127       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06128       return NULL;
06129     }
06130     arg3 = (PLFLT *) tmp3->data;
06131   }
06132   ecode4 = SWIG_AsVal_double(obj2, &val4);
06133   if (!SWIG_IsOK(ecode4)) {
06134     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
06135   } 
06136   arg4 = (PLFLT)(val4);
06137   plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
06138   resultobj = SWIG_Py_Void();
06139   {
06140     Py_DECREF( tmp1 );
06141   }
06142   {
06143     Py_DECREF( tmp3 );
06144   }
06145   return resultobj;
06146 fail:
06147   {
06148     Py_DECREF( tmp1 );
06149   }
06150   {
06151     Py_DECREF( tmp3 );
06152   }
06153   return NULL;
06154 }
06155 
06156 
06157 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06158   PyObject *resultobj = 0;
06159   
06160   if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
06161   plflush();
06162   resultobj = SWIG_Py_Void();
06163   return resultobj;
06164 fail:
06165   return NULL;
06166 }
06167 
06168 
06169 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06170   PyObject *resultobj = 0;
06171   PLINT arg1 ;
06172   int val1 ;
06173   int ecode1 = 0 ;
06174   PyObject * obj0 = 0 ;
06175   
06176   if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
06177   ecode1 = SWIG_AsVal_int(obj0, &val1);
06178   if (!SWIG_IsOK(ecode1)) {
06179     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
06180   } 
06181   arg1 = (PLINT)(val1);
06182   plfont(arg1);
06183   resultobj = SWIG_Py_Void();
06184   return resultobj;
06185 fail:
06186   return NULL;
06187 }
06188 
06189 
06190 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06191   PyObject *resultobj = 0;
06192   PLINT arg1 ;
06193   int val1 ;
06194   int ecode1 = 0 ;
06195   PyObject * obj0 = 0 ;
06196   
06197   if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
06198   ecode1 = SWIG_AsVal_int(obj0, &val1);
06199   if (!SWIG_IsOK(ecode1)) {
06200     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
06201   } 
06202   arg1 = (PLINT)(val1);
06203   plfontld(arg1);
06204   resultobj = SWIG_Py_Void();
06205   return resultobj;
06206 fail:
06207   return NULL;
06208 }
06209 
06210 
06211 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06212   PyObject *resultobj = 0;
06213   PLFLT *arg1 = (PLFLT *) 0 ;
06214   PLFLT *arg2 = (PLFLT *) 0 ;
06215   PLFLT temp1 ;
06216   int res1 = SWIG_TMPOBJ ;
06217   PLFLT temp2 ;
06218   int res2 = SWIG_TMPOBJ ;
06219   
06220   arg1 = &temp1;
06221   arg2 = &temp2;
06222   if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
06223   plgchr(arg1,arg2);
06224   resultobj = SWIG_Py_Void();
06225   if (SWIG_IsTmpObj(res1)) {
06226     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06227   } else {
06228     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06229     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06230   }
06231   if (SWIG_IsTmpObj(res2)) {
06232     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06233   } else {
06234     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06235     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06236   }
06237   return resultobj;
06238 fail:
06239   return NULL;
06240 }
06241 
06242 
06243 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06244   PyObject *resultobj = 0;
06245   PLINT arg1 ;
06246   PLINT *arg2 = (PLINT *) 0 ;
06247   PLINT *arg3 = (PLINT *) 0 ;
06248   PLINT *arg4 = (PLINT *) 0 ;
06249   int val1 ;
06250   int ecode1 = 0 ;
06251   PLINT temp2 ;
06252   int res2 = SWIG_TMPOBJ ;
06253   PLINT temp3 ;
06254   int res3 = SWIG_TMPOBJ ;
06255   PLINT temp4 ;
06256   int res4 = SWIG_TMPOBJ ;
06257   PyObject * obj0 = 0 ;
06258   
06259   arg2 = &temp2;
06260   arg3 = &temp3;
06261   arg4 = &temp4;
06262   if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
06263   ecode1 = SWIG_AsVal_int(obj0, &val1);
06264   if (!SWIG_IsOK(ecode1)) {
06265     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
06266   } 
06267   arg1 = (PLINT)(val1);
06268   plgcol0(arg1,arg2,arg3,arg4);
06269   resultobj = SWIG_Py_Void();
06270   if (SWIG_IsTmpObj(res2)) {
06271     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06272   } else {
06273     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06274     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06275   }
06276   if (SWIG_IsTmpObj(res3)) {
06277     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06278   } else {
06279     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06280     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06281   }
06282   if (SWIG_IsTmpObj(res4)) {
06283     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06284   } else {
06285     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06286     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06287   }
06288   return resultobj;
06289 fail:
06290   return NULL;
06291 }
06292 
06293 
06294 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06295   PyObject *resultobj = 0;
06296   PLINT arg1 ;
06297   PLINT *arg2 = (PLINT *) 0 ;
06298   PLINT *arg3 = (PLINT *) 0 ;
06299   PLINT *arg4 = (PLINT *) 0 ;
06300   PLFLT *arg5 = (PLFLT *) 0 ;
06301   int val1 ;
06302   int ecode1 = 0 ;
06303   PLINT temp2 ;
06304   int res2 = SWIG_TMPOBJ ;
06305   PLINT temp3 ;
06306   int res3 = SWIG_TMPOBJ ;
06307   PLINT temp4 ;
06308   int res4 = SWIG_TMPOBJ ;
06309   PLFLT temp5 ;
06310   int res5 = SWIG_TMPOBJ ;
06311   PyObject * obj0 = 0 ;
06312   
06313   arg2 = &temp2;
06314   arg3 = &temp3;
06315   arg4 = &temp4;
06316   arg5 = &temp5;
06317   if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
06318   ecode1 = SWIG_AsVal_int(obj0, &val1);
06319   if (!SWIG_IsOK(ecode1)) {
06320     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
06321   } 
06322   arg1 = (PLINT)(val1);
06323   plgcol0a(arg1,arg2,arg3,arg4,arg5);
06324   resultobj = SWIG_Py_Void();
06325   if (SWIG_IsTmpObj(res2)) {
06326     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06327   } else {
06328     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06329     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06330   }
06331   if (SWIG_IsTmpObj(res3)) {
06332     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06333   } else {
06334     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06335     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06336   }
06337   if (SWIG_IsTmpObj(res4)) {
06338     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06339   } else {
06340     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06341     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06342   }
06343   if (SWIG_IsTmpObj(res5)) {
06344     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
06345   } else {
06346     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06347     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
06348   }
06349   return resultobj;
06350 fail:
06351   return NULL;
06352 }
06353 
06354 
06355 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06356   PyObject *resultobj = 0;
06357   PLINT *arg1 = (PLINT *) 0 ;
06358   PLINT *arg2 = (PLINT *) 0 ;
06359   PLINT *arg3 = (PLINT *) 0 ;
06360   PLINT temp1 ;
06361   int res1 = SWIG_TMPOBJ ;
06362   PLINT temp2 ;
06363   int res2 = SWIG_TMPOBJ ;
06364   PLINT temp3 ;
06365   int res3 = SWIG_TMPOBJ ;
06366   
06367   arg1 = &temp1;
06368   arg2 = &temp2;
06369   arg3 = &temp3;
06370   if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
06371   plgcolbg(arg1,arg2,arg3);
06372   resultobj = SWIG_Py_Void();
06373   if (SWIG_IsTmpObj(res1)) {
06374     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06375   } else {
06376     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06377     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06378   }
06379   if (SWIG_IsTmpObj(res2)) {
06380     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06381   } else {
06382     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06383     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06384   }
06385   if (SWIG_IsTmpObj(res3)) {
06386     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06387   } else {
06388     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06389     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06390   }
06391   return resultobj;
06392 fail:
06393   return NULL;
06394 }
06395 
06396 
06397 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06398   PyObject *resultobj = 0;
06399   PLINT *arg1 = (PLINT *) 0 ;
06400   PLINT *arg2 = (PLINT *) 0 ;
06401   PLINT *arg3 = (PLINT *) 0 ;
06402   PLFLT *arg4 = (PLFLT *) 0 ;
06403   PLINT temp1 ;
06404   int res1 = SWIG_TMPOBJ ;
06405   PLINT temp2 ;
06406   int res2 = SWIG_TMPOBJ ;
06407   PLINT temp3 ;
06408   int res3 = SWIG_TMPOBJ ;
06409   PLFLT temp4 ;
06410   int res4 = SWIG_TMPOBJ ;
06411   
06412   arg1 = &temp1;
06413   arg2 = &temp2;
06414   arg3 = &temp3;
06415   arg4 = &temp4;
06416   if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
06417   plgcolbga(arg1,arg2,arg3,arg4);
06418   resultobj = SWIG_Py_Void();
06419   if (SWIG_IsTmpObj(res1)) {
06420     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06421   } else {
06422     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06423     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06424   }
06425   if (SWIG_IsTmpObj(res2)) {
06426     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06427   } else {
06428     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06429     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06430   }
06431   if (SWIG_IsTmpObj(res3)) {
06432     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06433   } else {
06434     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06435     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06436   }
06437   if (SWIG_IsTmpObj(res4)) {
06438     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06439   } else {
06440     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06441     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06442   }
06443   return resultobj;
06444 fail:
06445   return NULL;
06446 }
06447 
06448 
06449 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06450   PyObject *resultobj = 0;
06451   PLINT *arg1 = (PLINT *) 0 ;
06452   PLINT temp1 ;
06453   int res1 = SWIG_TMPOBJ ;
06454   
06455   arg1 = &temp1;
06456   if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
06457   plgcompression(arg1);
06458   resultobj = SWIG_Py_Void();
06459   if (SWIG_IsTmpObj(res1)) {
06460     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06461   } else {
06462     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06463     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06464   }
06465   return resultobj;
06466 fail:
06467   return NULL;
06468 }
06469 
06470 
06471 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06472   PyObject *resultobj = 0;
06473   char *arg1 = (char *) 0 ;
06474   char buff1[1000] ;
06475   
06476   {
06477     arg1 = buff1;
06478   }
06479   if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
06480   plgdev(arg1);
06481   resultobj = SWIG_Py_Void();
06482   {
06483     PyObject *o = PyString_FromString( arg1 );
06484     resultobj = t_output_helper( resultobj, o );
06485   }
06486   return resultobj;
06487 fail:
06488   return NULL;
06489 }
06490 
06491 
06492 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06493   PyObject *resultobj = 0;
06494   PLFLT *arg1 = (PLFLT *) 0 ;
06495   PLFLT *arg2 = (PLFLT *) 0 ;
06496   PLFLT *arg3 = (PLFLT *) 0 ;
06497   PLFLT *arg4 = (PLFLT *) 0 ;
06498   PLFLT temp1 ;
06499   int res1 = SWIG_TMPOBJ ;
06500   PLFLT temp2 ;
06501   int res2 = SWIG_TMPOBJ ;
06502   PLFLT temp3 ;
06503   int res3 = SWIG_TMPOBJ ;
06504   PLFLT temp4 ;
06505   int res4 = SWIG_TMPOBJ ;
06506   
06507   arg1 = &temp1;
06508   arg2 = &temp2;
06509   arg3 = &temp3;
06510   arg4 = &temp4;
06511   if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
06512   plgdidev(arg1,arg2,arg3,arg4);
06513   resultobj = SWIG_Py_Void();
06514   if (SWIG_IsTmpObj(res1)) {
06515     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06516   } else {
06517     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06518     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06519   }
06520   if (SWIG_IsTmpObj(res2)) {
06521     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06522   } else {
06523     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06524     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06525   }
06526   if (SWIG_IsTmpObj(res3)) {
06527     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06528   } else {
06529     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06530     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06531   }
06532   if (SWIG_IsTmpObj(res4)) {
06533     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06534   } else {
06535     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06536     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06537   }
06538   return resultobj;
06539 fail:
06540   return NULL;
06541 }
06542 
06543 
06544 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06545   PyObject *resultobj = 0;
06546   PLFLT *arg1 = (PLFLT *) 0 ;
06547   PLFLT temp1 ;
06548   int res1 = SWIG_TMPOBJ ;
06549   
06550   arg1 = &temp1;
06551   if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
06552   plgdiori(arg1);
06553   resultobj = SWIG_Py_Void();
06554   if (SWIG_IsTmpObj(res1)) {
06555     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06556   } else {
06557     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06558     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06559   }
06560   return resultobj;
06561 fail:
06562   return NULL;
06563 }
06564 
06565 
06566 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06567   PyObject *resultobj = 0;
06568   PLFLT *arg1 = (PLFLT *) 0 ;
06569   PLFLT *arg2 = (PLFLT *) 0 ;
06570   PLFLT *arg3 = (PLFLT *) 0 ;
06571   PLFLT *arg4 = (PLFLT *) 0 ;
06572   PLFLT temp1 ;
06573   int res1 = SWIG_TMPOBJ ;
06574   PLFLT temp2 ;
06575   int res2 = SWIG_TMPOBJ ;
06576   PLFLT temp3 ;
06577   int res3 = SWIG_TMPOBJ ;
06578   PLFLT temp4 ;
06579   int res4 = SWIG_TMPOBJ ;
06580   
06581   arg1 = &temp1;
06582   arg2 = &temp2;
06583   arg3 = &temp3;
06584   arg4 = &temp4;
06585   if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
06586   plgdiplt(arg1,arg2,arg3,arg4);
06587   resultobj = SWIG_Py_Void();
06588   if (SWIG_IsTmpObj(res1)) {
06589     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06590   } else {
06591     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06592     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06593   }
06594   if (SWIG_IsTmpObj(res2)) {
06595     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06596   } else {
06597     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06598     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06599   }
06600   if (SWIG_IsTmpObj(res3)) {
06601     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06602   } else {
06603     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06604     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06605   }
06606   if (SWIG_IsTmpObj(res4)) {
06607     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06608   } else {
06609     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06610     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06611   }
06612   return resultobj;
06613 fail:
06614   return NULL;
06615 }
06616 
06617 
06618 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06619   PyObject *resultobj = 0;
06620   PLINT *arg1 = (PLINT *) 0 ;
06621   PLINT *arg2 = (PLINT *) 0 ;
06622   PLINT *arg3 = (PLINT *) 0 ;
06623   PLINT temp1 ;
06624   int res1 = SWIG_TMPOBJ ;
06625   PLINT temp2 ;
06626   int res2 = SWIG_TMPOBJ ;
06627   PLINT temp3 ;
06628   int res3 = SWIG_TMPOBJ ;
06629   
06630   arg1 = &temp1;
06631   arg2 = &temp2;
06632   arg3 = &temp3;
06633   if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
06634   plgfam(arg1,arg2,arg3);
06635   resultobj = SWIG_Py_Void();
06636   if (SWIG_IsTmpObj(res1)) {
06637     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06638   } else {
06639     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06640     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06641   }
06642   if (SWIG_IsTmpObj(res2)) {
06643     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06644   } else {
06645     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06646     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06647   }
06648   if (SWIG_IsTmpObj(res3)) {
06649     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06650   } else {
06651     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06652     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06653   }
06654   return resultobj;
06655 fail:
06656   return NULL;
06657 }
06658 
06659 
06660 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06661   PyObject *resultobj = 0;
06662   PLUNICODE *arg1 = (PLUNICODE *) 0 ;
06663   PLUNICODE temp1 ;
06664   int res1 = SWIG_TMPOBJ ;
06665   
06666   arg1 = &temp1;
06667   if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
06668   plgfci(arg1);
06669   resultobj = SWIG_Py_Void();
06670   if (SWIG_IsTmpObj(res1)) {
06671     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
06672   } else {
06673     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06674     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
06675   }
06676   return resultobj;
06677 fail:
06678   return NULL;
06679 }
06680 
06681 
06682 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06683   PyObject *resultobj = 0;
06684   char *arg1 = (char *) 0 ;
06685   char buff1[1000] ;
06686   
06687   {
06688     arg1 = buff1;
06689   }
06690   if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
06691   plgfnam(arg1);
06692   resultobj = SWIG_Py_Void();
06693   {
06694     PyObject *o = PyString_FromString( arg1 );
06695     resultobj = t_output_helper( resultobj, o );
06696   }
06697   return resultobj;
06698 fail:
06699   return NULL;
06700 }
06701 
06702 
06703 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06704   PyObject *resultobj = 0;
06705   PLINT *arg1 = (PLINT *) 0 ;
06706   PLINT *arg2 = (PLINT *) 0 ;
06707   PLINT *arg3 = (PLINT *) 0 ;
06708   PLINT temp1 ;
06709   int res1 = SWIG_TMPOBJ ;
06710   PLINT temp2 ;
06711   int res2 = SWIG_TMPOBJ ;
06712   PLINT temp3 ;
06713   int res3 = SWIG_TMPOBJ ;
06714   
06715   arg1 = &temp1;
06716   arg2 = &temp2;
06717   arg3 = &temp3;
06718   if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
06719   plgfont(arg1,arg2,arg3);
06720   resultobj = SWIG_Py_Void();
06721   if (SWIG_IsTmpObj(res1)) {
06722     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06723   } else {
06724     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06725     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06726   }
06727   if (SWIG_IsTmpObj(res2)) {
06728     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06729   } else {
06730     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06731     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06732   }
06733   if (SWIG_IsTmpObj(res3)) {
06734     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06735   } else {
06736     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06737     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06738   }
06739   return resultobj;
06740 fail:
06741   return NULL;
06742 }
06743 
06744 
06745 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06746   PyObject *resultobj = 0;
06747   PLINT *arg1 = (PLINT *) 0 ;
06748   PLINT temp1 ;
06749   int res1 = SWIG_TMPOBJ ;
06750   
06751   arg1 = &temp1;
06752   if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
06753   plglevel(arg1);
06754   resultobj = SWIG_Py_Void();
06755   if (SWIG_IsTmpObj(res1)) {
06756     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06757   } else {
06758     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06759     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06760   }
06761   return resultobj;
06762 fail:
06763   return NULL;
06764 }
06765 
06766 
06767 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06768   PyObject *resultobj = 0;
06769   PLFLT *arg1 = (PLFLT *) 0 ;
06770   PLFLT *arg2 = (PLFLT *) 0 ;
06771   PLINT *arg3 = (PLINT *) 0 ;
06772   PLINT *arg4 = (PLINT *) 0 ;
06773   PLINT *arg5 = (PLINT *) 0 ;
06774   PLINT *arg6 = (PLINT *) 0 ;
06775   PLFLT temp1 ;
06776   int res1 = SWIG_TMPOBJ ;
06777   PLFLT temp2 ;
06778   int res2 = SWIG_TMPOBJ ;
06779   PLINT temp3 ;
06780   int res3 = SWIG_TMPOBJ ;
06781   PLINT temp4 ;
06782   int res4 = SWIG_TMPOBJ ;
06783   PLINT temp5 ;
06784   int res5 = SWIG_TMPOBJ ;
06785   PLINT temp6 ;
06786   int res6 = SWIG_TMPOBJ ;
06787   
06788   arg1 = &temp1;
06789   arg2 = &temp2;
06790   arg3 = &temp3;
06791   arg4 = &temp4;
06792   arg5 = &temp5;
06793   arg6 = &temp6;
06794   if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
06795   plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
06796   resultobj = SWIG_Py_Void();
06797   if (SWIG_IsTmpObj(res1)) {
06798     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06799   } else {
06800     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06801     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06802   }
06803   if (SWIG_IsTmpObj(res2)) {
06804     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06805   } else {
06806     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06807     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06808   }
06809   if (SWIG_IsTmpObj(res3)) {
06810     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06811   } else {
06812     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06813     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06814   }
06815   if (SWIG_IsTmpObj(res4)) {
06816     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06817   } else {
06818     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06819     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06820   }
06821   if (SWIG_IsTmpObj(res5)) {
06822     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
06823   } else {
06824     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06825     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
06826   }
06827   if (SWIG_IsTmpObj(res6)) {
06828     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
06829   } else {
06830     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06831     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
06832   }
06833   return resultobj;
06834 fail:
06835   return NULL;
06836 }
06837 
06838 
06839 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06840   PyObject *resultobj = 0;
06841   
06842   if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
06843   plgra();
06844   resultobj = SWIG_Py_Void();
06845   return resultobj;
06846 fail:
06847   return NULL;
06848 }
06849 
06850 
06851 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06852   PyObject *resultobj = 0;
06853   PLFLT *arg1 = (PLFLT *) 0 ;
06854   PLFLT *arg2 = (PLFLT *) 0 ;
06855   PLFLT *arg3 = (PLFLT *) 0 ;
06856   PLINT arg4 ;
06857   PLFLT *arg5 = (PLFLT *) 0 ;
06858   PLINT arg6 ;
06859   PLFLT *arg7 = (PLFLT *) 0 ;
06860   PLINT arg8 ;
06861   PLFLT **arg9 = (PLFLT **) 0 ;
06862   PLINT arg10 ;
06863   PLFLT arg11 ;
06864   PyArrayObject *tmp1 ;
06865   PyArrayObject *tmp2 ;
06866   PyArrayObject *tmp3 ;
06867   PyArrayObject *tmp5 ;
06868   PyArrayObject *tmp7 ;
06869   PyArrayObject *tmp9 ;
06870   int val10 ;
06871   int ecode10 = 0 ;
06872   double val11 ;
06873   int ecode11 = 0 ;
06874   PyObject * obj0 = 0 ;
06875   PyObject * obj1 = 0 ;
06876   PyObject * obj2 = 0 ;
06877   PyObject * obj3 = 0 ;
06878   PyObject * obj4 = 0 ;
06879   PyObject * obj5 = 0 ;
06880   PyObject * obj6 = 0 ;
06881   PyObject * obj7 = 0 ;
06882   
06883   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
06884   {
06885     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
06886     if ( tmp1 == NULL )
06887     return NULL;
06888     Alen = tmp1->dimensions[0];
06889     arg1   = (PLFLT *) tmp1->data;
06890   }
06891   {
06892     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
06893     if ( tmp2 == NULL )
06894     return NULL;
06895     if ( tmp2->dimensions[0] != Alen )
06896     {
06897       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06898       return NULL;
06899     }
06900     arg2 = (PLFLT *) tmp2->data;
06901   }
06902   {
06903     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
06904     if ( tmp3 == NULL )
06905     return NULL;
06906     if ( tmp3->dimensions[0] != Alen )
06907     {
06908       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06909       return NULL;
06910     }
06911     arg3 = (PLFLT *) tmp3->data;
06912     arg4 = tmp3->dimensions[0];
06913   }
06914   {
06915     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
06916     if ( tmp5 == NULL )
06917     return NULL;
06918     Xlen = tmp5->dimensions[0];
06919     arg6   = Xlen;
06920     arg5   = (PLFLT *) tmp5->data;
06921   }
06922   {
06923     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
06924     if ( tmp7 == NULL )
06925     return NULL;
06926     Ylen = tmp7->dimensions[0];
06927     arg8   = Ylen;
06928     arg7   = (PLFLT *) tmp7->data;
06929   }
06930   {
06931     int i, size;
06932     tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 2, 2 );
06933     if ( tmp9 == NULL )
06934     return NULL;
06935     if ( tmp9->dimensions[0] != Xlen || tmp9->dimensions[1] != Ylen )
06936     {
06937       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
06938       return NULL;
06939     }
06940     size = sizeof ( PLFLT ) * Ylen;
06941     arg9   = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
06942     for ( i = 0; i < Xlen; i++ )
06943     arg9[i] = (PLFLT *) ( tmp9->data + i * size );
06944   }
06945   ecode10 = SWIG_AsVal_int(obj6, &val10);
06946   if (!SWIG_IsOK(ecode10)) {
06947     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
06948   } 
06949   arg10 = (PLINT)(val10);
06950   ecode11 = SWIG_AsVal_double(obj7, &val11);
06951   if (!SWIG_IsOK(ecode11)) {
06952     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
06953   } 
06954   arg11 = (PLFLT)(val11);
06955   plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
06956   resultobj = SWIG_Py_Void();
06957   {
06958     Py_DECREF( tmp1 );
06959   }
06960   {
06961     Py_DECREF( tmp2 );
06962   }
06963   {
06964     Py_DECREF( tmp3 );
06965   }
06966   {
06967     Py_DECREF( tmp5 );
06968   }
06969   {
06970     Py_DECREF( tmp7 );
06971   }
06972   {
06973     Py_DECREF( tmp9 );
06974     free( arg9 );
06975   }
06976   return resultobj;
06977 fail:
06978   {
06979     Py_DECREF( tmp1 );
06980   }
06981   {
06982     Py_DECREF( tmp2 );
06983   }
06984   {
06985     Py_DECREF( tmp3 );
06986   }
06987   {
06988     Py_DECREF( tmp5 );
06989   }
06990   {
06991     Py_DECREF( tmp7 );
06992   }
06993   {
06994     Py_DECREF( tmp9 );
06995     free( arg9 );
06996   }
06997   return NULL;
06998 }
06999 
07000 
07001 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07002   PyObject *resultobj = 0;
07003   PLFLT *arg1 = (PLFLT *) 0 ;
07004   PLFLT *arg2 = (PLFLT *) 0 ;
07005   PLFLT *arg3 = (PLFLT *) 0 ;
07006   PLFLT *arg4 = (PLFLT *) 0 ;
07007   PLFLT temp1 ;
07008   int res1 = SWIG_TMPOBJ ;
07009   PLFLT temp2 ;
07010   int res2 = SWIG_TMPOBJ ;
07011   PLFLT temp3 ;
07012   int res3 = SWIG_TMPOBJ ;
07013   PLFLT temp4 ;
07014   int res4 = SWIG_TMPOBJ ;
07015   
07016   arg1 = &temp1;
07017   arg2 = &temp2;
07018   arg3 = &temp3;
07019   arg4 = &temp4;
07020   if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
07021   plgspa(arg1,arg2,arg3,arg4);
07022   resultobj = SWIG_Py_Void();
07023   if (SWIG_IsTmpObj(res1)) {
07024     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07025   } else {
07026     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07027     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07028   }
07029   if (SWIG_IsTmpObj(res2)) {
07030     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07031   } else {
07032     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07033     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07034   }
07035   if (SWIG_IsTmpObj(res3)) {
07036     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07037   } else {
07038     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07039     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07040   }
07041   if (SWIG_IsTmpObj(res4)) {
07042     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07043   } else {
07044     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07045     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07046   }
07047   return resultobj;
07048 fail:
07049   return NULL;
07050 }
07051 
07052 
07053 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07054   PyObject *resultobj = 0;
07055   PLINT *arg1 = (PLINT *) 0 ;
07056   PLINT temp1 ;
07057   int res1 = SWIG_TMPOBJ ;
07058   
07059   arg1 = &temp1;
07060   if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
07061   plgstrm(arg1);
07062   resultobj = SWIG_Py_Void();
07063   if (SWIG_IsTmpObj(res1)) {
07064     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07065   } else {
07066     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07067     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07068   }
07069   return resultobj;
07070 fail:
07071   return NULL;
07072 }
07073 
07074 
07075 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07076   PyObject *resultobj = 0;
07077   char *arg1 = (char *) 0 ;
07078   char buff1[1000] ;
07079   
07080   {
07081     arg1 = buff1;
07082   }
07083   if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
07084   plgver(arg1);
07085   resultobj = SWIG_Py_Void();
07086   {
07087     PyObject *o = PyString_FromString( arg1 );
07088     resultobj = t_output_helper( resultobj, o );
07089   }
07090   return resultobj;
07091 fail:
07092   return NULL;
07093 }
07094 
07095 
07096 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07097   PyObject *resultobj = 0;
07098   PLFLT *arg1 = (PLFLT *) 0 ;
07099   PLFLT *arg2 = (PLFLT *) 0 ;
07100   PLFLT *arg3 = (PLFLT *) 0 ;
07101   PLFLT *arg4 = (PLFLT *) 0 ;
07102   PLFLT temp1 ;
07103   int res1 = SWIG_TMPOBJ ;
07104   PLFLT temp2 ;
07105   int res2 = SWIG_TMPOBJ ;
07106   PLFLT temp3 ;
07107   int res3 = SWIG_TMPOBJ ;
07108   PLFLT temp4 ;
07109   int res4 = SWIG_TMPOBJ ;
07110   
07111   arg1 = &temp1;
07112   arg2 = &temp2;
07113   arg3 = &temp3;
07114   arg4 = &temp4;
07115   if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
07116   plgvpd(arg1,arg2,arg3,arg4);
07117   resultobj = SWIG_Py_Void();
07118   if (SWIG_IsTmpObj(res1)) {
07119     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07120   } else {
07121     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07122     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07123   }
07124   if (SWIG_IsTmpObj(res2)) {
07125     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07126   } else {
07127     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07128     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07129   }
07130   if (SWIG_IsTmpObj(res3)) {
07131     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07132   } else {
07133     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07134     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07135   }
07136   if (SWIG_IsTmpObj(res4)) {
07137     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07138   } else {
07139     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07140     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07141   }
07142   return resultobj;
07143 fail:
07144   return NULL;
07145 }
07146 
07147 
07148 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07149   PyObject *resultobj = 0;
07150   PLFLT *arg1 = (PLFLT *) 0 ;
07151   PLFLT *arg2 = (PLFLT *) 0 ;
07152   PLFLT *arg3 = (PLFLT *) 0 ;
07153   PLFLT *arg4 = (PLFLT *) 0 ;
07154   PLFLT temp1 ;
07155   int res1 = SWIG_TMPOBJ ;
07156   PLFLT temp2 ;
07157   int res2 = SWIG_TMPOBJ ;
07158   PLFLT temp3 ;
07159   int res3 = SWIG_TMPOBJ ;
07160   PLFLT temp4 ;
07161   int res4 = SWIG_TMPOBJ ;
07162   
07163   arg1 = &temp1;
07164   arg2 = &temp2;
07165   arg3 = &temp3;
07166   arg4 = &temp4;
07167   if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
07168   plgvpw(arg1,arg2,arg3,arg4);
07169   resultobj = SWIG_Py_Void();
07170   if (SWIG_IsTmpObj(res1)) {
07171     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07172   } else {
07173     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07174     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07175   }
07176   if (SWIG_IsTmpObj(res2)) {
07177     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07178   } else {
07179     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07180     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07181   }
07182   if (SWIG_IsTmpObj(res3)) {
07183     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07184   } else {
07185     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07186     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07187   }
07188   if (SWIG_IsTmpObj(res4)) {
07189     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07190   } else {
07191     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07192     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07193   }
07194   return resultobj;
07195 fail:
07196   return NULL;
07197 }
07198 
07199 
07200 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07201   PyObject *resultobj = 0;
07202   PLINT *arg1 = (PLINT *) 0 ;
07203   PLINT *arg2 = (PLINT *) 0 ;
07204   PLINT temp1 ;
07205   int res1 = SWIG_TMPOBJ ;
07206   PLINT temp2 ;
07207   int res2 = SWIG_TMPOBJ ;
07208   
07209   arg1 = &temp1;
07210   arg2 = &temp2;
07211   if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
07212   plgxax(arg1,arg2);
07213   resultobj = SWIG_Py_Void();
07214   if (SWIG_IsTmpObj(res1)) {
07215     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07216   } else {
07217     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07218     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07219   }
07220   if (SWIG_IsTmpObj(res2)) {
07221     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07222   } else {
07223     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07224     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07225   }
07226   return resultobj;
07227 fail:
07228   return NULL;
07229 }
07230 
07231 
07232 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07233   PyObject *resultobj = 0;
07234   PLINT *arg1 = (PLINT *) 0 ;
07235   PLINT *arg2 = (PLINT *) 0 ;
07236   PLINT temp1 ;
07237   int res1 = SWIG_TMPOBJ ;
07238   PLINT temp2 ;
07239   int res2 = SWIG_TMPOBJ ;
07240   
07241   arg1 = &temp1;
07242   arg2 = &temp2;
07243   if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
07244   plgyax(arg1,arg2);
07245   resultobj = SWIG_Py_Void();
07246   if (SWIG_IsTmpObj(res1)) {
07247     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07248   } else {
07249     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07250     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07251   }
07252   if (SWIG_IsTmpObj(res2)) {
07253     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07254   } else {
07255     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07256     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07257   }
07258   return resultobj;
07259 fail:
07260   return NULL;
07261 }
07262 
07263 
07264 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07265   PyObject *resultobj = 0;
07266   PLINT *arg1 = (PLINT *) 0 ;
07267   PLINT *arg2 = (PLINT *) 0 ;
07268   PLINT temp1 ;
07269   int res1 = SWIG_TMPOBJ ;
07270   PLINT temp2 ;
07271   int res2 = SWIG_TMPOBJ ;
07272   
07273   arg1 = &temp1;
07274   arg2 = &temp2;
07275   if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
07276   plgzax(arg1,arg2);
07277   resultobj = SWIG_Py_Void();
07278   if (SWIG_IsTmpObj(res1)) {
07279     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07280   } else {
07281     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07282     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07283   }
07284   if (SWIG_IsTmpObj(res2)) {
07285     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07286   } else {
07287     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07288     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07289   }
07290   return resultobj;
07291 fail:
07292   return NULL;
07293 }
07294 
07295 
07296 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07297   PyObject *resultobj = 0;
07298   PLINT arg1 ;
07299   PLFLT *arg2 = (PLFLT *) 0 ;
07300   PLFLT arg3 ;
07301   PLFLT arg4 ;
07302   PLINT arg5 ;
07303   PLINT arg6 ;
07304   PyArrayObject *tmp1 ;
07305   double val3 ;
07306   int ecode3 = 0 ;
07307   double val4 ;
07308   int ecode4 = 0 ;
07309   int val5 ;
07310   int ecode5 = 0 ;
07311   int val6 ;
07312   int ecode6 = 0 ;
07313   PyObject * obj0 = 0 ;
07314   PyObject * obj1 = 0 ;
07315   PyObject * obj2 = 0 ;
07316   PyObject * obj3 = 0 ;
07317   PyObject * obj4 = 0 ;
07318   
07319   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
07320   {
07321     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
07322     if ( tmp1 == NULL )
07323     return NULL;
07324     arg1 = Alen = tmp1->dimensions[0];
07325     arg2 = (PLFLT *) tmp1->data;
07326   }
07327   ecode3 = SWIG_AsVal_double(obj1, &val3);
07328   if (!SWIG_IsOK(ecode3)) {
07329     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
07330   } 
07331   arg3 = (PLFLT)(val3);
07332   ecode4 = SWIG_AsVal_double(obj2, &val4);
07333   if (!SWIG_IsOK(ecode4)) {
07334     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
07335   } 
07336   arg4 = (PLFLT)(val4);
07337   ecode5 = SWIG_AsVal_int(obj3, &val5);
07338   if (!SWIG_IsOK(ecode5)) {
07339     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
07340   } 
07341   arg5 = (PLINT)(val5);
07342   ecode6 = SWIG_AsVal_int(obj4, &val6);
07343   if (!SWIG_IsOK(ecode6)) {
07344     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
07345   } 
07346   arg6 = (PLINT)(val6);
07347   plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
07348   resultobj = SWIG_Py_Void();
07349   {
07350     Py_DECREF( tmp1 );
07351   }
07352   return resultobj;
07353 fail:
07354   {
07355     Py_DECREF( tmp1 );
07356   }
07357   return NULL;
07358 }
07359 
07360 
07361 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07362   PyObject *resultobj = 0;
07363   PLFLT arg1 ;
07364   PLFLT arg2 ;
07365   PLFLT arg3 ;
07366   PLFLT *arg4 = (PLFLT *) 0 ;
07367   PLFLT *arg5 = (PLFLT *) 0 ;
07368   PLFLT *arg6 = (PLFLT *) 0 ;
07369   double val1 ;
07370   int ecode1 = 0 ;
07371   double val2 ;
07372   int ecode2 = 0 ;
07373   double val3 ;
07374   int ecode3 = 0 ;
07375   PLFLT temp4 ;
07376   int res4 = SWIG_TMPOBJ ;
07377   PLFLT temp5 ;
07378   int res5 = SWIG_TMPOBJ ;
07379   PLFLT temp6 ;
07380   int res6 = SWIG_TMPOBJ ;
07381   PyObject * obj0 = 0 ;
07382   PyObject * obj1 = 0 ;
07383   PyObject * obj2 = 0 ;
07384   
07385   arg4 = &temp4;
07386   arg5 = &temp5;
07387   arg6 = &temp6;
07388   if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
07389   ecode1 = SWIG_AsVal_double(obj0, &val1);
07390   if (!SWIG_IsOK(ecode1)) {
07391     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
07392   } 
07393   arg1 = (PLFLT)(val1);
07394   ecode2 = SWIG_AsVal_double(obj1, &val2);
07395   if (!SWIG_IsOK(ecode2)) {
07396     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
07397   } 
07398   arg2 = (PLFLT)(val2);
07399   ecode3 = SWIG_AsVal_double(obj2, &val3);
07400   if (!SWIG_IsOK(ecode3)) {
07401     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
07402   } 
07403   arg3 = (PLFLT)(val3);
07404   plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
07405   resultobj = SWIG_Py_Void();
07406   if (SWIG_IsTmpObj(res4)) {
07407     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07408   } else {
07409     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07410     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07411   }
07412   if (SWIG_IsTmpObj(res5)) {
07413     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
07414   } else {
07415     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07416     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
07417   }
07418   if (SWIG_IsTmpObj(res6)) {
07419     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
07420   } else {
07421     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07422     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
07423   }
07424   return resultobj;
07425 fail:
07426   return NULL;
07427 }
07428 
07429 
07430 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07431   PyObject *resultobj = 0;
07432   
07433   if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
07434   plinit();
07435   resultobj = SWIG_Py_Void();
07436   return resultobj;
07437 fail:
07438   return NULL;
07439 }
07440 
07441 
07442 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07443   PyObject *resultobj = 0;
07444   PLFLT arg1 ;
07445   PLFLT arg2 ;
07446   PLFLT arg3 ;
07447   PLFLT arg4 ;
07448   double val1 ;
07449   int ecode1 = 0 ;
07450   double val2 ;
07451   int ecode2 = 0 ;
07452   double val3 ;
07453   int ecode3 = 0 ;
07454   double val4 ;
07455   int ecode4 = 0 ;
07456   PyObject * obj0 = 0 ;
07457   PyObject * obj1 = 0 ;
07458   PyObject * obj2 = 0 ;
07459   PyObject * obj3 = 0 ;
07460   
07461   if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07462   ecode1 = SWIG_AsVal_double(obj0, &val1);
07463   if (!SWIG_IsOK(ecode1)) {
07464     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
07465   } 
07466   arg1 = (PLFLT)(val1);
07467   ecode2 = SWIG_AsVal_double(obj1, &val2);
07468   if (!SWIG_IsOK(ecode2)) {
07469     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
07470   } 
07471   arg2 = (PLFLT)(val2);
07472   ecode3 = SWIG_AsVal_double(obj2, &val3);
07473   if (!SWIG_IsOK(ecode3)) {
07474     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
07475   } 
07476   arg3 = (PLFLT)(val3);
07477   ecode4 = SWIG_AsVal_double(obj3, &val4);
07478   if (!SWIG_IsOK(ecode4)) {
07479     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
07480   } 
07481   arg4 = (PLFLT)(val4);
07482   pljoin(arg1,arg2,arg3,arg4);
07483   resultobj = SWIG_Py_Void();
07484   return resultobj;
07485 fail:
07486   return NULL;
07487 }
07488 
07489 
07490 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07491   PyObject *resultobj = 0;
07492   char *arg1 = (char *) 0 ;
07493   char *arg2 = (char *) 0 ;
07494   char *arg3 = (char *) 0 ;
07495   int res1 ;
07496   char *buf1 = 0 ;
07497   int alloc1 = 0 ;
07498   int res2 ;
07499   char *buf2 = 0 ;
07500   int alloc2 = 0 ;
07501   int res3 ;
07502   char *buf3 = 0 ;
07503   int alloc3 = 0 ;
07504   PyObject * obj0 = 0 ;
07505   PyObject * obj1 = 0 ;
07506   PyObject * obj2 = 0 ;
07507   
07508   if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
07509   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
07510   if (!SWIG_IsOK(res1)) {
07511     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
07512   }
07513   arg1 = (char *)(buf1);
07514   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07515   if (!SWIG_IsOK(res2)) {
07516     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
07517   }
07518   arg2 = (char *)(buf2);
07519   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
07520   if (!SWIG_IsOK(res3)) {
07521     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
07522   }
07523   arg3 = (char *)(buf3);
07524   pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
07525   resultobj = SWIG_Py_Void();
07526   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07527   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07528   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07529   return resultobj;
07530 fail:
07531   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07532   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07533   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07534   return NULL;
07535 }
07536 
07537 
07538 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07539   PyObject *resultobj = 0;
07540   PLFLT *arg1 = (PLFLT *) 0 ;
07541   PLFLT *arg2 = (PLFLT *) 0 ;
07542   PLINT arg3 ;
07543   PLINT arg4 ;
07544   PLFLT arg5 ;
07545   PLFLT arg6 ;
07546   PLFLT arg7 ;
07547   PLINT arg8 ;
07548   PLINT arg9 ;
07549   PLINT arg10 ;
07550   PLINT arg11 ;
07551   PLINT arg12 ;
07552   PLINT arg13 ;
07553   PLINT *arg14 = (PLINT *) 0 ;
07554   PLFLT arg15 ;
07555   PLFLT arg16 ;
07556   PLFLT arg17 ;
07557   PLFLT arg18 ;
07558   PLINT *arg19 = (PLINT *) 0 ;
07559   char **arg20 = (char **) 0 ;
07560   PLINT *arg21 = (PLINT *) 0 ;
07561   PLINT *arg22 = (PLINT *) 0 ;
07562   PLFLT *arg23 = (PLFLT *) 0 ;
07563   PLINT *arg24 = (PLINT *) 0 ;
07564   PLINT *arg25 = (PLINT *) 0 ;
07565   PLINT *arg26 = (PLINT *) 0 ;
07566   PLINT *arg27 = (PLINT *) 0 ;
07567   PLINT *arg28 = (PLINT *) 0 ;
07568   PLFLT *arg29 = (PLFLT *) 0 ;
07569   PLINT *arg30 = (PLINT *) 0 ;
07570   char **arg31 = (char **) 0 ;
07571   PLFLT temp1 ;
07572   int res1 = SWIG_TMPOBJ ;
07573   PLFLT temp2 ;
07574   int res2 = SWIG_TMPOBJ ;
07575   int val3 ;
07576   int ecode3 = 0 ;
07577   int val4 ;
07578   int ecode4 = 0 ;
07579   double val5 ;
07580   int ecode5 = 0 ;
07581   double val6 ;
07582   int ecode6 = 0 ;
07583   double val7 ;
07584   int ecode7 = 0 ;
07585   int val8 ;
07586   int ecode8 = 0 ;
07587   int val9 ;
07588   int ecode9 = 0 ;
07589   int val10 ;
07590   int ecode10 = 0 ;
07591   int val11 ;
07592   int ecode11 = 0 ;
07593   int val12 ;
07594   int ecode12 = 0 ;
07595   PyArrayObject *tmp13 ;
07596   double val15 ;
07597   int ecode15 = 0 ;
07598   double val16 ;
07599   int ecode16 = 0 ;
07600   double val17 ;
07601   int ecode17 = 0 ;
07602   double val18 ;
07603   int ecode18 = 0 ;
07604   PyArrayObject *tmp19 ;
07605   PyArrayObject *tmp20 ;
07606   PyArrayObject *tmp21 ;
07607   PyArrayObject *tmp22 ;
07608   PyArrayObject *tmp23 ;
07609   PyArrayObject *tmp24 ;
07610   PyArrayObject *tmp25 ;
07611   PyArrayObject *tmp26 ;
07612   PyArrayObject *tmp27 ;
07613   PyArrayObject *tmp28 ;
07614   PyArrayObject *tmp29 ;
07615   PyArrayObject *tmp30 ;
07616   PyArrayObject *tmp31 ;
07617   PyObject * obj0 = 0 ;
07618   PyObject * obj1 = 0 ;
07619   PyObject * obj2 = 0 ;
07620   PyObject * obj3 = 0 ;
07621   PyObject * obj4 = 0 ;
07622   PyObject * obj5 = 0 ;
07623   PyObject * obj6 = 0 ;
07624   PyObject * obj7 = 0 ;
07625   PyObject * obj8 = 0 ;
07626   PyObject * obj9 = 0 ;
07627   PyObject * obj10 = 0 ;
07628   PyObject * obj11 = 0 ;
07629   PyObject * obj12 = 0 ;
07630   PyObject * obj13 = 0 ;
07631   PyObject * obj14 = 0 ;
07632   PyObject * obj15 = 0 ;
07633   PyObject * obj16 = 0 ;
07634   PyObject * obj17 = 0 ;
07635   PyObject * obj18 = 0 ;
07636   PyObject * obj19 = 0 ;
07637   PyObject * obj20 = 0 ;
07638   PyObject * obj21 = 0 ;
07639   PyObject * obj22 = 0 ;
07640   PyObject * obj23 = 0 ;
07641   PyObject * obj24 = 0 ;
07642   PyObject * obj25 = 0 ;
07643   PyObject * obj26 = 0 ;
07644   PyObject * obj27 = 0 ;
07645   
07646   arg1 = &temp1;
07647   arg2 = &temp2;
07648   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
07649   ecode3 = SWIG_AsVal_int(obj0, &val3);
07650   if (!SWIG_IsOK(ecode3)) {
07651     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
07652   } 
07653   arg3 = (PLINT)(val3);
07654   ecode4 = SWIG_AsVal_int(obj1, &val4);
07655   if (!SWIG_IsOK(ecode4)) {
07656     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
07657   } 
07658   arg4 = (PLINT)(val4);
07659   ecode5 = SWIG_AsVal_double(obj2, &val5);
07660   if (!SWIG_IsOK(ecode5)) {
07661     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
07662   } 
07663   arg5 = (PLFLT)(val5);
07664   ecode6 = SWIG_AsVal_double(obj3, &val6);
07665   if (!SWIG_IsOK(ecode6)) {
07666     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
07667   } 
07668   arg6 = (PLFLT)(val6);
07669   ecode7 = SWIG_AsVal_double(obj4, &val7);
07670   if (!SWIG_IsOK(ecode7)) {
07671     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
07672   } 
07673   arg7 = (PLFLT)(val7);
07674   ecode8 = SWIG_AsVal_int(obj5, &val8);
07675   if (!SWIG_IsOK(ecode8)) {
07676     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
07677   } 
07678   arg8 = (PLINT)(val8);
07679   ecode9 = SWIG_AsVal_int(obj6, &val9);
07680   if (!SWIG_IsOK(ecode9)) {
07681     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
07682   } 
07683   arg9 = (PLINT)(val9);
07684   ecode10 = SWIG_AsVal_int(obj7, &val10);
07685   if (!SWIG_IsOK(ecode10)) {
07686     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
07687   } 
07688   arg10 = (PLINT)(val10);
07689   ecode11 = SWIG_AsVal_int(obj8, &val11);
07690   if (!SWIG_IsOK(ecode11)) {
07691     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
07692   } 
07693   arg11 = (PLINT)(val11);
07694   ecode12 = SWIG_AsVal_int(obj9, &val12);
07695   if (!SWIG_IsOK(ecode12)) {
07696     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
07697   } 
07698   arg12 = (PLINT)(val12);
07699   {
07700     tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, PyArray_PLINT, 1, 1 );
07701     if ( tmp13 == NULL )
07702     return NULL;
07703     arg13 = Alen = tmp13->dimensions[0];
07704     arg14 = (PLINT *) tmp13->data;
07705   }
07706   ecode15 = SWIG_AsVal_double(obj11, &val15);
07707   if (!SWIG_IsOK(ecode15)) {
07708     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
07709   } 
07710   arg15 = (PLFLT)(val15);
07711   ecode16 = SWIG_AsVal_double(obj12, &val16);
07712   if (!SWIG_IsOK(ecode16)) {
07713     SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
07714   } 
07715   arg16 = (PLFLT)(val16);
07716   ecode17 = SWIG_AsVal_double(obj13, &val17);
07717   if (!SWIG_IsOK(ecode17)) {
07718     SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
07719   } 
07720   arg17 = (PLFLT)(val17);
07721   ecode18 = SWIG_AsVal_double(obj14, &val18);
07722   if (!SWIG_IsOK(ecode18)) {
07723     SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
07724   } 
07725   arg18 = (PLFLT)(val18);
07726   {
07727     tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, PyArray_PLINT, 1, 1 );
07728     if ( tmp19 == NULL )
07729     return NULL;
07730     if ( tmp19->dimensions[0] != Alen )
07731     {
07732       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07733       return NULL;
07734     }
07735     arg19 = (PLINT *) tmp19->data;
07736   }
07737   {
07738     int i;
07739     tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
07740     if ( tmp20 == NULL )
07741     return NULL;
07742     if ( tmp20->dimensions[0] != Alen )
07743     {
07744       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07745       return NULL;
07746     }
07747     arg20 = (char **) malloc( sizeof ( char* ) * Alen );
07748     for ( i = 0; i < Alen; i++ )
07749     {
07750       arg20[i] = tmp20->data + i * tmp20->strides[0];
07751       if ( arg20[i] == NULL )
07752       {
07753         free( arg20 );
07754         return NULL;
07755       }
07756     }
07757   }
07758   {
07759     tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, PyArray_PLINT, 1, 1 );
07760     if ( tmp21 == NULL )
07761     return NULL;
07762     if ( tmp21->dimensions[0] != Alen )
07763     {
07764       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07765       return NULL;
07766     }
07767     arg21 = (PLINT *) tmp21->data;
07768   }
07769   {
07770     tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, PyArray_PLINT, 1, 1 );
07771     if ( tmp22 == NULL )
07772     return NULL;
07773     if ( tmp22->dimensions[0] != Alen )
07774     {
07775       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07776       return NULL;
07777     }
07778     arg22 = (PLINT *) tmp22->data;
07779   }
07780   {
07781     tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, PyArray_PLFLT, 1, 1 );
07782     if ( tmp23 == NULL )
07783     return NULL;
07784     if ( tmp23->dimensions[0] != Alen )
07785     {
07786       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07787       return NULL;
07788     }
07789     arg23 = (PLFLT *) tmp23->data;
07790   }
07791   {
07792     tmp24 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj20, PyArray_PLINT, 1, 1 );
07793     if ( tmp24 == NULL )
07794     return NULL;
07795     if ( tmp24->dimensions[0] != Alen )
07796     {
07797       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07798       return NULL;
07799     }
07800     arg24 = (PLINT *) tmp24->data;
07801   }
07802   {
07803     tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, PyArray_PLINT, 1, 1 );
07804     if ( tmp25 == NULL )
07805     return NULL;
07806     if ( tmp25->dimensions[0] != Alen )
07807     {
07808       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07809       return NULL;
07810     }
07811     arg25 = (PLINT *) tmp25->data;
07812   }
07813   {
07814     tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, PyArray_PLINT, 1, 1 );
07815     if ( tmp26 == NULL )
07816     return NULL;
07817     if ( tmp26->dimensions[0] != Alen )
07818     {
07819       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07820       return NULL;
07821     }
07822     arg26 = (PLINT *) tmp26->data;
07823   }
07824   {
07825     tmp27 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj23, PyArray_PLINT, 1, 1 );
07826     if ( tmp27 == NULL )
07827     return NULL;
07828     if ( tmp27->dimensions[0] != Alen )
07829     {
07830       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07831       return NULL;
07832     }
07833     arg27 = (PLINT *) tmp27->data;
07834   }
07835   {
07836     tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, PyArray_PLINT, 1, 1 );
07837     if ( tmp28 == NULL )
07838     return NULL;
07839     if ( tmp28->dimensions[0] != Alen )
07840     {
07841       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07842       return NULL;
07843     }
07844     arg28 = (PLINT *) tmp28->data;
07845   }
07846   {
07847     tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, PyArray_PLFLT, 1, 1 );
07848     if ( tmp29 == NULL )
07849     return NULL;
07850     if ( tmp29->dimensions[0] != Alen )
07851     {
07852       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07853       return NULL;
07854     }
07855     arg29 = (PLFLT *) tmp29->data;
07856   }
07857   {
07858     tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, PyArray_PLINT, 1, 1 );
07859     if ( tmp30 == NULL )
07860     return NULL;
07861     if ( tmp30->dimensions[0] != Alen )
07862     {
07863       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07864       return NULL;
07865     }
07866     arg30 = (PLINT *) tmp30->data;
07867   }
07868   {
07869     int i;
07870     tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
07871     if ( tmp31 == NULL )
07872     return NULL;
07873     if ( tmp31->dimensions[0] != Alen )
07874     {
07875       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07876       return NULL;
07877     }
07878     arg31 = (char **) malloc( sizeof ( char* ) * Alen );
07879     for ( i = 0; i < Alen; i++ )
07880     {
07881       arg31[i] = tmp31->data + i * tmp31->strides[0];
07882       if ( arg31[i] == NULL )
07883       {
07884         free( arg31 );
07885         return NULL;
07886       }
07887     }
07888   }
07889   pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(int const *)arg24,(int const *)arg25,(int const *)arg26,(int const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
07890   resultobj = SWIG_Py_Void();
07891   if (SWIG_IsTmpObj(res1)) {
07892     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07893   } else {
07894     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07895     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07896   }
07897   if (SWIG_IsTmpObj(res2)) {
07898     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07899   } else {
07900     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07901     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07902   }
07903   {
07904     Py_DECREF( tmp13 );
07905   }
07906   {
07907     Py_DECREF( tmp19 );
07908   }
07909   {
07910     Py_DECREF( tmp20 ); free( arg20 );
07911   }
07912   {
07913     Py_DECREF( tmp21 );
07914   }
07915   {
07916     Py_DECREF( tmp22 );
07917   }
07918   {
07919     Py_DECREF( tmp23 );
07920   }
07921   {
07922     Py_DECREF( tmp24 );
07923   }
07924   {
07925     Py_DECREF( tmp25 );
07926   }
07927   {
07928     Py_DECREF( tmp26 );
07929   }
07930   {
07931     Py_DECREF( tmp27 );
07932   }
07933   {
07934     Py_DECREF( tmp28 );
07935   }
07936   {
07937     Py_DECREF( tmp29 );
07938   }
07939   {
07940     Py_DECREF( tmp30 );
07941   }
07942   {
07943     Py_DECREF( tmp31 ); free( arg31 );
07944   }
07945   return resultobj;
07946 fail:
07947   {
07948     Py_DECREF( tmp13 );
07949   }
07950   {
07951     Py_DECREF( tmp19 );
07952   }
07953   {
07954     Py_DECREF( tmp20 ); free( arg20 );
07955   }
07956   {
07957     Py_DECREF( tmp21 );
07958   }
07959   {
07960     Py_DECREF( tmp22 );
07961   }
07962   {
07963     Py_DECREF( tmp23 );
07964   }
07965   {
07966     Py_DECREF( tmp24 );
07967   }
07968   {
07969     Py_DECREF( tmp25 );
07970   }
07971   {
07972     Py_DECREF( tmp26 );
07973   }
07974   {
07975     Py_DECREF( tmp27 );
07976   }
07977   {
07978     Py_DECREF( tmp28 );
07979   }
07980   {
07981     Py_DECREF( tmp29 );
07982   }
07983   {
07984     Py_DECREF( tmp30 );
07985   }
07986   {
07987     Py_DECREF( tmp31 ); free( arg31 );
07988   }
07989   return NULL;
07990 }
07991 
07992 
07993 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07994   PyObject *resultobj = 0;
07995   PLFLT arg1 ;
07996   PLFLT arg2 ;
07997   PLFLT arg3 ;
07998   double val1 ;
07999   int ecode1 = 0 ;
08000   double val2 ;
08001   int ecode2 = 0 ;
08002   double val3 ;
08003   int ecode3 = 0 ;
08004   PyObject * obj0 = 0 ;
08005   PyObject * obj1 = 0 ;
08006   PyObject * obj2 = 0 ;
08007   
08008   if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
08009   ecode1 = SWIG_AsVal_double(obj0, &val1);
08010   if (!SWIG_IsOK(ecode1)) {
08011     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
08012   } 
08013   arg1 = (PLFLT)(val1);
08014   ecode2 = SWIG_AsVal_double(obj1, &val2);
08015   if (!SWIG_IsOK(ecode2)) {
08016     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
08017   } 
08018   arg2 = (PLFLT)(val2);
08019   ecode3 = SWIG_AsVal_double(obj2, &val3);
08020   if (!SWIG_IsOK(ecode3)) {
08021     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
08022   } 
08023   arg3 = (PLFLT)(val3);
08024   pllightsource(arg1,arg2,arg3);
08025   resultobj = SWIG_Py_Void();
08026   return resultobj;
08027 fail:
08028   return NULL;
08029 }
08030 
08031 
08032 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08033   PyObject *resultobj = 0;
08034   PLINT arg1 ;
08035   PLFLT *arg2 = (PLFLT *) 0 ;
08036   PLFLT *arg3 = (PLFLT *) 0 ;
08037   PyArrayObject *tmp1 ;
08038   PyArrayObject *tmp3 ;
08039   PyObject * obj0 = 0 ;
08040   PyObject * obj1 = 0 ;
08041   
08042   if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
08043   {
08044     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08045     if ( tmp1 == NULL )
08046     return NULL;
08047     arg1 = Alen = tmp1->dimensions[0];
08048     arg2 = (PLFLT *) tmp1->data;
08049   }
08050   {
08051     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08052     if ( tmp3 == NULL )
08053     return NULL;
08054     if ( tmp3->dimensions[0] != Alen )
08055     {
08056       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08057       return NULL;
08058     }
08059     arg3 = (PLFLT *) tmp3->data;
08060   }
08061   plline(arg1,(double const *)arg2,(double const *)arg3);
08062   resultobj = SWIG_Py_Void();
08063   {
08064     Py_DECREF( tmp1 );
08065   }
08066   {
08067     Py_DECREF( tmp3 );
08068   }
08069   return resultobj;
08070 fail:
08071   {
08072     Py_DECREF( tmp1 );
08073   }
08074   {
08075     Py_DECREF( tmp3 );
08076   }
08077   return NULL;
08078 }
08079 
08080 
08081 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08082   PyObject *resultobj = 0;
08083   PLINT arg1 ;
08084   PLFLT *arg2 = (PLFLT *) 0 ;
08085   PLFLT *arg3 = (PLFLT *) 0 ;
08086   PLFLT *arg4 = (PLFLT *) 0 ;
08087   PyArrayObject *tmp1 ;
08088   PyArrayObject *tmp3 ;
08089   PyArrayObject *tmp4 ;
08090   PyObject * obj0 = 0 ;
08091   PyObject * obj1 = 0 ;
08092   PyObject * obj2 = 0 ;
08093   
08094   if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
08095   {
08096     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08097     if ( tmp1 == NULL )
08098     return NULL;
08099     arg1 = Alen = tmp1->dimensions[0];
08100     arg2 = (PLFLT *) tmp1->data;
08101   }
08102   {
08103     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08104     if ( tmp3 == NULL )
08105     return NULL;
08106     if ( tmp3->dimensions[0] != Alen )
08107     {
08108       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08109       return NULL;
08110     }
08111     arg3 = (PLFLT *) tmp3->data;
08112   }
08113   {
08114     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
08115     if ( tmp4 == NULL )
08116     return NULL;
08117     if ( tmp4->dimensions[0] != Alen )
08118     {
08119       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08120       return NULL;
08121     }
08122     arg4 = (PLFLT *) tmp4->data;
08123   }
08124   plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
08125   resultobj = SWIG_Py_Void();
08126   {
08127     Py_DECREF( tmp1 );
08128   }
08129   {
08130     Py_DECREF( tmp3 );
08131   }
08132   {
08133     Py_DECREF( tmp4 );
08134   }
08135   return resultobj;
08136 fail:
08137   {
08138     Py_DECREF( tmp1 );
08139   }
08140   {
08141     Py_DECREF( tmp3 );
08142   }
08143   {
08144     Py_DECREF( tmp4 );
08145   }
08146   return NULL;
08147 }
08148 
08149 
08150 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08151   PyObject *resultobj = 0;
08152   PLINT arg1 ;
08153   int val1 ;
08154   int ecode1 = 0 ;
08155   PyObject * obj0 = 0 ;
08156   
08157   if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
08158   ecode1 = SWIG_AsVal_int(obj0, &val1);
08159   if (!SWIG_IsOK(ecode1)) {
08160     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
08161   } 
08162   arg1 = (PLINT)(val1);
08163   pllsty(arg1);
08164   resultobj = SWIG_Py_Void();
08165   return resultobj;
08166 fail:
08167   return NULL;
08168 }
08169 
08170 
08171 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08172   PyObject *resultobj = 0;
08173   PLFLT *arg1 = (PLFLT *) 0 ;
08174   PLFLT *arg2 = (PLFLT *) 0 ;
08175   PLFLT **arg3 = (PLFLT **) 0 ;
08176   PLINT arg4 ;
08177   PLINT arg5 ;
08178   PLINT arg6 ;
08179   PyArrayObject *tmp1 ;
08180   PyArrayObject *tmp2 ;
08181   PyArrayObject *tmp3 ;
08182   int val6 ;
08183   int ecode6 = 0 ;
08184   PyObject * obj0 = 0 ;
08185   PyObject * obj1 = 0 ;
08186   PyObject * obj2 = 0 ;
08187   PyObject * obj3 = 0 ;
08188   
08189   if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
08190   {
08191     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08192     if ( tmp1 == NULL )
08193     return NULL;
08194     Xlen = tmp1->dimensions[0];
08195     arg1   = (PLFLT *) tmp1->data;
08196   }
08197   {
08198     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08199     if ( tmp2 == NULL )
08200     return NULL;
08201     Ylen = tmp2->dimensions[0];
08202     arg2   = (PLFLT *) tmp2->data;
08203   }
08204   {
08205     int i, size;
08206     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08207     if ( tmp3 == NULL )
08208     return NULL;
08209     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08210     {
08211       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08212       return NULL;
08213     }
08214     arg4   = tmp3->dimensions[0];
08215     arg5   = tmp3->dimensions[1];
08216     size = sizeof ( PLFLT ) * arg5;
08217     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08218     for ( i = 0; i < arg4; i++ )
08219     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08220   }
08221   ecode6 = SWIG_AsVal_int(obj3, &val6);
08222   if (!SWIG_IsOK(ecode6)) {
08223     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
08224   } 
08225   arg6 = (PLINT)(val6);
08226   plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
08227   resultobj = SWIG_Py_Void();
08228   {
08229     Py_DECREF( tmp1 );
08230   }
08231   {
08232     Py_DECREF( tmp2 );
08233   }
08234   {
08235     Py_DECREF( tmp3 );
08236     free( arg3 );
08237   }
08238   return resultobj;
08239 fail:
08240   {
08241     Py_DECREF( tmp1 );
08242   }
08243   {
08244     Py_DECREF( tmp2 );
08245   }
08246   {
08247     Py_DECREF( tmp3 );
08248     free( arg3 );
08249   }
08250   return NULL;
08251 }
08252 
08253 
08254 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08255   PyObject *resultobj = 0;
08256   PLFLT *arg1 = (PLFLT *) 0 ;
08257   PLFLT *arg2 = (PLFLT *) 0 ;
08258   PLFLT **arg3 = (PLFLT **) 0 ;
08259   PLINT arg4 ;
08260   PLINT arg5 ;
08261   PLINT arg6 ;
08262   PLFLT *arg7 = (PLFLT *) 0 ;
08263   PLINT arg8 ;
08264   PyArrayObject *tmp1 ;
08265   PyArrayObject *tmp2 ;
08266   PyArrayObject *tmp3 ;
08267   int val6 ;
08268   int ecode6 = 0 ;
08269   PyArrayObject *tmp7 ;
08270   PyObject * obj0 = 0 ;
08271   PyObject * obj1 = 0 ;
08272   PyObject * obj2 = 0 ;
08273   PyObject * obj3 = 0 ;
08274   PyObject * obj4 = 0 ;
08275   
08276   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08277   {
08278     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08279     if ( tmp1 == NULL )
08280     return NULL;
08281     Xlen = tmp1->dimensions[0];
08282     arg1   = (PLFLT *) tmp1->data;
08283   }
08284   {
08285     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08286     if ( tmp2 == NULL )
08287     return NULL;
08288     Ylen = tmp2->dimensions[0];
08289     arg2   = (PLFLT *) tmp2->data;
08290   }
08291   {
08292     int i, size;
08293     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08294     if ( tmp3 == NULL )
08295     return NULL;
08296     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08297     {
08298       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08299       return NULL;
08300     }
08301     arg4   = tmp3->dimensions[0];
08302     arg5   = tmp3->dimensions[1];
08303     size = sizeof ( PLFLT ) * arg5;
08304     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08305     for ( i = 0; i < arg4; i++ )
08306     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08307   }
08308   ecode6 = SWIG_AsVal_int(obj3, &val6);
08309   if (!SWIG_IsOK(ecode6)) {
08310     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
08311   } 
08312   arg6 = (PLINT)(val6);
08313   {
08314     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08315     if ( tmp7 == NULL )
08316     return NULL;
08317     arg8 = tmp7->dimensions[0];
08318     arg7 = (PLFLT *) tmp7->data;
08319   }
08320   plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08321   resultobj = SWIG_Py_Void();
08322   {
08323     Py_DECREF( tmp1 );
08324   }
08325   {
08326     Py_DECREF( tmp2 );
08327   }
08328   {
08329     Py_DECREF( tmp3 );
08330     free( arg3 );
08331   }
08332   {
08333     Py_DECREF( tmp7 );
08334   }
08335   return resultobj;
08336 fail:
08337   {
08338     Py_DECREF( tmp1 );
08339   }
08340   {
08341     Py_DECREF( tmp2 );
08342   }
08343   {
08344     Py_DECREF( tmp3 );
08345     free( arg3 );
08346   }
08347   {
08348     Py_DECREF( tmp7 );
08349   }
08350   return NULL;
08351 }
08352 
08353 
08354 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08355   PyObject *resultobj = 0;
08356   PLINT *arg1 = (PLINT *) 0 ;
08357   PLINT temp1 ;
08358   int res1 = SWIG_TMPOBJ ;
08359   
08360   arg1 = &temp1;
08361   if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
08362   plmkstrm(arg1);
08363   resultobj = SWIG_Py_Void();
08364   if (SWIG_IsTmpObj(res1)) {
08365     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
08366   } else {
08367     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08368     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
08369   }
08370   return resultobj;
08371 fail:
08372   return NULL;
08373 }
08374 
08375 
08376 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08377   PyObject *resultobj = 0;
08378   char *arg1 = (char *) 0 ;
08379   PLFLT arg2 ;
08380   PLFLT arg3 ;
08381   PLFLT arg4 ;
08382   char *arg5 = (char *) 0 ;
08383   int res1 ;
08384   char *buf1 = 0 ;
08385   int alloc1 = 0 ;
08386   double val2 ;
08387   int ecode2 = 0 ;
08388   double val3 ;
08389   int ecode3 = 0 ;
08390   double val4 ;
08391   int ecode4 = 0 ;
08392   int res5 ;
08393   char *buf5 = 0 ;
08394   int alloc5 = 0 ;
08395   PyObject * obj0 = 0 ;
08396   PyObject * obj1 = 0 ;
08397   PyObject * obj2 = 0 ;
08398   PyObject * obj3 = 0 ;
08399   PyObject * obj4 = 0 ;
08400   
08401   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08402   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
08403   if (!SWIG_IsOK(res1)) {
08404     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
08405   }
08406   arg1 = (char *)(buf1);
08407   ecode2 = SWIG_AsVal_double(obj1, &val2);
08408   if (!SWIG_IsOK(ecode2)) {
08409     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
08410   } 
08411   arg2 = (PLFLT)(val2);
08412   ecode3 = SWIG_AsVal_double(obj2, &val3);
08413   if (!SWIG_IsOK(ecode3)) {
08414     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
08415   } 
08416   arg3 = (PLFLT)(val3);
08417   ecode4 = SWIG_AsVal_double(obj3, &val4);
08418   if (!SWIG_IsOK(ecode4)) {
08419     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
08420   } 
08421   arg4 = (PLFLT)(val4);
08422   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08423   if (!SWIG_IsOK(res5)) {
08424     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
08425   }
08426   arg5 = (char *)(buf5);
08427   plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
08428   resultobj = SWIG_Py_Void();
08429   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08430   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08431   return resultobj;
08432 fail:
08433   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08434   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08435   return NULL;
08436 }
08437 
08438 
08439 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08440   PyObject *resultobj = 0;
08441   char *arg1 = (char *) 0 ;
08442   PLFLT arg2 ;
08443   PLFLT arg3 ;
08444   PLFLT arg4 ;
08445   char *arg5 = (char *) 0 ;
08446   int res1 ;
08447   char *buf1 = 0 ;
08448   int alloc1 = 0 ;
08449   double val2 ;
08450   int ecode2 = 0 ;
08451   double val3 ;
08452   int ecode3 = 0 ;
08453   double val4 ;
08454   int ecode4 = 0 ;
08455   int res5 ;
08456   char *buf5 = 0 ;
08457   int alloc5 = 0 ;
08458   PyObject * obj0 = 0 ;
08459   PyObject * obj1 = 0 ;
08460   PyObject * obj2 = 0 ;
08461   PyObject * obj3 = 0 ;
08462   PyObject * obj4 = 0 ;
08463   
08464   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08465   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
08466   if (!SWIG_IsOK(res1)) {
08467     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
08468   }
08469   arg1 = (char *)(buf1);
08470   ecode2 = SWIG_AsVal_double(obj1, &val2);
08471   if (!SWIG_IsOK(ecode2)) {
08472     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
08473   } 
08474   arg2 = (PLFLT)(val2);
08475   ecode3 = SWIG_AsVal_double(obj2, &val3);
08476   if (!SWIG_IsOK(ecode3)) {
08477     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
08478   } 
08479   arg3 = (PLFLT)(val3);
08480   ecode4 = SWIG_AsVal_double(obj3, &val4);
08481   if (!SWIG_IsOK(ecode4)) {
08482     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
08483   } 
08484   arg4 = (PLFLT)(val4);
08485   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08486   if (!SWIG_IsOK(res5)) {
08487     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
08488   }
08489   arg5 = (char *)(buf5);
08490   plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
08491   resultobj = SWIG_Py_Void();
08492   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08493   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08494   return resultobj;
08495 fail:
08496   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
08497   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
08498   return NULL;
08499 }
08500 
08501 
08502 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08503   PyObject *resultobj = 0;
08504   PLFLT *arg1 = (PLFLT *) 0 ;
08505   PLFLT *arg2 = (PLFLT *) 0 ;
08506   PLFLT **arg3 = (PLFLT **) 0 ;
08507   PLINT arg4 ;
08508   PLINT arg5 ;
08509   PLINT arg6 ;
08510   PLBOOL arg7 ;
08511   PyArrayObject *tmp1 ;
08512   PyArrayObject *tmp2 ;
08513   PyArrayObject *tmp3 ;
08514   int val6 ;
08515   int ecode6 = 0 ;
08516   int val7 ;
08517   int ecode7 = 0 ;
08518   PyObject * obj0 = 0 ;
08519   PyObject * obj1 = 0 ;
08520   PyObject * obj2 = 0 ;
08521   PyObject * obj3 = 0 ;
08522   PyObject * obj4 = 0 ;
08523   
08524   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08525   {
08526     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08527     if ( tmp1 == NULL )
08528     return NULL;
08529     Xlen = tmp1->dimensions[0];
08530     arg1   = (PLFLT *) tmp1->data;
08531   }
08532   {
08533     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08534     if ( tmp2 == NULL )
08535     return NULL;
08536     Ylen = tmp2->dimensions[0];
08537     arg2   = (PLFLT *) tmp2->data;
08538   }
08539   {
08540     int i, size;
08541     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08542     if ( tmp3 == NULL )
08543     return NULL;
08544     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08545     {
08546       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08547       return NULL;
08548     }
08549     arg4   = tmp3->dimensions[0];
08550     arg5   = tmp3->dimensions[1];
08551     size = sizeof ( PLFLT ) * arg5;
08552     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08553     for ( i = 0; i < arg4; i++ )
08554     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08555   }
08556   ecode6 = SWIG_AsVal_int(obj3, &val6);
08557   if (!SWIG_IsOK(ecode6)) {
08558     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
08559   } 
08560   arg6 = (PLINT)(val6);
08561   ecode7 = SWIG_AsVal_int(obj4, &val7);
08562   if (!SWIG_IsOK(ecode7)) {
08563     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
08564   } 
08565   arg7 = (PLBOOL)(val7);
08566   plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
08567   resultobj = SWIG_Py_Void();
08568   {
08569     Py_DECREF( tmp1 );
08570   }
08571   {
08572     Py_DECREF( tmp2 );
08573   }
08574   {
08575     Py_DECREF( tmp3 );
08576     free( arg3 );
08577   }
08578   return resultobj;
08579 fail:
08580   {
08581     Py_DECREF( tmp1 );
08582   }
08583   {
08584     Py_DECREF( tmp2 );
08585   }
08586   {
08587     Py_DECREF( tmp3 );
08588     free( arg3 );
08589   }
08590   return NULL;
08591 }
08592 
08593 
08594 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08595   PyObject *resultobj = 0;
08596   PLFLT *arg1 = (PLFLT *) 0 ;
08597   PLFLT *arg2 = (PLFLT *) 0 ;
08598   PLFLT **arg3 = (PLFLT **) 0 ;
08599   PLINT arg4 ;
08600   PLINT arg5 ;
08601   PLINT arg6 ;
08602   PLFLT *arg7 = (PLFLT *) 0 ;
08603   PLINT arg8 ;
08604   PyArrayObject *tmp1 ;
08605   PyArrayObject *tmp2 ;
08606   PyArrayObject *tmp3 ;
08607   int val6 ;
08608   int ecode6 = 0 ;
08609   PyArrayObject *tmp7 ;
08610   PyObject * obj0 = 0 ;
08611   PyObject * obj1 = 0 ;
08612   PyObject * obj2 = 0 ;
08613   PyObject * obj3 = 0 ;
08614   PyObject * obj4 = 0 ;
08615   
08616   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08617   {
08618     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08619     if ( tmp1 == NULL )
08620     return NULL;
08621     Xlen = tmp1->dimensions[0];
08622     arg1   = (PLFLT *) tmp1->data;
08623   }
08624   {
08625     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08626     if ( tmp2 == NULL )
08627     return NULL;
08628     Ylen = tmp2->dimensions[0];
08629     arg2   = (PLFLT *) tmp2->data;
08630   }
08631   {
08632     int i, size;
08633     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08634     if ( tmp3 == NULL )
08635     return NULL;
08636     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08637     {
08638       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08639       return NULL;
08640     }
08641     arg4   = tmp3->dimensions[0];
08642     arg5   = tmp3->dimensions[1];
08643     size = sizeof ( PLFLT ) * arg5;
08644     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08645     for ( i = 0; i < arg4; i++ )
08646     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08647   }
08648   ecode6 = SWIG_AsVal_int(obj3, &val6);
08649   if (!SWIG_IsOK(ecode6)) {
08650     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
08651   } 
08652   arg6 = (PLINT)(val6);
08653   {
08654     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08655     if ( tmp7 == NULL )
08656     return NULL;
08657     arg8 = tmp7->dimensions[0];
08658     arg7 = (PLFLT *) tmp7->data;
08659   }
08660   plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08661   resultobj = SWIG_Py_Void();
08662   {
08663     Py_DECREF( tmp1 );
08664   }
08665   {
08666     Py_DECREF( tmp2 );
08667   }
08668   {
08669     Py_DECREF( tmp3 );
08670     free( arg3 );
08671   }
08672   {
08673     Py_DECREF( tmp7 );
08674   }
08675   return resultobj;
08676 fail:
08677   {
08678     Py_DECREF( tmp1 );
08679   }
08680   {
08681     Py_DECREF( tmp2 );
08682   }
08683   {
08684     Py_DECREF( tmp3 );
08685     free( arg3 );
08686   }
08687   {
08688     Py_DECREF( tmp7 );
08689   }
08690   return NULL;
08691 }
08692 
08693 
08694 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08695   PyObject *resultobj = 0;
08696   PLFLT *arg1 = (PLFLT *) 0 ;
08697   PLFLT *arg2 = (PLFLT *) 0 ;
08698   PLFLT **arg3 = (PLFLT **) 0 ;
08699   PLINT arg4 ;
08700   PLINT arg5 ;
08701   PLINT arg6 ;
08702   PLFLT *arg7 = (PLFLT *) 0 ;
08703   PLINT arg8 ;
08704   PLINT arg9 ;
08705   PLINT arg10 ;
08706   PLINT *arg11 = (PLINT *) 0 ;
08707   PLINT *arg12 = (PLINT *) 0 ;
08708   PyArrayObject *tmp1 ;
08709   PyArrayObject *tmp2 ;
08710   PyArrayObject *tmp3 ;
08711   int val6 ;
08712   int ecode6 = 0 ;
08713   PyArrayObject *tmp7 ;
08714   int val9 ;
08715   int ecode9 = 0 ;
08716   PyArrayObject *tmp10 ;
08717   PyArrayObject *tmp12 ;
08718   PyObject * obj0 = 0 ;
08719   PyObject * obj1 = 0 ;
08720   PyObject * obj2 = 0 ;
08721   PyObject * obj3 = 0 ;
08722   PyObject * obj4 = 0 ;
08723   PyObject * obj5 = 0 ;
08724   PyObject * obj6 = 0 ;
08725   PyObject * obj7 = 0 ;
08726   
08727   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
08728   {
08729     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08730     if ( tmp1 == NULL )
08731     return NULL;
08732     Xlen = tmp1->dimensions[0];
08733     arg1   = (PLFLT *) tmp1->data;
08734   }
08735   {
08736     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08737     if ( tmp2 == NULL )
08738     return NULL;
08739     Ylen = tmp2->dimensions[0];
08740     arg2   = (PLFLT *) tmp2->data;
08741   }
08742   {
08743     int i, size;
08744     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08745     if ( tmp3 == NULL )
08746     return NULL;
08747     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08748     {
08749       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08750       return NULL;
08751     }
08752     arg4   = tmp3->dimensions[0];
08753     arg5   = tmp3->dimensions[1];
08754     size = sizeof ( PLFLT ) * arg5;
08755     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08756     for ( i = 0; i < arg4; i++ )
08757     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08758   }
08759   ecode6 = SWIG_AsVal_int(obj3, &val6);
08760   if (!SWIG_IsOK(ecode6)) {
08761     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
08762   } 
08763   arg6 = (PLINT)(val6);
08764   {
08765     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08766     if ( tmp7 == NULL )
08767     return NULL;
08768     arg8 = tmp7->dimensions[0];
08769     arg7 = (PLFLT *) tmp7->data;
08770   }
08771   ecode9 = SWIG_AsVal_int(obj5, &val9);
08772   if (!SWIG_IsOK(ecode9)) {
08773     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
08774   } 
08775   arg9 = (PLINT)(val9);
08776   {
08777     tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
08778     if ( tmp10 == NULL )
08779     return NULL;
08780     arg10 = Alen = tmp10->dimensions[0];
08781     arg11 = (PLINT *) tmp10->data;
08782   }
08783   {
08784     tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, PyArray_PLINT, 1, 1 );
08785     if ( tmp12 == NULL )
08786     return NULL;
08787     if ( tmp12->dimensions[0] != Alen )
08788     {
08789       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08790       return NULL;
08791     }
08792     arg12 = (PLINT *) tmp12->data;
08793   }
08794   plot3dcl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
08795   resultobj = SWIG_Py_Void();
08796   {
08797     Py_DECREF( tmp1 );
08798   }
08799   {
08800     Py_DECREF( tmp2 );
08801   }
08802   {
08803     Py_DECREF( tmp3 );
08804     free( arg3 );
08805   }
08806   {
08807     Py_DECREF( tmp7 );
08808   }
08809   {
08810     Py_DECREF( tmp10 );
08811   }
08812   {
08813     Py_DECREF( tmp12 );
08814   }
08815   return resultobj;
08816 fail:
08817   {
08818     Py_DECREF( tmp1 );
08819   }
08820   {
08821     Py_DECREF( tmp2 );
08822   }
08823   {
08824     Py_DECREF( tmp3 );
08825     free( arg3 );
08826   }
08827   {
08828     Py_DECREF( tmp7 );
08829   }
08830   {
08831     Py_DECREF( tmp10 );
08832   }
08833   {
08834     Py_DECREF( tmp12 );
08835   }
08836   return NULL;
08837 }
08838 
08839 
08840 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08841   PyObject *resultobj = 0;
08842   PLFLT *arg1 = (PLFLT *) 0 ;
08843   PLFLT *arg2 = (PLFLT *) 0 ;
08844   PLFLT **arg3 = (PLFLT **) 0 ;
08845   PLINT arg4 ;
08846   PLINT arg5 ;
08847   PLINT arg6 ;
08848   PLFLT *arg7 = (PLFLT *) 0 ;
08849   PLINT arg8 ;
08850   PyArrayObject *tmp1 ;
08851   PyArrayObject *tmp2 ;
08852   PyArrayObject *tmp3 ;
08853   int val6 ;
08854   int ecode6 = 0 ;
08855   PyArrayObject *tmp7 ;
08856   PyObject * obj0 = 0 ;
08857   PyObject * obj1 = 0 ;
08858   PyObject * obj2 = 0 ;
08859   PyObject * obj3 = 0 ;
08860   PyObject * obj4 = 0 ;
08861   
08862   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08863   {
08864     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08865     if ( tmp1 == NULL )
08866     return NULL;
08867     Xlen = tmp1->dimensions[0];
08868     arg1   = (PLFLT *) tmp1->data;
08869   }
08870   {
08871     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08872     if ( tmp2 == NULL )
08873     return NULL;
08874     Ylen = tmp2->dimensions[0];
08875     arg2   = (PLFLT *) tmp2->data;
08876   }
08877   {
08878     int i, size;
08879     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08880     if ( tmp3 == NULL )
08881     return NULL;
08882     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08883     {
08884       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08885       return NULL;
08886     }
08887     arg4   = tmp3->dimensions[0];
08888     arg5   = tmp3->dimensions[1];
08889     size = sizeof ( PLFLT ) * arg5;
08890     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
08891     for ( i = 0; i < arg4; i++ )
08892     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
08893   }
08894   ecode6 = SWIG_AsVal_int(obj3, &val6);
08895   if (!SWIG_IsOK(ecode6)) {
08896     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
08897   } 
08898   arg6 = (PLINT)(val6);
08899   {
08900     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
08901     if ( tmp7 == NULL )
08902     return NULL;
08903     arg8 = tmp7->dimensions[0];
08904     arg7 = (PLFLT *) tmp7->data;
08905   }
08906   plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08907   resultobj = SWIG_Py_Void();
08908   {
08909     Py_DECREF( tmp1 );
08910   }
08911   {
08912     Py_DECREF( tmp2 );
08913   }
08914   {
08915     Py_DECREF( tmp3 );
08916     free( arg3 );
08917   }
08918   {
08919     Py_DECREF( tmp7 );
08920   }
08921   return resultobj;
08922 fail:
08923   {
08924     Py_DECREF( tmp1 );
08925   }
08926   {
08927     Py_DECREF( tmp2 );
08928   }
08929   {
08930     Py_DECREF( tmp3 );
08931     free( arg3 );
08932   }
08933   {
08934     Py_DECREF( tmp7 );
08935   }
08936   return NULL;
08937 }
08938 
08939 
08940 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08941   PyObject *resultobj = 0;
08942   PLFLT *arg1 = (PLFLT *) 0 ;
08943   PLFLT *arg2 = (PLFLT *) 0 ;
08944   PLFLT **arg3 = (PLFLT **) 0 ;
08945   PLINT arg4 ;
08946   PLINT arg5 ;
08947   PLINT arg6 ;
08948   PLFLT *arg7 = (PLFLT *) 0 ;
08949   PLINT arg8 ;
08950   PLINT arg9 ;
08951   PLINT arg10 ;
08952   PLINT *arg11 = (PLINT *) 0 ;
08953   PLINT *arg12 = (PLINT *) 0 ;
08954   PyArrayObject *tmp1 ;
08955   PyArrayObject *tmp2 ;
08956   PyArrayObject *tmp3 ;
08957   int val6 ;
08958   int ecode6 = 0 ;
08959   PyArrayObject *tmp7 ;
08960   int val9 ;
08961   int ecode9 = 0 ;
08962   PyArrayObject *tmp10 ;
08963   PyArrayObject *tmp12 ;
08964   PyObject * obj0 = 0 ;
08965   PyObject * obj1 = 0 ;
08966   PyObject * obj2 = 0 ;
08967   PyObject * obj3 = 0 ;
08968   PyObject * obj4 = 0 ;
08969   PyObject * obj5 = 0 ;
08970   PyObject * obj6 = 0 ;
08971   PyObject * obj7 = 0 ;
08972   
08973   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
08974   {
08975     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
08976     if ( tmp1 == NULL )
08977     return NULL;
08978     Xlen = tmp1->dimensions[0];
08979     arg1   = (PLFLT *) tmp1->data;
08980   }
08981   {
08982     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
08983     if ( tmp2 == NULL )
08984     return NULL;
08985     Ylen = tmp2->dimensions[0];
08986     arg2   = (PLFLT *) tmp2->data;
08987   }
08988   {
08989     int i, size;
08990     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 2, 2 );
08991     if ( tmp3 == NULL )
08992     return NULL;
08993     if ( Xlen != tmp3->dimensions[0] || Ylen != tmp3->dimensions[1] )
08994     {
08995       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08996       return NULL;
08997     }
08998     arg4   = tmp3->dimensions[0];
08999     arg5   = tmp3->dimensions[1];
09000     size = sizeof ( PLFLT ) * arg5;
09001     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg4 );
09002     for ( i = 0; i < arg4; i++ )
09003     arg3[i] = (PLFLT *) ( tmp3->data + i * size );
09004   }
09005   ecode6 = SWIG_AsVal_int(obj3, &val6);
09006   if (!SWIG_IsOK(ecode6)) {
09007     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
09008   } 
09009   arg6 = (PLINT)(val6);
09010   {
09011     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
09012     if ( tmp7 == NULL )
09013     return NULL;
09014     arg8 = tmp7->dimensions[0];
09015     arg7 = (PLFLT *) tmp7->data;
09016   }
09017   ecode9 = SWIG_AsVal_int(obj5, &val9);
09018   if (!SWIG_IsOK(ecode9)) {
09019     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
09020   } 
09021   arg9 = (PLINT)(val9);
09022   {
09023     tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
09024     if ( tmp10 == NULL )
09025     return NULL;
09026     arg10 = Alen = tmp10->dimensions[0];
09027     arg11 = (PLINT *) tmp10->data;
09028   }
09029   {
09030     tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, PyArray_PLINT, 1, 1 );
09031     if ( tmp12 == NULL )
09032     return NULL;
09033     if ( tmp12->dimensions[0] != Alen )
09034     {
09035       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09036       return NULL;
09037     }
09038     arg12 = (PLINT *) tmp12->data;
09039   }
09040   plsurf3dl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
09041   resultobj = SWIG_Py_Void();
09042   {
09043     Py_DECREF( tmp1 );
09044   }
09045   {
09046     Py_DECREF( tmp2 );
09047   }
09048   {
09049     Py_DECREF( tmp3 );
09050     free( arg3 );
09051   }
09052   {
09053     Py_DECREF( tmp7 );
09054   }
09055   {
09056     Py_DECREF( tmp10 );
09057   }
09058   {
09059     Py_DECREF( tmp12 );
09060   }
09061   return resultobj;
09062 fail:
09063   {
09064     Py_DECREF( tmp1 );
09065   }
09066   {
09067     Py_DECREF( tmp2 );
09068   }
09069   {
09070     Py_DECREF( tmp3 );
09071     free( arg3 );
09072   }
09073   {
09074     Py_DECREF( tmp7 );
09075   }
09076   {
09077     Py_DECREF( tmp10 );
09078   }
09079   {
09080     Py_DECREF( tmp12 );
09081   }
09082   return NULL;
09083 }
09084 
09085 
09086 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09087   PyObject *resultobj = 0;
09088   int *arg1 = (int *) 0 ;
09089   char **arg2 = (char **) 0 ;
09090   PLINT arg3 ;
09091   int tmp1 ;
09092   int val3 ;
09093   int ecode3 = 0 ;
09094   PyObject * obj0 = 0 ;
09095   PyObject * obj1 = 0 ;
09096   PLINT result;
09097   
09098   if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
09099   {
09100     int i;
09101     if ( !PyList_Check( obj0 ) )
09102     {
09103       PyErr_SetString( PyExc_ValueError, "Expecting a list" );
09104       return NULL;
09105     }
09106     tmp1 = PyList_Size( obj0 );
09107     arg1  = &tmp1;
09108     arg2  = (char **) malloc( ( tmp1 + 1 ) * sizeof ( char * ) );
09109     for ( i = 0; i < tmp1; i++ )
09110     {
09111       PyObject *s = PyList_GetItem( obj0, i );
09112       if ( !PyString_Check( s ) )
09113       {
09114         free( arg2 );
09115         PyErr_SetString( PyExc_ValueError, "List items must be strings" );
09116         return NULL;
09117       }
09118       arg2[i] = PyString_AsString( s );
09119     }
09120     arg2[i] = 0;
09121   }
09122   ecode3 = SWIG_AsVal_int(obj1, &val3);
09123   if (!SWIG_IsOK(ecode3)) {
09124     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
09125   } 
09126   arg3 = (PLINT)(val3);
09127   result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
09128   resultobj = SWIG_From_int((int)(result));
09129   {
09130     if ( arg2 )
09131     free( arg2 );
09132   }
09133   return resultobj;
09134 fail:
09135   {
09136     if ( arg2 )
09137     free( arg2 );
09138   }
09139   return NULL;
09140 }
09141 
09142 
09143 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09144   PyObject *resultobj = 0;
09145   PLINT arg1 ;
09146   PLINT *arg2 = (PLINT *) 0 ;
09147   PLINT *arg3 = (PLINT *) 0 ;
09148   PyArrayObject *tmp1 ;
09149   PyArrayObject *tmp3 ;
09150   PyObject * obj0 = 0 ;
09151   PyObject * obj1 = 0 ;
09152   
09153   if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
09154   {
09155     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09156     if ( tmp1 == NULL )
09157     return NULL;
09158     arg1 = Alen = tmp1->dimensions[0];
09159     arg2 = (PLINT *) tmp1->data;
09160   }
09161   {
09162     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09163     if ( tmp3 == NULL )
09164     return NULL;
09165     if ( tmp3->dimensions[0] != Alen )
09166     {
09167       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09168       return NULL;
09169     }
09170     arg3 = (PLINT *) tmp3->data;
09171   }
09172   plpat(arg1,(int const *)arg2,(int const *)arg3);
09173   resultobj = SWIG_Py_Void();
09174   {
09175     Py_DECREF( tmp1 );
09176   }
09177   {
09178     Py_DECREF( tmp3 );
09179   }
09180   return resultobj;
09181 fail:
09182   {
09183     Py_DECREF( tmp1 );
09184   }
09185   {
09186     Py_DECREF( tmp3 );
09187   }
09188   return NULL;
09189 }
09190 
09191 
09192 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09193   PyObject *resultobj = 0;
09194   PLINT arg1 ;
09195   PLFLT *arg2 = (PLFLT *) 0 ;
09196   PLFLT *arg3 = (PLFLT *) 0 ;
09197   PLINT arg4 ;
09198   PyArrayObject *tmp1 ;
09199   PyArrayObject *tmp3 ;
09200   int val4 ;
09201   int ecode4 = 0 ;
09202   PyObject * obj0 = 0 ;
09203   PyObject * obj1 = 0 ;
09204   PyObject * obj2 = 0 ;
09205   
09206   if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
09207   {
09208     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09209     if ( tmp1 == NULL )
09210     return NULL;
09211     arg1 = Alen = tmp1->dimensions[0];
09212     arg2 = (PLFLT *) tmp1->data;
09213   }
09214   {
09215     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09216     if ( tmp3 == NULL )
09217     return NULL;
09218     if ( tmp3->dimensions[0] != Alen )
09219     {
09220       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09221       return NULL;
09222     }
09223     arg3 = (PLFLT *) tmp3->data;
09224   }
09225   ecode4 = SWIG_AsVal_int(obj2, &val4);
09226   if (!SWIG_IsOK(ecode4)) {
09227     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
09228   } 
09229   arg4 = (PLINT)(val4);
09230   plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
09231   resultobj = SWIG_Py_Void();
09232   {
09233     Py_DECREF( tmp1 );
09234   }
09235   {
09236     Py_DECREF( tmp3 );
09237   }
09238   return resultobj;
09239 fail:
09240   {
09241     Py_DECREF( tmp1 );
09242   }
09243   {
09244     Py_DECREF( tmp3 );
09245   }
09246   return NULL;
09247 }
09248 
09249 
09250 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09251   PyObject *resultobj = 0;
09252   PLINT arg1 ;
09253   PLFLT *arg2 = (PLFLT *) 0 ;
09254   PLFLT *arg3 = (PLFLT *) 0 ;
09255   PLFLT *arg4 = (PLFLT *) 0 ;
09256   PLINT arg5 ;
09257   PyArrayObject *tmp1 ;
09258   PyArrayObject *tmp3 ;
09259   PyArrayObject *tmp4 ;
09260   int val5 ;
09261   int ecode5 = 0 ;
09262   PyObject * obj0 = 0 ;
09263   PyObject * obj1 = 0 ;
09264   PyObject * obj2 = 0 ;
09265   PyObject * obj3 = 0 ;
09266   
09267   if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
09268   {
09269     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09270     if ( tmp1 == NULL )
09271     return NULL;
09272     arg1 = Alen = tmp1->dimensions[0];
09273     arg2 = (PLFLT *) tmp1->data;
09274   }
09275   {
09276     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09277     if ( tmp3 == NULL )
09278     return NULL;
09279     if ( tmp3->dimensions[0] != Alen )
09280     {
09281       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09282       return NULL;
09283     }
09284     arg3 = (PLFLT *) tmp3->data;
09285   }
09286   {
09287     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
09288     if ( tmp4 == NULL )
09289     return NULL;
09290     if ( tmp4->dimensions[0] != Alen )
09291     {
09292       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09293       return NULL;
09294     }
09295     arg4 = (PLFLT *) tmp4->data;
09296   }
09297   ecode5 = SWIG_AsVal_int(obj3, &val5);
09298   if (!SWIG_IsOK(ecode5)) {
09299     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
09300   } 
09301   arg5 = (PLINT)(val5);
09302   plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
09303   resultobj = SWIG_Py_Void();
09304   {
09305     Py_DECREF( tmp1 );
09306   }
09307   {
09308     Py_DECREF( tmp3 );
09309   }
09310   {
09311     Py_DECREF( tmp4 );
09312   }
09313   return resultobj;
09314 fail:
09315   {
09316     Py_DECREF( tmp1 );
09317   }
09318   {
09319     Py_DECREF( tmp3 );
09320   }
09321   {
09322     Py_DECREF( tmp4 );
09323   }
09324   return NULL;
09325 }
09326 
09327 
09328 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09329   PyObject *resultobj = 0;
09330   PLINT arg1 ;
09331   PLFLT *arg2 = (PLFLT *) 0 ;
09332   PLFLT *arg3 = (PLFLT *) 0 ;
09333   PLFLT *arg4 = (PLFLT *) 0 ;
09334   PLBOOL *arg5 = (PLBOOL *) 0 ;
09335   PLBOOL arg6 ;
09336   PyArrayObject *tmp1 ;
09337   PyArrayObject *tmp3 ;
09338   PyArrayObject *tmp4 ;
09339   PyArrayObject *tmp5 ;
09340   int val6 ;
09341   int ecode6 = 0 ;
09342   PyObject * obj0 = 0 ;
09343   PyObject * obj1 = 0 ;
09344   PyObject * obj2 = 0 ;
09345   PyObject * obj3 = 0 ;
09346   PyObject * obj4 = 0 ;
09347   
09348   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09349   {
09350     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
09351     if ( tmp1 == NULL )
09352     return NULL;
09353     arg1 = Alen = tmp1->dimensions[0];
09354     arg2 = (PLFLT *) tmp1->data;
09355   }
09356   {
09357     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
09358     if ( tmp3 == NULL )
09359     return NULL;
09360     if ( tmp3->dimensions[0] != Alen )
09361     {
09362       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09363       return NULL;
09364     }
09365     arg3 = (PLFLT *) tmp3->data;
09366   }
09367   {
09368     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
09369     if ( tmp4 == NULL )
09370     return NULL;
09371     if ( tmp4->dimensions[0] != Alen )
09372     {
09373       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09374       return NULL;
09375     }
09376     arg4 = (PLFLT *) tmp4->data;
09377   }
09378   {
09379     tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, PyArray_PLINT, 1, 1 );
09380     if ( tmp5 == NULL )
09381     return NULL;
09382     if ( tmp5->dimensions[0] < Alen - 1 )
09383     {
09384       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
09385       return NULL;
09386     }
09387     arg5 = (PLINT *) tmp5->data;
09388   }
09389   ecode6 = SWIG_AsVal_int(obj4, &val6);
09390   if (!SWIG_IsOK(ecode6)) {
09391     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
09392   } 
09393   arg6 = (PLBOOL)(val6);
09394   plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
09395   resultobj = SWIG_Py_Void();
09396   {
09397     Py_DECREF( tmp1 );
09398   }
09399   {
09400     Py_DECREF( tmp3 );
09401   }
09402   {
09403     Py_DECREF( tmp4 );
09404   }
09405   {
09406     Py_DECREF( tmp5 );
09407   }
09408   return resultobj;
09409 fail:
09410   {
09411     Py_DECREF( tmp1 );
09412   }
09413   {
09414     Py_DECREF( tmp3 );
09415   }
09416   {
09417     Py_DECREF( tmp4 );
09418   }
09419   {
09420     Py_DECREF( tmp5 );
09421   }
09422   return NULL;
09423 }
09424 
09425 
09426 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09427   PyObject *resultobj = 0;
09428   PLINT arg1 ;
09429   PLINT arg2 ;
09430   int val1 ;
09431   int ecode1 = 0 ;
09432   int val2 ;
09433   int ecode2 = 0 ;
09434   PyObject * obj0 = 0 ;
09435   PyObject * obj1 = 0 ;
09436   
09437   if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
09438   ecode1 = SWIG_AsVal_int(obj0, &val1);
09439   if (!SWIG_IsOK(ecode1)) {
09440     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
09441   } 
09442   arg1 = (PLINT)(val1);
09443   ecode2 = SWIG_AsVal_int(obj1, &val2);
09444   if (!SWIG_IsOK(ecode2)) {
09445     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
09446   } 
09447   arg2 = (PLINT)(val2);
09448   plprec(arg1,arg2);
09449   resultobj = SWIG_Py_Void();
09450   return resultobj;
09451 fail:
09452   return NULL;
09453 }
09454 
09455 
09456 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09457   PyObject *resultobj = 0;
09458   PLINT arg1 ;
09459   int val1 ;
09460   int ecode1 = 0 ;
09461   PyObject * obj0 = 0 ;
09462   
09463   if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
09464   ecode1 = SWIG_AsVal_int(obj0, &val1);
09465   if (!SWIG_IsOK(ecode1)) {
09466     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
09467   } 
09468   arg1 = (PLINT)(val1);
09469   plpsty(arg1);
09470   resultobj = SWIG_Py_Void();
09471   return resultobj;
09472 fail:
09473   return NULL;
09474 }
09475 
09476 
09477 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09478   PyObject *resultobj = 0;
09479   PLFLT arg1 ;
09480   PLFLT arg2 ;
09481   PLFLT arg3 ;
09482   PLFLT arg4 ;
09483   PLFLT arg5 ;
09484   char *arg6 = (char *) 0 ;
09485   double val1 ;
09486   int ecode1 = 0 ;
09487   double val2 ;
09488   int ecode2 = 0 ;
09489   double val3 ;
09490   int ecode3 = 0 ;
09491   double val4 ;
09492   int ecode4 = 0 ;
09493   double val5 ;
09494   int ecode5 = 0 ;
09495   int res6 ;
09496   char *buf6 = 0 ;
09497   int alloc6 = 0 ;
09498   PyObject * obj0 = 0 ;
09499   PyObject * obj1 = 0 ;
09500   PyObject * obj2 = 0 ;
09501   PyObject * obj3 = 0 ;
09502   PyObject * obj4 = 0 ;
09503   PyObject * obj5 = 0 ;
09504   
09505   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
09506   ecode1 = SWIG_AsVal_double(obj0, &val1);
09507   if (!SWIG_IsOK(ecode1)) {
09508     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
09509   } 
09510   arg1 = (PLFLT)(val1);
09511   ecode2 = SWIG_AsVal_double(obj1, &val2);
09512   if (!SWIG_IsOK(ecode2)) {
09513     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
09514   } 
09515   arg2 = (PLFLT)(val2);
09516   ecode3 = SWIG_AsVal_double(obj2, &val3);
09517   if (!SWIG_IsOK(ecode3)) {
09518     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
09519   } 
09520   arg3 = (PLFLT)(val3);
09521   ecode4 = SWIG_AsVal_double(obj3, &val4);
09522   if (!SWIG_IsOK(ecode4)) {
09523     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
09524   } 
09525   arg4 = (PLFLT)(val4);
09526   ecode5 = SWIG_AsVal_double(obj4, &val5);
09527   if (!SWIG_IsOK(ecode5)) {
09528     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
09529   } 
09530   arg5 = (PLFLT)(val5);
09531   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
09532   if (!SWIG_IsOK(res6)) {
09533     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
09534   }
09535   arg6 = (char *)(buf6);
09536   plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
09537   resultobj = SWIG_Py_Void();
09538   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
09539   return resultobj;
09540 fail:
09541   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
09542   return NULL;
09543 }
09544 
09545 
09546 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09547   PyObject *resultobj = 0;
09548   PLFLT arg1 ;
09549   PLFLT arg2 ;
09550   PLFLT arg3 ;
09551   PLFLT arg4 ;
09552   PLFLT arg5 ;
09553   PLFLT arg6 ;
09554   PLFLT arg7 ;
09555   PLFLT arg8 ;
09556   PLFLT arg9 ;
09557   PLFLT arg10 ;
09558   char *arg11 = (char *) 0 ;
09559   double val1 ;
09560   int ecode1 = 0 ;
09561   double val2 ;
09562   int ecode2 = 0 ;
09563   double val3 ;
09564   int ecode3 = 0 ;
09565   double val4 ;
09566   int ecode4 = 0 ;
09567   double val5 ;
09568   int ecode5 = 0 ;
09569   double val6 ;
09570   int ecode6 = 0 ;
09571   double val7 ;
09572   int ecode7 = 0 ;
09573   double val8 ;
09574   int ecode8 = 0 ;
09575   double val9 ;
09576   int ecode9 = 0 ;
09577   double val10 ;
09578   int ecode10 = 0 ;
09579   int res11 ;
09580   char *buf11 = 0 ;
09581   int alloc11 = 0 ;
09582   PyObject * obj0 = 0 ;
09583   PyObject * obj1 = 0 ;
09584   PyObject * obj2 = 0 ;
09585   PyObject * obj3 = 0 ;
09586   PyObject * obj4 = 0 ;
09587   PyObject * obj5 = 0 ;
09588   PyObject * obj6 = 0 ;
09589   PyObject * obj7 = 0 ;
09590   PyObject * obj8 = 0 ;
09591   PyObject * obj9 = 0 ;
09592   PyObject * obj10 = 0 ;
09593   
09594   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
09595   ecode1 = SWIG_AsVal_double(obj0, &val1);
09596   if (!SWIG_IsOK(ecode1)) {
09597     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
09598   } 
09599   arg1 = (PLFLT)(val1);
09600   ecode2 = SWIG_AsVal_double(obj1, &val2);
09601   if (!SWIG_IsOK(ecode2)) {
09602     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
09603   } 
09604   arg2 = (PLFLT)(val2);
09605   ecode3 = SWIG_AsVal_double(obj2, &val3);
09606   if (!SWIG_IsOK(ecode3)) {
09607     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
09608   } 
09609   arg3 = (PLFLT)(val3);
09610   ecode4 = SWIG_AsVal_double(obj3, &val4);
09611   if (!SWIG_IsOK(ecode4)) {
09612     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
09613   } 
09614   arg4 = (PLFLT)(val4);
09615   ecode5 = SWIG_AsVal_double(obj4, &val5);
09616   if (!SWIG_IsOK(ecode5)) {
09617     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
09618   } 
09619   arg5 = (PLFLT)(val5);
09620   ecode6 = SWIG_AsVal_double(obj5, &val6);
09621   if (!SWIG_IsOK(ecode6)) {
09622     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
09623   } 
09624   arg6 = (PLFLT)(val6);
09625   ecode7 = SWIG_AsVal_double(obj6, &val7);
09626   if (!SWIG_IsOK(ecode7)) {
09627     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
09628   } 
09629   arg7 = (PLFLT)(val7);
09630   ecode8 = SWIG_AsVal_double(obj7, &val8);
09631   if (!SWIG_IsOK(ecode8)) {
09632     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
09633   } 
09634   arg8 = (PLFLT)(val8);
09635   ecode9 = SWIG_AsVal_double(obj8, &val9);
09636   if (!SWIG_IsOK(ecode9)) {
09637     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
09638   } 
09639   arg9 = (PLFLT)(val9);
09640   ecode10 = SWIG_AsVal_double(obj9, &val10);
09641   if (!SWIG_IsOK(ecode10)) {
09642     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
09643   } 
09644   arg10 = (PLFLT)(val10);
09645   res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
09646   if (!SWIG_IsOK(res11)) {
09647     SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
09648   }
09649   arg11 = (char *)(buf11);
09650   plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
09651   resultobj = SWIG_Py_Void();
09652   if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
09653   return resultobj;
09654 fail:
09655   if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
09656   return NULL;
09657 }
09658 
09659 
09660 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09661   PyObject *resultobj = 0;
09662   PLFLT result;
09663   
09664   if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
09665   result = (PLFLT)plrandd();
09666   resultobj = SWIG_From_double((double)(result));
09667   return resultobj;
09668 fail:
09669   return NULL;
09670 }
09671 
09672 
09673 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09674   PyObject *resultobj = 0;
09675   
09676   if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
09677   plreplot();
09678   resultobj = SWIG_Py_Void();
09679   return resultobj;
09680 fail:
09681   return NULL;
09682 }
09683 
09684 
09685 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09686   PyObject *resultobj = 0;
09687   PLFLT arg1 ;
09688   PLFLT arg2 ;
09689   PLFLT arg3 ;
09690   PLFLT *arg4 = (PLFLT *) 0 ;
09691   PLFLT *arg5 = (PLFLT *) 0 ;
09692   PLFLT *arg6 = (PLFLT *) 0 ;
09693   double val1 ;
09694   int ecode1 = 0 ;
09695   double val2 ;
09696   int ecode2 = 0 ;
09697   double val3 ;
09698   int ecode3 = 0 ;
09699   PLFLT temp4 ;
09700   int res4 = SWIG_TMPOBJ ;
09701   PLFLT temp5 ;
09702   int res5 = SWIG_TMPOBJ ;
09703   PLFLT temp6 ;
09704   int res6 = SWIG_TMPOBJ ;
09705   PyObject * obj0 = 0 ;
09706   PyObject * obj1 = 0 ;
09707   PyObject * obj2 = 0 ;
09708   
09709   arg4 = &temp4;
09710   arg5 = &temp5;
09711   arg6 = &temp6;
09712   if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
09713   ecode1 = SWIG_AsVal_double(obj0, &val1);
09714   if (!SWIG_IsOK(ecode1)) {
09715     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
09716   } 
09717   arg1 = (PLFLT)(val1);
09718   ecode2 = SWIG_AsVal_double(obj1, &val2);
09719   if (!SWIG_IsOK(ecode2)) {
09720     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
09721   } 
09722   arg2 = (PLFLT)(val2);
09723   ecode3 = SWIG_AsVal_double(obj2, &val3);
09724   if (!SWIG_IsOK(ecode3)) {
09725     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
09726   } 
09727   arg3 = (PLFLT)(val3);
09728   plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
09729   resultobj = SWIG_Py_Void();
09730   if (SWIG_IsTmpObj(res4)) {
09731     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
09732   } else {
09733     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
09734     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
09735   }
09736   if (SWIG_IsTmpObj(res5)) {
09737     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
09738   } else {
09739     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
09740     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
09741   }
09742   if (SWIG_IsTmpObj(res6)) {
09743     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
09744   } else {
09745     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
09746     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
09747   }
09748   return resultobj;
09749 fail:
09750   return NULL;
09751 }
09752 
09753 
09754 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09755   PyObject *resultobj = 0;
09756   PLFLT arg1 ;
09757   PLFLT arg2 ;
09758   double val1 ;
09759   int ecode1 = 0 ;
09760   double val2 ;
09761   int ecode2 = 0 ;
09762   PyObject * obj0 = 0 ;
09763   PyObject * obj1 = 0 ;
09764   
09765   if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
09766   ecode1 = SWIG_AsVal_double(obj0, &val1);
09767   if (!SWIG_IsOK(ecode1)) {
09768     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
09769   } 
09770   arg1 = (PLFLT)(val1);
09771   ecode2 = SWIG_AsVal_double(obj1, &val2);
09772   if (!SWIG_IsOK(ecode2)) {
09773     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
09774   } 
09775   arg2 = (PLFLT)(val2);
09776   plschr(arg1,arg2);
09777   resultobj = SWIG_Py_Void();
09778   return resultobj;
09779 fail:
09780   return NULL;
09781 }
09782 
09783 
09784 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09785   PyObject *resultobj = 0;
09786   PLINT *arg1 = (PLINT *) 0 ;
09787   PLINT *arg2 = (PLINT *) 0 ;
09788   PLINT *arg3 = (PLINT *) 0 ;
09789   PLINT arg4 ;
09790   PyArrayObject *tmp1 ;
09791   PyArrayObject *tmp2 ;
09792   PyArrayObject *tmp3 ;
09793   PyObject * obj0 = 0 ;
09794   PyObject * obj1 = 0 ;
09795   PyObject * obj2 = 0 ;
09796   
09797   if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
09798   {
09799     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09800     if ( tmp1 == NULL )
09801     return NULL;
09802     Alen = tmp1->dimensions[0];
09803     arg1   = (PLINT *) tmp1->data;
09804   }
09805   {
09806     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09807     if ( tmp2 == NULL )
09808     return NULL;
09809     if ( tmp2->dimensions[0] != Alen )
09810     {
09811       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09812       return NULL;
09813     }
09814     arg2 = (PLINT *) tmp2->data;
09815   }
09816   {
09817     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09818     if ( tmp3 == NULL )
09819     return NULL;
09820     if ( tmp3->dimensions[0] != Alen )
09821     {
09822       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09823       return NULL;
09824     }
09825     arg4 = tmp3->dimensions[0];
09826     arg3 = (PLINT *) tmp3->data;
09827   }
09828   plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
09829   resultobj = SWIG_Py_Void();
09830   {
09831     Py_DECREF( tmp1 );
09832   }
09833   {
09834     Py_DECREF( tmp2 );
09835   }
09836   {
09837     Py_DECREF( tmp3 );
09838   }
09839   return resultobj;
09840 fail:
09841   {
09842     Py_DECREF( tmp1 );
09843   }
09844   {
09845     Py_DECREF( tmp2 );
09846   }
09847   {
09848     Py_DECREF( tmp3 );
09849   }
09850   return NULL;
09851 }
09852 
09853 
09854 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09855   PyObject *resultobj = 0;
09856   PLINT *arg1 = (PLINT *) 0 ;
09857   PLINT *arg2 = (PLINT *) 0 ;
09858   PLINT *arg3 = (PLINT *) 0 ;
09859   PLFLT *arg4 = (PLFLT *) 0 ;
09860   PLINT arg5 ;
09861   PyArrayObject *tmp1 ;
09862   PyArrayObject *tmp2 ;
09863   PyArrayObject *tmp3 ;
09864   PyArrayObject *tmp4 ;
09865   PyObject * obj0 = 0 ;
09866   PyObject * obj1 = 0 ;
09867   PyObject * obj2 = 0 ;
09868   PyObject * obj3 = 0 ;
09869   
09870   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
09871   {
09872     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09873     if ( tmp1 == NULL )
09874     return NULL;
09875     Alen = tmp1->dimensions[0];
09876     arg1   = (PLINT *) tmp1->data;
09877   }
09878   {
09879     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09880     if ( tmp2 == NULL )
09881     return NULL;
09882     if ( tmp2->dimensions[0] != Alen )
09883     {
09884       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09885       return NULL;
09886     }
09887     arg2 = (PLINT *) tmp2->data;
09888   }
09889   {
09890     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09891     if ( tmp3 == NULL )
09892     return NULL;
09893     if ( tmp3->dimensions[0] != Alen )
09894     {
09895       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09896       return NULL;
09897     }
09898     arg3 = (PLINT *) tmp3->data;
09899   }
09900   {
09901     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
09902     if ( tmp4 == NULL )
09903     return NULL;
09904     if ( tmp4->dimensions[0] != Alen )
09905     {
09906       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09907       return NULL;
09908     }
09909     arg4 = (PLFLT *) tmp4->data;
09910     arg5 = tmp4->dimensions[0];
09911   }
09912   plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
09913   resultobj = SWIG_Py_Void();
09914   {
09915     Py_DECREF( tmp1 );
09916   }
09917   {
09918     Py_DECREF( tmp2 );
09919   }
09920   {
09921     Py_DECREF( tmp3 );
09922   }
09923   {
09924     Py_DECREF( tmp4 );
09925   }
09926   return resultobj;
09927 fail:
09928   {
09929     Py_DECREF( tmp1 );
09930   }
09931   {
09932     Py_DECREF( tmp2 );
09933   }
09934   {
09935     Py_DECREF( tmp3 );
09936   }
09937   {
09938     Py_DECREF( tmp4 );
09939   }
09940   return NULL;
09941 }
09942 
09943 
09944 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09945   PyObject *resultobj = 0;
09946   PLINT arg1 ;
09947   int val1 ;
09948   int ecode1 = 0 ;
09949   PyObject * obj0 = 0 ;
09950   
09951   if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
09952   ecode1 = SWIG_AsVal_int(obj0, &val1);
09953   if (!SWIG_IsOK(ecode1)) {
09954     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
09955   } 
09956   arg1 = (PLINT)(val1);
09957   plscmap0n(arg1);
09958   resultobj = SWIG_Py_Void();
09959   return resultobj;
09960 fail:
09961   return NULL;
09962 }
09963 
09964 
09965 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09966   PyObject *resultobj = 0;
09967   PLINT *arg1 = (PLINT *) 0 ;
09968   PLINT *arg2 = (PLINT *) 0 ;
09969   PLINT *arg3 = (PLINT *) 0 ;
09970   PLINT arg4 ;
09971   PyArrayObject *tmp1 ;
09972   PyArrayObject *tmp2 ;
09973   PyArrayObject *tmp3 ;
09974   PyObject * obj0 = 0 ;
09975   PyObject * obj1 = 0 ;
09976   PyObject * obj2 = 0 ;
09977   
09978   if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
09979   {
09980     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
09981     if ( tmp1 == NULL )
09982     return NULL;
09983     Alen = tmp1->dimensions[0];
09984     arg1   = (PLINT *) tmp1->data;
09985   }
09986   {
09987     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
09988     if ( tmp2 == NULL )
09989     return NULL;
09990     if ( tmp2->dimensions[0] != Alen )
09991     {
09992       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09993       return NULL;
09994     }
09995     arg2 = (PLINT *) tmp2->data;
09996   }
09997   {
09998     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
09999     if ( tmp3 == NULL )
10000     return NULL;
10001     if ( tmp3->dimensions[0] != Alen )
10002     {
10003       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10004       return NULL;
10005     }
10006     arg4 = tmp3->dimensions[0];
10007     arg3 = (PLINT *) tmp3->data;
10008   }
10009   plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10010   resultobj = SWIG_Py_Void();
10011   {
10012     Py_DECREF( tmp1 );
10013   }
10014   {
10015     Py_DECREF( tmp2 );
10016   }
10017   {
10018     Py_DECREF( tmp3 );
10019   }
10020   return resultobj;
10021 fail:
10022   {
10023     Py_DECREF( tmp1 );
10024   }
10025   {
10026     Py_DECREF( tmp2 );
10027   }
10028   {
10029     Py_DECREF( tmp3 );
10030   }
10031   return NULL;
10032 }
10033 
10034 
10035 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10036   PyObject *resultobj = 0;
10037   PLINT *arg1 = (PLINT *) 0 ;
10038   PLINT *arg2 = (PLINT *) 0 ;
10039   PLINT *arg3 = (PLINT *) 0 ;
10040   PLFLT *arg4 = (PLFLT *) 0 ;
10041   PLINT arg5 ;
10042   PyArrayObject *tmp1 ;
10043   PyArrayObject *tmp2 ;
10044   PyArrayObject *tmp3 ;
10045   PyArrayObject *tmp4 ;
10046   PyObject * obj0 = 0 ;
10047   PyObject * obj1 = 0 ;
10048   PyObject * obj2 = 0 ;
10049   PyObject * obj3 = 0 ;
10050   
10051   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10052   {
10053     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
10054     if ( tmp1 == NULL )
10055     return NULL;
10056     Alen = tmp1->dimensions[0];
10057     arg1   = (PLINT *) tmp1->data;
10058   }
10059   {
10060     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
10061     if ( tmp2 == NULL )
10062     return NULL;
10063     if ( tmp2->dimensions[0] != Alen )
10064     {
10065       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10066       return NULL;
10067     }
10068     arg2 = (PLINT *) tmp2->data;
10069   }
10070   {
10071     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, PyArray_PLINT, 1, 1 );
10072     if ( tmp3 == NULL )
10073     return NULL;
10074     if ( tmp3->dimensions[0] != Alen )
10075     {
10076       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10077       return NULL;
10078     }
10079     arg3 = (PLINT *) tmp3->data;
10080   }
10081   {
10082     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10083     if ( tmp4 == NULL )
10084     return NULL;
10085     if ( tmp4->dimensions[0] != Alen )
10086     {
10087       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10088       return NULL;
10089     }
10090     arg4 = (PLFLT *) tmp4->data;
10091     arg5 = tmp4->dimensions[0];
10092   }
10093   plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10094   resultobj = SWIG_Py_Void();
10095   {
10096     Py_DECREF( tmp1 );
10097   }
10098   {
10099     Py_DECREF( tmp2 );
10100   }
10101   {
10102     Py_DECREF( tmp3 );
10103   }
10104   {
10105     Py_DECREF( tmp4 );
10106   }
10107   return resultobj;
10108 fail:
10109   {
10110     Py_DECREF( tmp1 );
10111   }
10112   {
10113     Py_DECREF( tmp2 );
10114   }
10115   {
10116     Py_DECREF( tmp3 );
10117   }
10118   {
10119     Py_DECREF( tmp4 );
10120   }
10121   return NULL;
10122 }
10123 
10124 
10125 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10126   PyObject *resultobj = 0;
10127   PLBOOL arg1 ;
10128   PLINT arg2 ;
10129   PLFLT *arg3 = (PLFLT *) 0 ;
10130   PLFLT *arg4 = (PLFLT *) 0 ;
10131   PLFLT *arg5 = (PLFLT *) 0 ;
10132   PLFLT *arg6 = (PLFLT *) 0 ;
10133   PLBOOL *arg7 = (PLBOOL *) 0 ;
10134   int val1 ;
10135   int ecode1 = 0 ;
10136   PyArrayObject *tmp2 ;
10137   PyArrayObject *tmp4 ;
10138   PyArrayObject *tmp5 ;
10139   PyArrayObject *tmp6 ;
10140   PyArrayObject *tmp7 ;
10141   PyObject * obj0 = 0 ;
10142   PyObject * obj1 = 0 ;
10143   PyObject * obj2 = 0 ;
10144   PyObject * obj3 = 0 ;
10145   PyObject * obj4 = 0 ;
10146   PyObject * obj5 = 0 ;
10147   
10148   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10149   ecode1 = SWIG_AsVal_int(obj0, &val1);
10150   if (!SWIG_IsOK(ecode1)) {
10151     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10152   } 
10153   arg1 = (PLBOOL)(val1);
10154   {
10155     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
10156     if ( tmp2 == NULL )
10157     return NULL;
10158     arg2 = Alen = tmp2->dimensions[0];
10159     arg3 = (PLFLT *) tmp2->data;
10160   }
10161   {
10162     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
10163     if ( tmp4 == NULL )
10164     return NULL;
10165     if ( tmp4->dimensions[0] != Alen )
10166     {
10167       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10168       return NULL;
10169     }
10170     arg4 = (PLFLT *) tmp4->data;
10171   }
10172   {
10173     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10174     if ( tmp5 == NULL )
10175     return NULL;
10176     if ( tmp5->dimensions[0] != Alen )
10177     {
10178       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10179       return NULL;
10180     }
10181     arg5 = (PLFLT *) tmp5->data;
10182   }
10183   {
10184     tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
10185     if ( tmp6 == NULL )
10186     return NULL;
10187     if ( tmp6->dimensions[0] != Alen )
10188     {
10189       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10190       return NULL;
10191     }
10192     arg6 = (PLFLT *) tmp6->data;
10193   }
10194   {
10195     tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, PyArray_PLINT, 1, 1 );
10196     if ( tmp7 == NULL )
10197     return NULL;
10198     if ( tmp7->dimensions[0] < Alen - 1 )
10199     {
10200       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10201       return NULL;
10202     }
10203     arg7 = (PLINT *) tmp7->data;
10204   }
10205   plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10206   resultobj = SWIG_Py_Void();
10207   {
10208     Py_DECREF( tmp2 );
10209   }
10210   {
10211     Py_DECREF( tmp4 );
10212   }
10213   {
10214     Py_DECREF( tmp5 );
10215   }
10216   {
10217     Py_DECREF( tmp6 );
10218   }
10219   {
10220     Py_DECREF( tmp7 );
10221   }
10222   return resultobj;
10223 fail:
10224   {
10225     Py_DECREF( tmp2 );
10226   }
10227   {
10228     Py_DECREF( tmp4 );
10229   }
10230   {
10231     Py_DECREF( tmp5 );
10232   }
10233   {
10234     Py_DECREF( tmp6 );
10235   }
10236   {
10237     Py_DECREF( tmp7 );
10238   }
10239   return NULL;
10240 }
10241 
10242 
10243 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244   PyObject *resultobj = 0;
10245   PLBOOL arg1 ;
10246   PLINT arg2 ;
10247   PLFLT *arg3 = (PLFLT *) 0 ;
10248   PLFLT *arg4 = (PLFLT *) 0 ;
10249   PLFLT *arg5 = (PLFLT *) 0 ;
10250   PLFLT *arg6 = (PLFLT *) 0 ;
10251   PLFLT *arg7 = (PLFLT *) 0 ;
10252   PLBOOL *arg8 = (PLBOOL *) 0 ;
10253   int val1 ;
10254   int ecode1 = 0 ;
10255   PyArrayObject *tmp2 ;
10256   PyArrayObject *tmp4 ;
10257   PyArrayObject *tmp5 ;
10258   PyArrayObject *tmp6 ;
10259   PyArrayObject *tmp7 ;
10260   PyArrayObject *tmp8 ;
10261   PyObject * obj0 = 0 ;
10262   PyObject * obj1 = 0 ;
10263   PyObject * obj2 = 0 ;
10264   PyObject * obj3 = 0 ;
10265   PyObject * obj4 = 0 ;
10266   PyObject * obj5 = 0 ;
10267   PyObject * obj6 = 0 ;
10268   
10269   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10270   ecode1 = SWIG_AsVal_int(obj0, &val1);
10271   if (!SWIG_IsOK(ecode1)) {
10272     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10273   } 
10274   arg1 = (PLBOOL)(val1);
10275   {
10276     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
10277     if ( tmp2 == NULL )
10278     return NULL;
10279     arg2 = Alen = tmp2->dimensions[0];
10280     arg3 = (PLFLT *) tmp2->data;
10281   }
10282   {
10283     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
10284     if ( tmp4 == NULL )
10285     return NULL;
10286     if ( tmp4->dimensions[0] != Alen )
10287     {
10288       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10289       return NULL;
10290     }
10291     arg4 = (PLFLT *) tmp4->data;
10292   }
10293   {
10294     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, PyArray_PLFLT, 1, 1 );
10295     if ( tmp5 == NULL )
10296     return NULL;
10297     if ( tmp5->dimensions[0] != Alen )
10298     {
10299       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10300       return NULL;
10301     }
10302     arg5 = (PLFLT *) tmp5->data;
10303   }
10304   {
10305     tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, PyArray_PLFLT, 1, 1 );
10306     if ( tmp6 == NULL )
10307     return NULL;
10308     if ( tmp6->dimensions[0] != Alen )
10309     {
10310       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10311       return NULL;
10312     }
10313     arg6 = (PLFLT *) tmp6->data;
10314   }
10315   {
10316     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
10317     if ( tmp7 == NULL )
10318     return NULL;
10319     if ( tmp7->dimensions[0] != Alen )
10320     {
10321       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10322       return NULL;
10323     }
10324     arg7 = (PLFLT *) tmp7->data;
10325   }
10326   {
10327     tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, PyArray_PLINT, 1, 1 );
10328     if ( tmp8 == NULL )
10329     return NULL;
10330     if ( tmp8->dimensions[0] < Alen - 1 )
10331     {
10332       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10333       return NULL;
10334     }
10335     arg8 = (PLINT *) tmp8->data;
10336   }
10337   plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10338   resultobj = SWIG_Py_Void();
10339   {
10340     Py_DECREF( tmp2 );
10341   }
10342   {
10343     Py_DECREF( tmp4 );
10344   }
10345   {
10346     Py_DECREF( tmp5 );
10347   }
10348   {
10349     Py_DECREF( tmp6 );
10350   }
10351   {
10352     Py_DECREF( tmp7 );
10353   }
10354   {
10355     Py_DECREF( tmp8 );
10356   }
10357   return resultobj;
10358 fail:
10359   {
10360     Py_DECREF( tmp2 );
10361   }
10362   {
10363     Py_DECREF( tmp4 );
10364   }
10365   {
10366     Py_DECREF( tmp5 );
10367   }
10368   {
10369     Py_DECREF( tmp6 );
10370   }
10371   {
10372     Py_DECREF( tmp7 );
10373   }
10374   {
10375     Py_DECREF( tmp8 );
10376   }
10377   return NULL;
10378 }
10379 
10380 
10381 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10382   PyObject *resultobj = 0;
10383   PLINT arg1 ;
10384   int val1 ;
10385   int ecode1 = 0 ;
10386   PyObject * obj0 = 0 ;
10387   
10388   if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
10389   ecode1 = SWIG_AsVal_int(obj0, &val1);
10390   if (!SWIG_IsOK(ecode1)) {
10391     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10392   } 
10393   arg1 = (PLINT)(val1);
10394   plscmap1n(arg1);
10395   resultobj = SWIG_Py_Void();
10396   return resultobj;
10397 fail:
10398   return NULL;
10399 }
10400 
10401 
10402 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10403   PyObject *resultobj = 0;
10404   PLINT arg1 ;
10405   PLINT arg2 ;
10406   PLINT arg3 ;
10407   PLINT arg4 ;
10408   int val1 ;
10409   int ecode1 = 0 ;
10410   int val2 ;
10411   int ecode2 = 0 ;
10412   int val3 ;
10413   int ecode3 = 0 ;
10414   int val4 ;
10415   int ecode4 = 0 ;
10416   PyObject * obj0 = 0 ;
10417   PyObject * obj1 = 0 ;
10418   PyObject * obj2 = 0 ;
10419   PyObject * obj3 = 0 ;
10420   
10421   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10422   ecode1 = SWIG_AsVal_int(obj0, &val1);
10423   if (!SWIG_IsOK(ecode1)) {
10424     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10425   } 
10426   arg1 = (PLINT)(val1);
10427   ecode2 = SWIG_AsVal_int(obj1, &val2);
10428   if (!SWIG_IsOK(ecode2)) {
10429     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10430   } 
10431   arg2 = (PLINT)(val2);
10432   ecode3 = SWIG_AsVal_int(obj2, &val3);
10433   if (!SWIG_IsOK(ecode3)) {
10434     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10435   } 
10436   arg3 = (PLINT)(val3);
10437   ecode4 = SWIG_AsVal_int(obj3, &val4);
10438   if (!SWIG_IsOK(ecode4)) {
10439     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10440   } 
10441   arg4 = (PLINT)(val4);
10442   plscol0(arg1,arg2,arg3,arg4);
10443   resultobj = SWIG_Py_Void();
10444   return resultobj;
10445 fail:
10446   return NULL;
10447 }
10448 
10449 
10450 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10451   PyObject *resultobj = 0;
10452   PLINT arg1 ;
10453   PLINT arg2 ;
10454   PLINT arg3 ;
10455   PLINT arg4 ;
10456   PLFLT arg5 ;
10457   int val1 ;
10458   int ecode1 = 0 ;
10459   int val2 ;
10460   int ecode2 = 0 ;
10461   int val3 ;
10462   int ecode3 = 0 ;
10463   int val4 ;
10464   int ecode4 = 0 ;
10465   double val5 ;
10466   int ecode5 = 0 ;
10467   PyObject * obj0 = 0 ;
10468   PyObject * obj1 = 0 ;
10469   PyObject * obj2 = 0 ;
10470   PyObject * obj3 = 0 ;
10471   PyObject * obj4 = 0 ;
10472   
10473   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10474   ecode1 = SWIG_AsVal_int(obj0, &val1);
10475   if (!SWIG_IsOK(ecode1)) {
10476     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10477   } 
10478   arg1 = (PLINT)(val1);
10479   ecode2 = SWIG_AsVal_int(obj1, &val2);
10480   if (!SWIG_IsOK(ecode2)) {
10481     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10482   } 
10483   arg2 = (PLINT)(val2);
10484   ecode3 = SWIG_AsVal_int(obj2, &val3);
10485   if (!SWIG_IsOK(ecode3)) {
10486     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10487   } 
10488   arg3 = (PLINT)(val3);
10489   ecode4 = SWIG_AsVal_int(obj3, &val4);
10490   if (!SWIG_IsOK(ecode4)) {
10491     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10492   } 
10493   arg4 = (PLINT)(val4);
10494   ecode5 = SWIG_AsVal_double(obj4, &val5);
10495   if (!SWIG_IsOK(ecode5)) {
10496     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10497   } 
10498   arg5 = (PLFLT)(val5);
10499   plscol0a(arg1,arg2,arg3,arg4,arg5);
10500   resultobj = SWIG_Py_Void();
10501   return resultobj;
10502 fail:
10503   return NULL;
10504 }
10505 
10506 
10507 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508   PyObject *resultobj = 0;
10509   PLINT arg1 ;
10510   PLINT arg2 ;
10511   PLINT arg3 ;
10512   int val1 ;
10513   int ecode1 = 0 ;
10514   int val2 ;
10515   int ecode2 = 0 ;
10516   int val3 ;
10517   int ecode3 = 0 ;
10518   PyObject * obj0 = 0 ;
10519   PyObject * obj1 = 0 ;
10520   PyObject * obj2 = 0 ;
10521   
10522   if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
10523   ecode1 = SWIG_AsVal_int(obj0, &val1);
10524   if (!SWIG_IsOK(ecode1)) {
10525     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10526   } 
10527   arg1 = (PLINT)(val1);
10528   ecode2 = SWIG_AsVal_int(obj1, &val2);
10529   if (!SWIG_IsOK(ecode2)) {
10530     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10531   } 
10532   arg2 = (PLINT)(val2);
10533   ecode3 = SWIG_AsVal_int(obj2, &val3);
10534   if (!SWIG_IsOK(ecode3)) {
10535     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10536   } 
10537   arg3 = (PLINT)(val3);
10538   plscolbg(arg1,arg2,arg3);
10539   resultobj = SWIG_Py_Void();
10540   return resultobj;
10541 fail:
10542   return NULL;
10543 }
10544 
10545 
10546 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10547   PyObject *resultobj = 0;
10548   PLINT arg1 ;
10549   PLINT arg2 ;
10550   PLINT arg3 ;
10551   PLFLT arg4 ;
10552   int val1 ;
10553   int ecode1 = 0 ;
10554   int val2 ;
10555   int ecode2 = 0 ;
10556   int val3 ;
10557   int ecode3 = 0 ;
10558   double val4 ;
10559   int ecode4 = 0 ;
10560   PyObject * obj0 = 0 ;
10561   PyObject * obj1 = 0 ;
10562   PyObject * obj2 = 0 ;
10563   PyObject * obj3 = 0 ;
10564   
10565   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10566   ecode1 = SWIG_AsVal_int(obj0, &val1);
10567   if (!SWIG_IsOK(ecode1)) {
10568     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10569   } 
10570   arg1 = (PLINT)(val1);
10571   ecode2 = SWIG_AsVal_int(obj1, &val2);
10572   if (!SWIG_IsOK(ecode2)) {
10573     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10574   } 
10575   arg2 = (PLINT)(val2);
10576   ecode3 = SWIG_AsVal_int(obj2, &val3);
10577   if (!SWIG_IsOK(ecode3)) {
10578     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10579   } 
10580   arg3 = (PLINT)(val3);
10581   ecode4 = SWIG_AsVal_double(obj3, &val4);
10582   if (!SWIG_IsOK(ecode4)) {
10583     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10584   } 
10585   arg4 = (PLFLT)(val4);
10586   plscolbga(arg1,arg2,arg3,arg4);
10587   resultobj = SWIG_Py_Void();
10588   return resultobj;
10589 fail:
10590   return NULL;
10591 }
10592 
10593 
10594 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10595   PyObject *resultobj = 0;
10596   PLINT arg1 ;
10597   int val1 ;
10598   int ecode1 = 0 ;
10599   PyObject * obj0 = 0 ;
10600   
10601   if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
10602   ecode1 = SWIG_AsVal_int(obj0, &val1);
10603   if (!SWIG_IsOK(ecode1)) {
10604     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10605   } 
10606   arg1 = (PLINT)(val1);
10607   plscolor(arg1);
10608   resultobj = SWIG_Py_Void();
10609   return resultobj;
10610 fail:
10611   return NULL;
10612 }
10613 
10614 
10615 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616   PyObject *resultobj = 0;
10617   PLINT arg1 ;
10618   int val1 ;
10619   int ecode1 = 0 ;
10620   PyObject * obj0 = 0 ;
10621   
10622   if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
10623   ecode1 = SWIG_AsVal_int(obj0, &val1);
10624   if (!SWIG_IsOK(ecode1)) {
10625     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10626   } 
10627   arg1 = (PLINT)(val1);
10628   plscompression(arg1);
10629   resultobj = SWIG_Py_Void();
10630   return resultobj;
10631 fail:
10632   return NULL;
10633 }
10634 
10635 
10636 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10637   PyObject *resultobj = 0;
10638   char *arg1 = (char *) 0 ;
10639   int res1 ;
10640   char *buf1 = 0 ;
10641   int alloc1 = 0 ;
10642   PyObject * obj0 = 0 ;
10643   
10644   if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
10645   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
10646   if (!SWIG_IsOK(res1)) {
10647     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10648   }
10649   arg1 = (char *)(buf1);
10650   plsdev((char const *)arg1);
10651   resultobj = SWIG_Py_Void();
10652   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10653   return resultobj;
10654 fail:
10655   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10656   return NULL;
10657 }
10658 
10659 
10660 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10661   PyObject *resultobj = 0;
10662   PLFLT arg1 ;
10663   PLFLT arg2 ;
10664   PLFLT arg3 ;
10665   PLFLT arg4 ;
10666   double val1 ;
10667   int ecode1 = 0 ;
10668   double val2 ;
10669   int ecode2 = 0 ;
10670   double val3 ;
10671   int ecode3 = 0 ;
10672   double val4 ;
10673   int ecode4 = 0 ;
10674   PyObject * obj0 = 0 ;
10675   PyObject * obj1 = 0 ;
10676   PyObject * obj2 = 0 ;
10677   PyObject * obj3 = 0 ;
10678   
10679   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10680   ecode1 = SWIG_AsVal_double(obj0, &val1);
10681   if (!SWIG_IsOK(ecode1)) {
10682     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10683   } 
10684   arg1 = (PLFLT)(val1);
10685   ecode2 = SWIG_AsVal_double(obj1, &val2);
10686   if (!SWIG_IsOK(ecode2)) {
10687     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10688   } 
10689   arg2 = (PLFLT)(val2);
10690   ecode3 = SWIG_AsVal_double(obj2, &val3);
10691   if (!SWIG_IsOK(ecode3)) {
10692     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10693   } 
10694   arg3 = (PLFLT)(val3);
10695   ecode4 = SWIG_AsVal_double(obj3, &val4);
10696   if (!SWIG_IsOK(ecode4)) {
10697     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10698   } 
10699   arg4 = (PLFLT)(val4);
10700   plsdidev(arg1,arg2,arg3,arg4);
10701   resultobj = SWIG_Py_Void();
10702   return resultobj;
10703 fail:
10704   return NULL;
10705 }
10706 
10707 
10708 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10709   PyObject *resultobj = 0;
10710   PLINT arg1 ;
10711   PLINT arg2 ;
10712   PLINT arg3 ;
10713   PLINT arg4 ;
10714   PLFLT arg5 ;
10715   PLFLT arg6 ;
10716   int val1 ;
10717   int ecode1 = 0 ;
10718   int val2 ;
10719   int ecode2 = 0 ;
10720   int val3 ;
10721   int ecode3 = 0 ;
10722   int val4 ;
10723   int ecode4 = 0 ;
10724   double val5 ;
10725   int ecode5 = 0 ;
10726   double val6 ;
10727   int ecode6 = 0 ;
10728   PyObject * obj0 = 0 ;
10729   PyObject * obj1 = 0 ;
10730   PyObject * obj2 = 0 ;
10731   PyObject * obj3 = 0 ;
10732   PyObject * obj4 = 0 ;
10733   PyObject * obj5 = 0 ;
10734   
10735   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10736   ecode1 = SWIG_AsVal_int(obj0, &val1);
10737   if (!SWIG_IsOK(ecode1)) {
10738     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
10739   } 
10740   arg1 = (PLINT)(val1);
10741   ecode2 = SWIG_AsVal_int(obj1, &val2);
10742   if (!SWIG_IsOK(ecode2)) {
10743     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
10744   } 
10745   arg2 = (PLINT)(val2);
10746   ecode3 = SWIG_AsVal_int(obj2, &val3);
10747   if (!SWIG_IsOK(ecode3)) {
10748     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
10749   } 
10750   arg3 = (PLINT)(val3);
10751   ecode4 = SWIG_AsVal_int(obj3, &val4);
10752   if (!SWIG_IsOK(ecode4)) {
10753     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
10754   } 
10755   arg4 = (PLINT)(val4);
10756   ecode5 = SWIG_AsVal_double(obj4, &val5);
10757   if (!SWIG_IsOK(ecode5)) {
10758     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
10759   } 
10760   arg5 = (PLFLT)(val5);
10761   ecode6 = SWIG_AsVal_double(obj5, &val6);
10762   if (!SWIG_IsOK(ecode6)) {
10763     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
10764   } 
10765   arg6 = (PLFLT)(val6);
10766   plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
10767   resultobj = SWIG_Py_Void();
10768   return resultobj;
10769 fail:
10770   return NULL;
10771 }
10772 
10773 
10774 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775   PyObject *resultobj = 0;
10776   PLFLT arg1 ;
10777   double val1 ;
10778   int ecode1 = 0 ;
10779   PyObject * obj0 = 0 ;
10780   
10781   if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
10782   ecode1 = SWIG_AsVal_double(obj0, &val1);
10783   if (!SWIG_IsOK(ecode1)) {
10784     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
10785   } 
10786   arg1 = (PLFLT)(val1);
10787   plsdiori(arg1);
10788   resultobj = SWIG_Py_Void();
10789   return resultobj;
10790 fail:
10791   return NULL;
10792 }
10793 
10794 
10795 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10796   PyObject *resultobj = 0;
10797   PLFLT arg1 ;
10798   PLFLT arg2 ;
10799   PLFLT arg3 ;
10800   PLFLT arg4 ;
10801   double val1 ;
10802   int ecode1 = 0 ;
10803   double val2 ;
10804   int ecode2 = 0 ;
10805   double val3 ;
10806   int ecode3 = 0 ;
10807   double val4 ;
10808   int ecode4 = 0 ;
10809   PyObject * obj0 = 0 ;
10810   PyObject * obj1 = 0 ;
10811   PyObject * obj2 = 0 ;
10812   PyObject * obj3 = 0 ;
10813   
10814   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10815   ecode1 = SWIG_AsVal_double(obj0, &val1);
10816   if (!SWIG_IsOK(ecode1)) {
10817     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
10818   } 
10819   arg1 = (PLFLT)(val1);
10820   ecode2 = SWIG_AsVal_double(obj1, &val2);
10821   if (!SWIG_IsOK(ecode2)) {
10822     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
10823   } 
10824   arg2 = (PLFLT)(val2);
10825   ecode3 = SWIG_AsVal_double(obj2, &val3);
10826   if (!SWIG_IsOK(ecode3)) {
10827     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
10828   } 
10829   arg3 = (PLFLT)(val3);
10830   ecode4 = SWIG_AsVal_double(obj3, &val4);
10831   if (!SWIG_IsOK(ecode4)) {
10832     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
10833   } 
10834   arg4 = (PLFLT)(val4);
10835   plsdiplt(arg1,arg2,arg3,arg4);
10836   resultobj = SWIG_Py_Void();
10837   return resultobj;
10838 fail:
10839   return NULL;
10840 }
10841 
10842 
10843 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10844   PyObject *resultobj = 0;
10845   PLFLT arg1 ;
10846   PLFLT arg2 ;
10847   PLFLT arg3 ;
10848   PLFLT arg4 ;
10849   double val1 ;
10850   int ecode1 = 0 ;
10851   double val2 ;
10852   int ecode2 = 0 ;
10853   double val3 ;
10854   int ecode3 = 0 ;
10855   double val4 ;
10856   int ecode4 = 0 ;
10857   PyObject * obj0 = 0 ;
10858   PyObject * obj1 = 0 ;
10859   PyObject * obj2 = 0 ;
10860   PyObject * obj3 = 0 ;
10861   
10862   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10863   ecode1 = SWIG_AsVal_double(obj0, &val1);
10864   if (!SWIG_IsOK(ecode1)) {
10865     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
10866   } 
10867   arg1 = (PLFLT)(val1);
10868   ecode2 = SWIG_AsVal_double(obj1, &val2);
10869   if (!SWIG_IsOK(ecode2)) {
10870     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
10871   } 
10872   arg2 = (PLFLT)(val2);
10873   ecode3 = SWIG_AsVal_double(obj2, &val3);
10874   if (!SWIG_IsOK(ecode3)) {
10875     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
10876   } 
10877   arg3 = (PLFLT)(val3);
10878   ecode4 = SWIG_AsVal_double(obj3, &val4);
10879   if (!SWIG_IsOK(ecode4)) {
10880     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
10881   } 
10882   arg4 = (PLFLT)(val4);
10883   plsdiplz(arg1,arg2,arg3,arg4);
10884   resultobj = SWIG_Py_Void();
10885   return resultobj;
10886 fail:
10887   return NULL;
10888 }
10889 
10890 
10891 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10892   PyObject *resultobj = 0;
10893   unsigned int arg1 ;
10894   unsigned int val1 ;
10895   int ecode1 = 0 ;
10896   PyObject * obj0 = 0 ;
10897   
10898   if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
10899   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
10900   if (!SWIG_IsOK(ecode1)) {
10901     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
10902   } 
10903   arg1 = (unsigned int)(val1);
10904   plseed(arg1);
10905   resultobj = SWIG_Py_Void();
10906   return resultobj;
10907 fail:
10908   return NULL;
10909 }
10910 
10911 
10912 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10913   PyObject *resultobj = 0;
10914   char arg1 ;
10915   char val1 ;
10916   int ecode1 = 0 ;
10917   PyObject * obj0 = 0 ;
10918   
10919   if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
10920   ecode1 = SWIG_AsVal_char(obj0, &val1);
10921   if (!SWIG_IsOK(ecode1)) {
10922     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
10923   } 
10924   arg1 = (char)(val1);
10925   plsesc(arg1);
10926   resultobj = SWIG_Py_Void();
10927   return resultobj;
10928 fail:
10929   return NULL;
10930 }
10931 
10932 
10933 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934   PyObject *resultobj = 0;
10935   char *arg1 = (char *) 0 ;
10936   char *arg2 = (char *) 0 ;
10937   int res1 ;
10938   char *buf1 = 0 ;
10939   int alloc1 = 0 ;
10940   int res2 ;
10941   char *buf2 = 0 ;
10942   int alloc2 = 0 ;
10943   PyObject * obj0 = 0 ;
10944   PyObject * obj1 = 0 ;
10945   PLINT result;
10946   
10947   if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
10948   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
10949   if (!SWIG_IsOK(res1)) {
10950     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
10951   }
10952   arg1 = (char *)(buf1);
10953   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10954   if (!SWIG_IsOK(res2)) {
10955     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
10956   }
10957   arg2 = (char *)(buf2);
10958   result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
10959   resultobj = SWIG_From_int((int)(result));
10960   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10961   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10962   return resultobj;
10963 fail:
10964   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10965   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10966   return NULL;
10967 }
10968 
10969 
10970 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971   PyObject *resultobj = 0;
10972   PLINT arg1 ;
10973   PLINT arg2 ;
10974   PLINT arg3 ;
10975   int val1 ;
10976   int ecode1 = 0 ;
10977   int val2 ;
10978   int ecode2 = 0 ;
10979   int val3 ;
10980   int ecode3 = 0 ;
10981   PyObject * obj0 = 0 ;
10982   PyObject * obj1 = 0 ;
10983   PyObject * obj2 = 0 ;
10984   
10985   if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
10986   ecode1 = SWIG_AsVal_int(obj0, &val1);
10987   if (!SWIG_IsOK(ecode1)) {
10988     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
10989   } 
10990   arg1 = (PLINT)(val1);
10991   ecode2 = SWIG_AsVal_int(obj1, &val2);
10992   if (!SWIG_IsOK(ecode2)) {
10993     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
10994   } 
10995   arg2 = (PLINT)(val2);
10996   ecode3 = SWIG_AsVal_int(obj2, &val3);
10997   if (!SWIG_IsOK(ecode3)) {
10998     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
10999   } 
11000   arg3 = (PLINT)(val3);
11001   plsfam(arg1,arg2,arg3);
11002   resultobj = SWIG_Py_Void();
11003   return resultobj;
11004 fail:
11005   return NULL;
11006 }
11007 
11008 
11009 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11010   PyObject *resultobj = 0;
11011   PLUNICODE arg1 ;
11012   unsigned int val1 ;
11013   int ecode1 = 0 ;
11014   PyObject * obj0 = 0 ;
11015   
11016   if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11017   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11018   if (!SWIG_IsOK(ecode1)) {
11019     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11020   } 
11021   arg1 = (PLUNICODE)(val1);
11022   plsfci(arg1);
11023   resultobj = SWIG_Py_Void();
11024   return resultobj;
11025 fail:
11026   return NULL;
11027 }
11028 
11029 
11030 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031   PyObject *resultobj = 0;
11032   char *arg1 = (char *) 0 ;
11033   int res1 ;
11034   char *buf1 = 0 ;
11035   int alloc1 = 0 ;
11036   PyObject * obj0 = 0 ;
11037   
11038   if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11039   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11040   if (!SWIG_IsOK(res1)) {
11041     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11042   }
11043   arg1 = (char *)(buf1);
11044   plsfnam((char const *)arg1);
11045   resultobj = SWIG_Py_Void();
11046   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11047   return resultobj;
11048 fail:
11049   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11050   return NULL;
11051 }
11052 
11053 
11054 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055   PyObject *resultobj = 0;
11056   PLINT arg1 ;
11057   PLINT arg2 ;
11058   PLINT arg3 ;
11059   int val1 ;
11060   int ecode1 = 0 ;
11061   int val2 ;
11062   int ecode2 = 0 ;
11063   int val3 ;
11064   int ecode3 = 0 ;
11065   PyObject * obj0 = 0 ;
11066   PyObject * obj1 = 0 ;
11067   PyObject * obj2 = 0 ;
11068   
11069   if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11070   ecode1 = SWIG_AsVal_int(obj0, &val1);
11071   if (!SWIG_IsOK(ecode1)) {
11072     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11073   } 
11074   arg1 = (PLINT)(val1);
11075   ecode2 = SWIG_AsVal_int(obj1, &val2);
11076   if (!SWIG_IsOK(ecode2)) {
11077     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11078   } 
11079   arg2 = (PLINT)(val2);
11080   ecode3 = SWIG_AsVal_int(obj2, &val3);
11081   if (!SWIG_IsOK(ecode3)) {
11082     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11083   } 
11084   arg3 = (PLINT)(val3);
11085   plsfont(arg1,arg2,arg3);
11086   resultobj = SWIG_Py_Void();
11087   return resultobj;
11088 fail:
11089   return NULL;
11090 }
11091 
11092 
11093 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094   PyObject *resultobj = 0;
11095   PLFLT **arg1 = (PLFLT **) 0 ;
11096   PLINT arg2 ;
11097   PLINT arg3 ;
11098   defined_func arg4 = (defined_func) 0 ;
11099   PLFLT arg5 ;
11100   PLFLT arg6 ;
11101   PLFLT arg7 ;
11102   PLFLT arg8 ;
11103   PLFLT *arg9 = (PLFLT *) 0 ;
11104   PLINT arg10 ;
11105   PLINT arg11 ;
11106   PLINT arg12 ;
11107   PLINT arg13 ;
11108   fill_func arg14 = (fill_func) 0 ;
11109   PLBOOL arg15 ;
11110   pltr_func arg16 = (pltr_func) 0 ;
11111   PLPointer arg17 = (PLPointer) 0 ;
11112   PyArrayObject *tmp1 ;
11113   double val5 ;
11114   int ecode5 = 0 ;
11115   double val6 ;
11116   int ecode6 = 0 ;
11117   double val7 ;
11118   int ecode7 = 0 ;
11119   double val8 ;
11120   int ecode8 = 0 ;
11121   PyArrayObject *tmp9 ;
11122   int val11 ;
11123   int ecode11 = 0 ;
11124   int val12 ;
11125   int ecode12 = 0 ;
11126   int val13 ;
11127   int ecode13 = 0 ;
11128   int val15 ;
11129   int ecode15 = 0 ;
11130   PyObject * obj0 = 0 ;
11131   PyObject * obj1 = 0 ;
11132   PyObject * obj2 = 0 ;
11133   PyObject * obj3 = 0 ;
11134   PyObject * obj4 = 0 ;
11135   PyObject * obj5 = 0 ;
11136   PyObject * obj6 = 0 ;
11137   PyObject * obj7 = 0 ;
11138   PyObject * obj8 = 0 ;
11139   PyObject * obj9 = 0 ;
11140   PyObject * obj10 = 0 ;
11141   PyObject * obj11 = 0 ;
11142   
11143   {
11144     python_pltr = 0;
11145     arg16          = NULL;
11146   }
11147   {
11148     arg17 = NULL;
11149   }
11150   {
11151     arg4 = NULL;
11152   }
11153   {
11154     arg14 = plfill;
11155   }
11156   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11157   {
11158     int i, size;
11159     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
11160     if ( tmp1 == NULL )
11161     return NULL;
11162     Xlen = arg2 = tmp1->dimensions[0];
11163     Ylen = arg3 = tmp1->dimensions[1];
11164     size = sizeof ( PLFLT ) * arg3;
11165     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11166     for ( i = 0; i < arg2; i++ )
11167     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
11168   }
11169   ecode5 = SWIG_AsVal_double(obj1, &val5);
11170   if (!SWIG_IsOK(ecode5)) {
11171     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11172   } 
11173   arg5 = (PLFLT)(val5);
11174   ecode6 = SWIG_AsVal_double(obj2, &val6);
11175   if (!SWIG_IsOK(ecode6)) {
11176     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11177   } 
11178   arg6 = (PLFLT)(val6);
11179   ecode7 = SWIG_AsVal_double(obj3, &val7);
11180   if (!SWIG_IsOK(ecode7)) {
11181     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11182   } 
11183   arg7 = (PLFLT)(val7);
11184   ecode8 = SWIG_AsVal_double(obj4, &val8);
11185   if (!SWIG_IsOK(ecode8)) {
11186     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11187   } 
11188   arg8 = (PLFLT)(val8);
11189   {
11190     tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, PyArray_PLFLT, 1, 1 );
11191     if ( tmp9 == NULL )
11192     return NULL;
11193     arg10 = tmp9->dimensions[0];
11194     arg9 = (PLFLT *) tmp9->data;
11195   }
11196   ecode11 = SWIG_AsVal_int(obj6, &val11);
11197   if (!SWIG_IsOK(ecode11)) {
11198     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
11199   } 
11200   arg11 = (PLINT)(val11);
11201   ecode12 = SWIG_AsVal_int(obj7, &val12);
11202   if (!SWIG_IsOK(ecode12)) {
11203     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11204   } 
11205   arg12 = (PLINT)(val12);
11206   ecode13 = SWIG_AsVal_int(obj8, &val13);
11207   if (!SWIG_IsOK(ecode13)) {
11208     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLINT""'");
11209   } 
11210   arg13 = (PLINT)(val13);
11211   ecode15 = SWIG_AsVal_int(obj9, &val15);
11212   if (!SWIG_IsOK(ecode15)) {
11213     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11214   } 
11215   arg15 = (PLBOOL)(val15);
11216   if (obj10) {
11217     {
11218       // it must be a callable or None
11219       if ( obj10 == Py_None )
11220       {
11221         arg16 = NULL;
11222       }
11223       else
11224       {
11225         if ( !PyCallable_Check( (PyObject *) obj10 ) )
11226         {
11227           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11228           return NULL;
11229         }
11230         arg16 = marshal_pltr( obj10 );
11231       }
11232     }
11233   }
11234   if (obj11) {
11235     {
11236       if ( obj11 == Py_None )
11237       arg17 = NULL;
11238       else
11239       {
11240         arg17 = marshal_PLPointer( obj11, 0 );
11241       }
11242     }
11243   }
11244   plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11245   resultobj = SWIG_Py_Void();
11246   {
11247     Py_DECREF( tmp1 );
11248     free( arg1 );
11249   }
11250   {
11251     Py_DECREF( tmp9 );
11252   }
11253   {
11254     cleanup_pltr();
11255   }
11256   {
11257     cleanup_PLPointer();
11258   }
11259   return resultobj;
11260 fail:
11261   {
11262     Py_DECREF( tmp1 );
11263     free( arg1 );
11264   }
11265   {
11266     Py_DECREF( tmp9 );
11267   }
11268   {
11269     cleanup_pltr();
11270   }
11271   {
11272     cleanup_PLPointer();
11273   }
11274   return NULL;
11275 }
11276 
11277 
11278 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11279   PyObject *resultobj = 0;
11280   PLFLT **arg1 = (PLFLT **) 0 ;
11281   PLINT arg2 ;
11282   PLINT arg3 ;
11283   defined_func arg4 = (defined_func) 0 ;
11284   PLFLT arg5 ;
11285   PLFLT arg6 ;
11286   PLFLT arg7 ;
11287   PLFLT arg8 ;
11288   PLFLT arg9 ;
11289   PLFLT arg10 ;
11290   PLINT arg11 ;
11291   PLFLT arg12 ;
11292   PLINT arg13 ;
11293   PLINT arg14 ;
11294   PLINT arg15 ;
11295   PLINT arg16 ;
11296   PLINT arg17 ;
11297   fill_func arg18 = (fill_func) 0 ;
11298   PLBOOL arg19 ;
11299   pltr_func arg20 = (pltr_func) 0 ;
11300   PLPointer arg21 = (PLPointer) 0 ;
11301   PyArrayObject *tmp1 ;
11302   double val5 ;
11303   int ecode5 = 0 ;
11304   double val6 ;
11305   int ecode6 = 0 ;
11306   double val7 ;
11307   int ecode7 = 0 ;
11308   double val8 ;
11309   int ecode8 = 0 ;
11310   double val9 ;
11311   int ecode9 = 0 ;
11312   double val10 ;
11313   int ecode10 = 0 ;
11314   int val11 ;
11315   int ecode11 = 0 ;
11316   double val12 ;
11317   int ecode12 = 0 ;
11318   int val13 ;
11319   int ecode13 = 0 ;
11320   int val14 ;
11321   int ecode14 = 0 ;
11322   int val15 ;
11323   int ecode15 = 0 ;
11324   int val16 ;
11325   int ecode16 = 0 ;
11326   int val17 ;
11327   int ecode17 = 0 ;
11328   int val19 ;
11329   int ecode19 = 0 ;
11330   PyObject * obj0 = 0 ;
11331   PyObject * obj1 = 0 ;
11332   PyObject * obj2 = 0 ;
11333   PyObject * obj3 = 0 ;
11334   PyObject * obj4 = 0 ;
11335   PyObject * obj5 = 0 ;
11336   PyObject * obj6 = 0 ;
11337   PyObject * obj7 = 0 ;
11338   PyObject * obj8 = 0 ;
11339   PyObject * obj9 = 0 ;
11340   PyObject * obj10 = 0 ;
11341   PyObject * obj11 = 0 ;
11342   PyObject * obj12 = 0 ;
11343   PyObject * obj13 = 0 ;
11344   PyObject * obj14 = 0 ;
11345   PyObject * obj15 = 0 ;
11346   PyObject * obj16 = 0 ;
11347   
11348   {
11349     python_pltr = 0;
11350     arg20          = NULL;
11351   }
11352   {
11353     arg21 = NULL;
11354   }
11355   {
11356     arg4 = NULL;
11357   }
11358   {
11359     arg18 = plfill;
11360   }
11361   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
11362   {
11363     int i, size;
11364     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
11365     if ( tmp1 == NULL )
11366     return NULL;
11367     Xlen = arg2 = tmp1->dimensions[0];
11368     Ylen = arg3 = tmp1->dimensions[1];
11369     size = sizeof ( PLFLT ) * arg3;
11370     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
11371     for ( i = 0; i < arg2; i++ )
11372     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
11373   }
11374   ecode5 = SWIG_AsVal_double(obj1, &val5);
11375   if (!SWIG_IsOK(ecode5)) {
11376     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11377   } 
11378   arg5 = (PLFLT)(val5);
11379   ecode6 = SWIG_AsVal_double(obj2, &val6);
11380   if (!SWIG_IsOK(ecode6)) {
11381     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11382   } 
11383   arg6 = (PLFLT)(val6);
11384   ecode7 = SWIG_AsVal_double(obj3, &val7);
11385   if (!SWIG_IsOK(ecode7)) {
11386     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11387   } 
11388   arg7 = (PLFLT)(val7);
11389   ecode8 = SWIG_AsVal_double(obj4, &val8);
11390   if (!SWIG_IsOK(ecode8)) {
11391     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11392   } 
11393   arg8 = (PLFLT)(val8);
11394   ecode9 = SWIG_AsVal_double(obj5, &val9);
11395   if (!SWIG_IsOK(ecode9)) {
11396     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11397   } 
11398   arg9 = (PLFLT)(val9);
11399   ecode10 = SWIG_AsVal_double(obj6, &val10);
11400   if (!SWIG_IsOK(ecode10)) {
11401     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11402   } 
11403   arg10 = (PLFLT)(val10);
11404   ecode11 = SWIG_AsVal_int(obj7, &val11);
11405   if (!SWIG_IsOK(ecode11)) {
11406     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11407   } 
11408   arg11 = (PLINT)(val11);
11409   ecode12 = SWIG_AsVal_double(obj8, &val12);
11410   if (!SWIG_IsOK(ecode12)) {
11411     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11412   } 
11413   arg12 = (PLFLT)(val12);
11414   ecode13 = SWIG_AsVal_int(obj9, &val13);
11415   if (!SWIG_IsOK(ecode13)) {
11416     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
11417   } 
11418   arg13 = (PLINT)(val13);
11419   ecode14 = SWIG_AsVal_int(obj10, &val14);
11420   if (!SWIG_IsOK(ecode14)) {
11421     SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11422   } 
11423   arg14 = (PLINT)(val14);
11424   ecode15 = SWIG_AsVal_int(obj11, &val15);
11425   if (!SWIG_IsOK(ecode15)) {
11426     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
11427   } 
11428   arg15 = (PLINT)(val15);
11429   ecode16 = SWIG_AsVal_int(obj12, &val16);
11430   if (!SWIG_IsOK(ecode16)) {
11431     SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11432   } 
11433   arg16 = (PLINT)(val16);
11434   ecode17 = SWIG_AsVal_int(obj13, &val17);
11435   if (!SWIG_IsOK(ecode17)) {
11436     SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
11437   } 
11438   arg17 = (PLINT)(val17);
11439   ecode19 = SWIG_AsVal_int(obj14, &val19);
11440   if (!SWIG_IsOK(ecode19)) {
11441     SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11442   } 
11443   arg19 = (PLBOOL)(val19);
11444   if (obj15) {
11445     {
11446       // it must be a callable or None
11447       if ( obj15 == Py_None )
11448       {
11449         arg20 = NULL;
11450       }
11451       else
11452       {
11453         if ( !PyCallable_Check( (PyObject *) obj15 ) )
11454         {
11455           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11456           return NULL;
11457         }
11458         arg20 = marshal_pltr( obj15 );
11459       }
11460     }
11461   }
11462   if (obj16) {
11463     {
11464       if ( obj16 == Py_None )
11465       arg21 = NULL;
11466       else
11467       {
11468         arg21 = marshal_PLPointer( obj16, 0 );
11469       }
11470     }
11471   }
11472   plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11473   resultobj = SWIG_Py_Void();
11474   {
11475     Py_DECREF( tmp1 );
11476     free( arg1 );
11477   }
11478   {
11479     cleanup_pltr();
11480   }
11481   {
11482     cleanup_PLPointer();
11483   }
11484   return resultobj;
11485 fail:
11486   {
11487     Py_DECREF( tmp1 );
11488     free( arg1 );
11489   }
11490   {
11491     cleanup_pltr();
11492   }
11493   {
11494     cleanup_PLPointer();
11495   }
11496   return NULL;
11497 }
11498 
11499 
11500 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11501   PyObject *resultobj = 0;
11502   label_func arg1 = (label_func) 0 ;
11503   PLPointer arg2 = (PLPointer) 0 ;
11504   int res2 ;
11505   PyObject * obj0 = 0 ;
11506   PyObject * obj1 = 0 ;
11507   
11508   if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
11509   {
11510     // Release reference to previous function if applicable
11511     if ( python_label )
11512     {
11513       Py_XDECREF( python_label );
11514       python_label = 0;
11515     }
11516     // it must be a callable or None
11517     if ( obj0 == Py_None )
11518     {
11519       arg1 = NULL;
11520     }
11521     else
11522     {
11523       if ( !PyCallable_Check( (PyObject *) obj0 ) )
11524       {
11525         PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11526         return NULL;
11527       }
11528       // hold a reference to it
11529       Py_XINCREF( (PyObject *) obj0 );
11530       python_label = (PyObject *) obj0;
11531       // this function handles calling the python function
11532       arg1 = do_label_callback;
11533     }
11534   }
11535   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
11536   if (!SWIG_IsOK(res2)) {
11537     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'"); 
11538   }
11539   plslabelfunc(arg1,arg2);
11540   resultobj = SWIG_Py_Void();
11541   return resultobj;
11542 fail:
11543   return NULL;
11544 }
11545 
11546 
11547 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11548   PyObject *resultobj = 0;
11549   PLFLT arg1 ;
11550   PLFLT arg2 ;
11551   double val1 ;
11552   int ecode1 = 0 ;
11553   double val2 ;
11554   int ecode2 = 0 ;
11555   PyObject * obj0 = 0 ;
11556   PyObject * obj1 = 0 ;
11557   
11558   if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
11559   ecode1 = SWIG_AsVal_double(obj0, &val1);
11560   if (!SWIG_IsOK(ecode1)) {
11561     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11562   } 
11563   arg1 = (PLFLT)(val1);
11564   ecode2 = SWIG_AsVal_double(obj1, &val2);
11565   if (!SWIG_IsOK(ecode2)) {
11566     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11567   } 
11568   arg2 = (PLFLT)(val2);
11569   plsmaj(arg1,arg2);
11570   resultobj = SWIG_Py_Void();
11571   return resultobj;
11572 fail:
11573   return NULL;
11574 }
11575 
11576 
11577 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11578   PyObject *resultobj = 0;
11579   PLINT arg1 ;
11580   PLINT arg2 ;
11581   void *arg3 = (void *) 0 ;
11582   int val1 ;
11583   int ecode1 = 0 ;
11584   int val2 ;
11585   int ecode2 = 0 ;
11586   int res3 ;
11587   Py_ssize_t size3 = 0 ;
11588   void *buf3 = 0 ;
11589   PyObject * obj0 = 0 ;
11590   PyObject * obj1 = 0 ;
11591   PyObject * obj2 = 0 ;
11592   
11593   if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
11594   ecode1 = SWIG_AsVal_int(obj0, &val1);
11595   if (!SWIG_IsOK(ecode1)) {
11596     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11597   } 
11598   arg1 = (PLINT)(val1);
11599   ecode2 = SWIG_AsVal_int(obj1, &val2);
11600   if (!SWIG_IsOK(ecode2)) {
11601     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11602   } 
11603   arg2 = (PLINT)(val2);
11604   {
11605     res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
11606     if (res3<0) {
11607       PyErr_Clear();
11608       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
11609     }
11610     arg3 = (void *) buf3;
11611   }
11612   plsmem(arg1,arg2,arg3);
11613   resultobj = SWIG_Py_Void();
11614   return resultobj;
11615 fail:
11616   return NULL;
11617 }
11618 
11619 
11620 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11621   PyObject *resultobj = 0;
11622   PLINT arg1 ;
11623   PLINT arg2 ;
11624   void *arg3 = (void *) 0 ;
11625   int val1 ;
11626   int ecode1 = 0 ;
11627   int val2 ;
11628   int ecode2 = 0 ;
11629   int res3 ;
11630   Py_ssize_t size3 = 0 ;
11631   void *buf3 = 0 ;
11632   PyObject * obj0 = 0 ;
11633   PyObject * obj1 = 0 ;
11634   PyObject * obj2 = 0 ;
11635   
11636   if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
11637   ecode1 = SWIG_AsVal_int(obj0, &val1);
11638   if (!SWIG_IsOK(ecode1)) {
11639     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11640   } 
11641   arg1 = (PLINT)(val1);
11642   ecode2 = SWIG_AsVal_int(obj1, &val2);
11643   if (!SWIG_IsOK(ecode2)) {
11644     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11645   } 
11646   arg2 = (PLINT)(val2);
11647   {
11648     res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
11649     if (res3<0) {
11650       PyErr_Clear();
11651       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
11652     }
11653     arg3 = (void *) buf3;
11654   }
11655   plsmema(arg1,arg2,arg3);
11656   resultobj = SWIG_Py_Void();
11657   return resultobj;
11658 fail:
11659   return NULL;
11660 }
11661 
11662 
11663 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664   PyObject *resultobj = 0;
11665   PLFLT arg1 ;
11666   PLFLT arg2 ;
11667   double val1 ;
11668   int ecode1 = 0 ;
11669   double val2 ;
11670   int ecode2 = 0 ;
11671   PyObject * obj0 = 0 ;
11672   PyObject * obj1 = 0 ;
11673   
11674   if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
11675   ecode1 = SWIG_AsVal_double(obj0, &val1);
11676   if (!SWIG_IsOK(ecode1)) {
11677     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11678   } 
11679   arg1 = (PLFLT)(val1);
11680   ecode2 = SWIG_AsVal_double(obj1, &val2);
11681   if (!SWIG_IsOK(ecode2)) {
11682     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11683   } 
11684   arg2 = (PLFLT)(val2);
11685   plsmin(arg1,arg2);
11686   resultobj = SWIG_Py_Void();
11687   return resultobj;
11688 fail:
11689   return NULL;
11690 }
11691 
11692 
11693 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694   PyObject *resultobj = 0;
11695   PLINT arg1 ;
11696   int val1 ;
11697   int ecode1 = 0 ;
11698   PyObject * obj0 = 0 ;
11699   
11700   if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
11701   ecode1 = SWIG_AsVal_int(obj0, &val1);
11702   if (!SWIG_IsOK(ecode1)) {
11703     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11704   } 
11705   arg1 = (PLINT)(val1);
11706   plsori(arg1);
11707   resultobj = SWIG_Py_Void();
11708   return resultobj;
11709 fail:
11710   return NULL;
11711 }
11712 
11713 
11714 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715   PyObject *resultobj = 0;
11716   PLFLT arg1 ;
11717   PLFLT arg2 ;
11718   PLINT arg3 ;
11719   PLINT arg4 ;
11720   PLINT arg5 ;
11721   PLINT arg6 ;
11722   double val1 ;
11723   int ecode1 = 0 ;
11724   double val2 ;
11725   int ecode2 = 0 ;
11726   int val3 ;
11727   int ecode3 = 0 ;
11728   int val4 ;
11729   int ecode4 = 0 ;
11730   int val5 ;
11731   int ecode5 = 0 ;
11732   int val6 ;
11733   int ecode6 = 0 ;
11734   PyObject * obj0 = 0 ;
11735   PyObject * obj1 = 0 ;
11736   PyObject * obj2 = 0 ;
11737   PyObject * obj3 = 0 ;
11738   PyObject * obj4 = 0 ;
11739   PyObject * obj5 = 0 ;
11740   
11741   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11742   ecode1 = SWIG_AsVal_double(obj0, &val1);
11743   if (!SWIG_IsOK(ecode1)) {
11744     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11745   } 
11746   arg1 = (PLFLT)(val1);
11747   ecode2 = SWIG_AsVal_double(obj1, &val2);
11748   if (!SWIG_IsOK(ecode2)) {
11749     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11750   } 
11751   arg2 = (PLFLT)(val2);
11752   ecode3 = SWIG_AsVal_int(obj2, &val3);
11753   if (!SWIG_IsOK(ecode3)) {
11754     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
11755   } 
11756   arg3 = (PLINT)(val3);
11757   ecode4 = SWIG_AsVal_int(obj3, &val4);
11758   if (!SWIG_IsOK(ecode4)) {
11759     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
11760   } 
11761   arg4 = (PLINT)(val4);
11762   ecode5 = SWIG_AsVal_int(obj4, &val5);
11763   if (!SWIG_IsOK(ecode5)) {
11764     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
11765   } 
11766   arg5 = (PLINT)(val5);
11767   ecode6 = SWIG_AsVal_int(obj5, &val6);
11768   if (!SWIG_IsOK(ecode6)) {
11769     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
11770   } 
11771   arg6 = (PLINT)(val6);
11772   plspage(arg1,arg2,arg3,arg4,arg5,arg6);
11773   resultobj = SWIG_Py_Void();
11774   return resultobj;
11775 fail:
11776   return NULL;
11777 }
11778 
11779 
11780 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11781   PyObject *resultobj = 0;
11782   char *arg1 = (char *) 0 ;
11783   int res1 ;
11784   char *buf1 = 0 ;
11785   int alloc1 = 0 ;
11786   PyObject * obj0 = 0 ;
11787   
11788   if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
11789   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11790   if (!SWIG_IsOK(res1)) {
11791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
11792   }
11793   arg1 = (char *)(buf1);
11794   plspal0((char const *)arg1);
11795   resultobj = SWIG_Py_Void();
11796   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11797   return resultobj;
11798 fail:
11799   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11800   return NULL;
11801 }
11802 
11803 
11804 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11805   PyObject *resultobj = 0;
11806   char *arg1 = (char *) 0 ;
11807   PLBOOL arg2 ;
11808   int res1 ;
11809   char *buf1 = 0 ;
11810   int alloc1 = 0 ;
11811   int val2 ;
11812   int ecode2 = 0 ;
11813   PyObject * obj0 = 0 ;
11814   PyObject * obj1 = 0 ;
11815   
11816   if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
11817   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11818   if (!SWIG_IsOK(res1)) {
11819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
11820   }
11821   arg1 = (char *)(buf1);
11822   ecode2 = SWIG_AsVal_int(obj1, &val2);
11823   if (!SWIG_IsOK(ecode2)) {
11824     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
11825   } 
11826   arg2 = (PLBOOL)(val2);
11827   plspal1((char const *)arg1,arg2);
11828   resultobj = SWIG_Py_Void();
11829   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11830   return resultobj;
11831 fail:
11832   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11833   return NULL;
11834 }
11835 
11836 
11837 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838   PyObject *resultobj = 0;
11839   PLBOOL arg1 ;
11840   int val1 ;
11841   int ecode1 = 0 ;
11842   PyObject * obj0 = 0 ;
11843   
11844   if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
11845   ecode1 = SWIG_AsVal_int(obj0, &val1);
11846   if (!SWIG_IsOK(ecode1)) {
11847     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
11848   } 
11849   arg1 = (PLBOOL)(val1);
11850   plspause(arg1);
11851   resultobj = SWIG_Py_Void();
11852   return resultobj;
11853 fail:
11854   return NULL;
11855 }
11856 
11857 
11858 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11859   PyObject *resultobj = 0;
11860   PLINT arg1 ;
11861   int val1 ;
11862   int ecode1 = 0 ;
11863   PyObject * obj0 = 0 ;
11864   
11865   if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
11866   ecode1 = SWIG_AsVal_int(obj0, &val1);
11867   if (!SWIG_IsOK(ecode1)) {
11868     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
11869   } 
11870   arg1 = (PLINT)(val1);
11871   plsstrm(arg1);
11872   resultobj = SWIG_Py_Void();
11873   return resultobj;
11874 fail:
11875   return NULL;
11876 }
11877 
11878 
11879 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880   PyObject *resultobj = 0;
11881   PLINT arg1 ;
11882   PLINT arg2 ;
11883   int val1 ;
11884   int ecode1 = 0 ;
11885   int val2 ;
11886   int ecode2 = 0 ;
11887   PyObject * obj0 = 0 ;
11888   PyObject * obj1 = 0 ;
11889   
11890   if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
11891   ecode1 = SWIG_AsVal_int(obj0, &val1);
11892   if (!SWIG_IsOK(ecode1)) {
11893     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
11894   } 
11895   arg1 = (PLINT)(val1);
11896   ecode2 = SWIG_AsVal_int(obj1, &val2);
11897   if (!SWIG_IsOK(ecode2)) {
11898     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
11899   } 
11900   arg2 = (PLINT)(val2);
11901   plssub(arg1,arg2);
11902   resultobj = SWIG_Py_Void();
11903   return resultobj;
11904 fail:
11905   return NULL;
11906 }
11907 
11908 
11909 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910   PyObject *resultobj = 0;
11911   PLFLT arg1 ;
11912   PLFLT arg2 ;
11913   double val1 ;
11914   int ecode1 = 0 ;
11915   double val2 ;
11916   int ecode2 = 0 ;
11917   PyObject * obj0 = 0 ;
11918   PyObject * obj1 = 0 ;
11919   
11920   if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
11921   ecode1 = SWIG_AsVal_double(obj0, &val1);
11922   if (!SWIG_IsOK(ecode1)) {
11923     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
11924   } 
11925   arg1 = (PLFLT)(val1);
11926   ecode2 = SWIG_AsVal_double(obj1, &val2);
11927   if (!SWIG_IsOK(ecode2)) {
11928     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
11929   } 
11930   arg2 = (PLFLT)(val2);
11931   plssym(arg1,arg2);
11932   resultobj = SWIG_Py_Void();
11933   return resultobj;
11934 fail:
11935   return NULL;
11936 }
11937 
11938 
11939 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940   PyObject *resultobj = 0;
11941   PLINT arg1 ;
11942   PLINT arg2 ;
11943   int val1 ;
11944   int ecode1 = 0 ;
11945   int val2 ;
11946   int ecode2 = 0 ;
11947   PyObject * obj0 = 0 ;
11948   PyObject * obj1 = 0 ;
11949   
11950   if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
11951   ecode1 = SWIG_AsVal_int(obj0, &val1);
11952   if (!SWIG_IsOK(ecode1)) {
11953     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
11954   } 
11955   arg1 = (PLINT)(val1);
11956   ecode2 = SWIG_AsVal_int(obj1, &val2);
11957   if (!SWIG_IsOK(ecode2)) {
11958     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
11959   } 
11960   arg2 = (PLINT)(val2);
11961   plstar(arg1,arg2);
11962   resultobj = SWIG_Py_Void();
11963   return resultobj;
11964 fail:
11965   return NULL;
11966 }
11967 
11968 
11969 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11970   PyObject *resultobj = 0;
11971   char *arg1 = (char *) 0 ;
11972   PLINT arg2 ;
11973   PLINT arg3 ;
11974   int res1 ;
11975   char *buf1 = 0 ;
11976   int alloc1 = 0 ;
11977   int val2 ;
11978   int ecode2 = 0 ;
11979   int val3 ;
11980   int ecode3 = 0 ;
11981   PyObject * obj0 = 0 ;
11982   PyObject * obj1 = 0 ;
11983   PyObject * obj2 = 0 ;
11984   
11985   if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
11986   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11987   if (!SWIG_IsOK(res1)) {
11988     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
11989   }
11990   arg1 = (char *)(buf1);
11991   ecode2 = SWIG_AsVal_int(obj1, &val2);
11992   if (!SWIG_IsOK(ecode2)) {
11993     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
11994   } 
11995   arg2 = (PLINT)(val2);
11996   ecode3 = SWIG_AsVal_int(obj2, &val3);
11997   if (!SWIG_IsOK(ecode3)) {
11998     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
11999   } 
12000   arg3 = (PLINT)(val3);
12001   plstart((char const *)arg1,arg2,arg3);
12002   resultobj = SWIG_Py_Void();
12003   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12004   return resultobj;
12005 fail:
12006   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12007   return NULL;
12008 }
12009 
12010 
12011 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12012   PyObject *resultobj = 0;
12013   ct_func arg1 = (ct_func) 0 ;
12014   PLPointer arg2 = (PLPointer) 0 ;
12015   int res2 ;
12016   PyObject * obj0 = 0 ;
12017   PyObject * obj1 = 0 ;
12018   
12019   {
12020     python_ct = 0;
12021     arg1        = NULL;
12022   }
12023   if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12024   if (obj0) {
12025     {
12026       if ( python_ct )
12027       cleanup_ct();
12028       // it must be a callable or none
12029       if ( obj0 == Py_None )
12030       {
12031         arg1 = NULL;
12032       }
12033       else
12034       {
12035         if ( !PyCallable_Check( (PyObject *) obj0 ) )
12036         {
12037           PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12038           return NULL;
12039         }
12040         arg1 = marshal_ct( obj0 );
12041       }
12042     }
12043   }
12044   if (obj1) {
12045     res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12046     if (!SWIG_IsOK(res2)) {
12047       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'"); 
12048     }
12049   }
12050   plstransform(arg1,arg2);
12051   resultobj = SWIG_Py_Void();
12052   return resultobj;
12053 fail:
12054   return NULL;
12055 }
12056 
12057 
12058 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12059   PyObject *resultobj = 0;
12060   PLINT arg1 ;
12061   PLFLT *arg2 = (PLFLT *) 0 ;
12062   PLFLT *arg3 = (PLFLT *) 0 ;
12063   char *arg4 = (char *) 0 ;
12064   PyArrayObject *tmp1 ;
12065   PyArrayObject *tmp3 ;
12066   int res4 ;
12067   char *buf4 = 0 ;
12068   int alloc4 = 0 ;
12069   PyObject * obj0 = 0 ;
12070   PyObject * obj1 = 0 ;
12071   PyObject * obj2 = 0 ;
12072   
12073   if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12074   {
12075     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12076     if ( tmp1 == NULL )
12077     return NULL;
12078     arg1 = Alen = tmp1->dimensions[0];
12079     arg2 = (PLFLT *) tmp1->data;
12080   }
12081   {
12082     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12083     if ( tmp3 == NULL )
12084     return NULL;
12085     if ( tmp3->dimensions[0] != Alen )
12086     {
12087       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12088       return NULL;
12089     }
12090     arg3 = (PLFLT *) tmp3->data;
12091   }
12092   res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12093   if (!SWIG_IsOK(res4)) {
12094     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12095   }
12096   arg4 = (char *)(buf4);
12097   plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12098   resultobj = SWIG_Py_Void();
12099   {
12100     Py_DECREF( tmp1 );
12101   }
12102   {
12103     Py_DECREF( tmp3 );
12104   }
12105   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12106   return resultobj;
12107 fail:
12108   {
12109     Py_DECREF( tmp1 );
12110   }
12111   {
12112     Py_DECREF( tmp3 );
12113   }
12114   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12115   return NULL;
12116 }
12117 
12118 
12119 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12120   PyObject *resultobj = 0;
12121   PLINT arg1 ;
12122   PLFLT *arg2 = (PLFLT *) 0 ;
12123   PLFLT *arg3 = (PLFLT *) 0 ;
12124   PLFLT *arg4 = (PLFLT *) 0 ;
12125   char *arg5 = (char *) 0 ;
12126   PyArrayObject *tmp1 ;
12127   PyArrayObject *tmp3 ;
12128   PyArrayObject *tmp4 ;
12129   int res5 ;
12130   char *buf5 = 0 ;
12131   int alloc5 = 0 ;
12132   PyObject * obj0 = 0 ;
12133   PyObject * obj1 = 0 ;
12134   PyObject * obj2 = 0 ;
12135   PyObject * obj3 = 0 ;
12136   
12137   if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12138   {
12139     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12140     if ( tmp1 == NULL )
12141     return NULL;
12142     arg1 = Alen = tmp1->dimensions[0];
12143     arg2 = (PLFLT *) tmp1->data;
12144   }
12145   {
12146     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12147     if ( tmp3 == NULL )
12148     return NULL;
12149     if ( tmp3->dimensions[0] != Alen )
12150     {
12151       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12152       return NULL;
12153     }
12154     arg3 = (PLFLT *) tmp3->data;
12155   }
12156   {
12157     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, PyArray_PLFLT, 1, 1 );
12158     if ( tmp4 == NULL )
12159     return NULL;
12160     if ( tmp4->dimensions[0] != Alen )
12161     {
12162       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12163       return NULL;
12164     }
12165     arg4 = (PLFLT *) tmp4->data;
12166   }
12167   res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12168   if (!SWIG_IsOK(res5)) {
12169     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12170   }
12171   arg5 = (char *)(buf5);
12172   plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12173   resultobj = SWIG_Py_Void();
12174   {
12175     Py_DECREF( tmp1 );
12176   }
12177   {
12178     Py_DECREF( tmp3 );
12179   }
12180   {
12181     Py_DECREF( tmp4 );
12182   }
12183   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12184   return resultobj;
12185 fail:
12186   {
12187     Py_DECREF( tmp1 );
12188   }
12189   {
12190     Py_DECREF( tmp3 );
12191   }
12192   {
12193     Py_DECREF( tmp4 );
12194   }
12195   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12196   return NULL;
12197 }
12198 
12199 
12200 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201   PyObject *resultobj = 0;
12202   PLINT arg1 ;
12203   PLINT arg2 ;
12204   PLFLT arg3 ;
12205   PLFLT arg4 ;
12206   int val1 ;
12207   int ecode1 = 0 ;
12208   int val2 ;
12209   int ecode2 = 0 ;
12210   double val3 ;
12211   int ecode3 = 0 ;
12212   double val4 ;
12213   int ecode4 = 0 ;
12214   PyObject * obj0 = 0 ;
12215   PyObject * obj1 = 0 ;
12216   PyObject * obj2 = 0 ;
12217   PyObject * obj3 = 0 ;
12218   
12219   if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12220   ecode1 = SWIG_AsVal_int(obj0, &val1);
12221   if (!SWIG_IsOK(ecode1)) {
12222     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12223   } 
12224   arg1 = (PLINT)(val1);
12225   ecode2 = SWIG_AsVal_int(obj1, &val2);
12226   if (!SWIG_IsOK(ecode2)) {
12227     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12228   } 
12229   arg2 = (PLINT)(val2);
12230   ecode3 = SWIG_AsVal_double(obj2, &val3);
12231   if (!SWIG_IsOK(ecode3)) {
12232     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12233   } 
12234   arg3 = (PLFLT)(val3);
12235   ecode4 = SWIG_AsVal_double(obj3, &val4);
12236   if (!SWIG_IsOK(ecode4)) {
12237     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12238   } 
12239   arg4 = (PLFLT)(val4);
12240   plstripa(arg1,arg2,arg3,arg4);
12241   resultobj = SWIG_Py_Void();
12242   return resultobj;
12243 fail:
12244   return NULL;
12245 }
12246 
12247 
12248 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12249   PyObject *resultobj = 0;
12250   PLINT *arg1 = (PLINT *) 0 ;
12251   char *arg2 = (char *) 0 ;
12252   char *arg3 = (char *) 0 ;
12253   PLFLT arg4 ;
12254   PLFLT arg5 ;
12255   PLFLT arg6 ;
12256   PLFLT arg7 ;
12257   PLFLT arg8 ;
12258   PLFLT arg9 ;
12259   PLFLT arg10 ;
12260   PLBOOL arg11 ;
12261   PLBOOL arg12 ;
12262   PLINT arg13 ;
12263   PLINT arg14 ;
12264   PLINT *arg15 = (PLINT *) 0 ;
12265   PLINT *arg16 = (PLINT *) 0 ;
12266   char **arg17 ;
12267   char *arg18 = (char *) 0 ;
12268   char *arg19 = (char *) 0 ;
12269   char *arg20 = (char *) 0 ;
12270   PLINT temp1 ;
12271   int res1 = SWIG_TMPOBJ ;
12272   int res2 ;
12273   char *buf2 = 0 ;
12274   int alloc2 = 0 ;
12275   int res3 ;
12276   char *buf3 = 0 ;
12277   int alloc3 = 0 ;
12278   double val4 ;
12279   int ecode4 = 0 ;
12280   double val5 ;
12281   int ecode5 = 0 ;
12282   double val6 ;
12283   int ecode6 = 0 ;
12284   double val7 ;
12285   int ecode7 = 0 ;
12286   double val8 ;
12287   int ecode8 = 0 ;
12288   double val9 ;
12289   int ecode9 = 0 ;
12290   double val10 ;
12291   int ecode10 = 0 ;
12292   int val11 ;
12293   int ecode11 = 0 ;
12294   int val12 ;
12295   int ecode12 = 0 ;
12296   int val13 ;
12297   int ecode13 = 0 ;
12298   int val14 ;
12299   int ecode14 = 0 ;
12300   PyArrayObject *tmp15 ;
12301   PyArrayObject *tmp16 ;
12302   int res18 ;
12303   char *buf18 = 0 ;
12304   int alloc18 = 0 ;
12305   int res19 ;
12306   char *buf19 = 0 ;
12307   int alloc19 = 0 ;
12308   int res20 ;
12309   char *buf20 = 0 ;
12310   int alloc20 = 0 ;
12311   PyObject * obj0 = 0 ;
12312   PyObject * obj1 = 0 ;
12313   PyObject * obj2 = 0 ;
12314   PyObject * obj3 = 0 ;
12315   PyObject * obj4 = 0 ;
12316   PyObject * obj5 = 0 ;
12317   PyObject * obj6 = 0 ;
12318   PyObject * obj7 = 0 ;
12319   PyObject * obj8 = 0 ;
12320   PyObject * obj9 = 0 ;
12321   PyObject * obj10 = 0 ;
12322   PyObject * obj11 = 0 ;
12323   PyObject * obj12 = 0 ;
12324   PyObject * obj13 = 0 ;
12325   PyObject * obj14 = 0 ;
12326   PyObject * obj15 = 0 ;
12327   PyObject * obj16 = 0 ;
12328   PyObject * obj17 = 0 ;
12329   PyObject * obj18 = 0 ;
12330   
12331   arg1 = &temp1;
12332   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
12333   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
12334   if (!SWIG_IsOK(res2)) {
12335     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12336   }
12337   arg2 = (char *)(buf2);
12338   res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
12339   if (!SWIG_IsOK(res3)) {
12340     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12341   }
12342   arg3 = (char *)(buf3);
12343   ecode4 = SWIG_AsVal_double(obj2, &val4);
12344   if (!SWIG_IsOK(ecode4)) {
12345     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12346   } 
12347   arg4 = (PLFLT)(val4);
12348   ecode5 = SWIG_AsVal_double(obj3, &val5);
12349   if (!SWIG_IsOK(ecode5)) {
12350     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12351   } 
12352   arg5 = (PLFLT)(val5);
12353   ecode6 = SWIG_AsVal_double(obj4, &val6);
12354   if (!SWIG_IsOK(ecode6)) {
12355     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12356   } 
12357   arg6 = (PLFLT)(val6);
12358   ecode7 = SWIG_AsVal_double(obj5, &val7);
12359   if (!SWIG_IsOK(ecode7)) {
12360     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12361   } 
12362   arg7 = (PLFLT)(val7);
12363   ecode8 = SWIG_AsVal_double(obj6, &val8);
12364   if (!SWIG_IsOK(ecode8)) {
12365     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12366   } 
12367   arg8 = (PLFLT)(val8);
12368   ecode9 = SWIG_AsVal_double(obj7, &val9);
12369   if (!SWIG_IsOK(ecode9)) {
12370     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12371   } 
12372   arg9 = (PLFLT)(val9);
12373   ecode10 = SWIG_AsVal_double(obj8, &val10);
12374   if (!SWIG_IsOK(ecode10)) {
12375     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12376   } 
12377   arg10 = (PLFLT)(val10);
12378   ecode11 = SWIG_AsVal_int(obj9, &val11);
12379   if (!SWIG_IsOK(ecode11)) {
12380     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12381   } 
12382   arg11 = (PLBOOL)(val11);
12383   ecode12 = SWIG_AsVal_int(obj10, &val12);
12384   if (!SWIG_IsOK(ecode12)) {
12385     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12386   } 
12387   arg12 = (PLBOOL)(val12);
12388   ecode13 = SWIG_AsVal_int(obj11, &val13);
12389   if (!SWIG_IsOK(ecode13)) {
12390     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12391   } 
12392   arg13 = (PLINT)(val13);
12393   ecode14 = SWIG_AsVal_int(obj12, &val14);
12394   if (!SWIG_IsOK(ecode14)) {
12395     SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12396   } 
12397   arg14 = (PLINT)(val14);
12398   {
12399     tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, PyArray_PLINT, 1, 1 );
12400     if ( tmp15 == NULL )
12401     return NULL;
12402     Alen = tmp15->dimensions[0];
12403     arg15   = (PLINT *) tmp15->data;
12404   }
12405   {
12406     tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, PyArray_PLINT, 1, 1 );
12407     if ( tmp16 == NULL )
12408     return NULL;
12409     if ( tmp16->dimensions[0] != Alen )
12410     {
12411       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12412       return NULL;
12413     }
12414     arg16 = (PLINT *) tmp16->data;
12415   }
12416   {
12417     int i;
12418     if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
12419     {
12420       PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12421       return NULL;
12422     }
12423     if ( Alen != 4 )
12424     {
12425       PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12426       return NULL;
12427     }
12428     arg17 = malloc( sizeof ( char* ) * 4 );
12429     for ( i = 0; i < 4; i++ )
12430     {
12431       arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
12432       if ( arg17[i] == NULL )
12433       {
12434         free( arg17 );
12435         return NULL;
12436       }
12437     }
12438   }
12439   res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
12440   if (!SWIG_IsOK(res18)) {
12441     SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12442   }
12443   arg18 = (char *)(buf18);
12444   res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
12445   if (!SWIG_IsOK(res19)) {
12446     SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12447   }
12448   arg19 = (char *)(buf19);
12449   res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
12450   if (!SWIG_IsOK(res20)) {
12451     SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12452   }
12453   arg20 = (char *)(buf20);
12454   plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *(*))arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20);
12455   resultobj = SWIG_Py_Void();
12456   if (SWIG_IsTmpObj(res1)) {
12457     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12458   } else {
12459     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
12460     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12461   }
12462   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12463   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12464   {
12465     Py_DECREF( tmp15 );
12466   }
12467   {
12468     Py_DECREF( tmp16 );
12469   }
12470   {
12471     free( arg17 );
12472   }
12473   if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12474   if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12475   if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12476   return resultobj;
12477 fail:
12478   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12479   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12480   {
12481     Py_DECREF( tmp15 );
12482   }
12483   {
12484     Py_DECREF( tmp16 );
12485   }
12486   {
12487     free( arg17 );
12488   }
12489   if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12490   if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12491   if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12492   return NULL;
12493 }
12494 
12495 
12496 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12497   PyObject *resultobj = 0;
12498   PLINT arg1 ;
12499   int val1 ;
12500   int ecode1 = 0 ;
12501   PyObject * obj0 = 0 ;
12502   
12503   if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
12504   ecode1 = SWIG_AsVal_int(obj0, &val1);
12505   if (!SWIG_IsOK(ecode1)) {
12506     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12507   } 
12508   arg1 = (PLINT)(val1);
12509   plstripd(arg1);
12510   resultobj = SWIG_Py_Void();
12511   return resultobj;
12512 fail:
12513   return NULL;
12514 }
12515 
12516 
12517 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518   PyObject *resultobj = 0;
12519   PLINT arg1 ;
12520   PLINT *arg2 = (PLINT *) 0 ;
12521   PLINT *arg3 = (PLINT *) 0 ;
12522   PyArrayObject *tmp1 ;
12523   PyArrayObject *tmp3 ;
12524   PyObject * obj0 = 0 ;
12525   PyObject * obj1 = 0 ;
12526   
12527   if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
12528   {
12529     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, PyArray_PLINT, 1, 1 );
12530     if ( tmp1 == NULL )
12531     return NULL;
12532     arg1 = Alen = tmp1->dimensions[0];
12533     arg2 = (PLINT *) tmp1->data;
12534   }
12535   {
12536     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, PyArray_PLINT, 1, 1 );
12537     if ( tmp3 == NULL )
12538     return NULL;
12539     if ( tmp3->dimensions[0] != Alen )
12540     {
12541       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12542       return NULL;
12543     }
12544     arg3 = (PLINT *) tmp3->data;
12545   }
12546   plstyl(arg1,(int const *)arg2,(int const *)arg3);
12547   resultobj = SWIG_Py_Void();
12548   {
12549     Py_DECREF( tmp1 );
12550   }
12551   {
12552     Py_DECREF( tmp3 );
12553   }
12554   return resultobj;
12555 fail:
12556   {
12557     Py_DECREF( tmp1 );
12558   }
12559   {
12560     Py_DECREF( tmp3 );
12561   }
12562   return NULL;
12563 }
12564 
12565 
12566 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567   PyObject *resultobj = 0;
12568   PLFLT *arg1 = (PLFLT *) 0 ;
12569   PLFLT *arg2 = (PLFLT *) 0 ;
12570   PLINT arg3 ;
12571   PLBOOL arg4 ;
12572   PyArrayObject *tmp1 ;
12573   PyArrayObject *tmp2 ;
12574   int val4 ;
12575   int ecode4 = 0 ;
12576   PyObject * obj0 = 0 ;
12577   PyObject * obj1 = 0 ;
12578   PyObject * obj2 = 0 ;
12579   
12580   if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
12581   {
12582     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12583     if ( tmp1 == NULL )
12584     return NULL;
12585     Alen = tmp1->dimensions[0];
12586     arg1   = (PLFLT *) tmp1->data;
12587   }
12588   {
12589     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12590     if ( tmp2 == NULL )
12591     return NULL;
12592     if ( tmp2->dimensions[0] != Alen )
12593     {
12594       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12595       return NULL;
12596     }
12597     arg2 = (PLFLT *) tmp2->data;
12598     arg3 = tmp2->dimensions[0];
12599   }
12600   ecode4 = SWIG_AsVal_int(obj2, &val4);
12601   if (!SWIG_IsOK(ecode4)) {
12602     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12603   } 
12604   arg4 = (PLBOOL)(val4);
12605   plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12606   resultobj = SWIG_Py_Void();
12607   {
12608     Py_DECREF( tmp1 );
12609   }
12610   {
12611     Py_DECREF( tmp2 );
12612   }
12613   return resultobj;
12614 fail:
12615   {
12616     Py_DECREF( tmp1 );
12617   }
12618   {
12619     Py_DECREF( tmp2 );
12620   }
12621   return NULL;
12622 }
12623 
12624 
12625 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626   PyObject *resultobj = 0;
12627   PLFLT arg1 ;
12628   PLFLT arg2 ;
12629   PLFLT arg3 ;
12630   PLFLT arg4 ;
12631   double val1 ;
12632   int ecode1 = 0 ;
12633   double val2 ;
12634   int ecode2 = 0 ;
12635   double val3 ;
12636   int ecode3 = 0 ;
12637   double val4 ;
12638   int ecode4 = 0 ;
12639   PyObject * obj0 = 0 ;
12640   PyObject * obj1 = 0 ;
12641   PyObject * obj2 = 0 ;
12642   PyObject * obj3 = 0 ;
12643   
12644   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12645   ecode1 = SWIG_AsVal_double(obj0, &val1);
12646   if (!SWIG_IsOK(ecode1)) {
12647     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12648   } 
12649   arg1 = (PLFLT)(val1);
12650   ecode2 = SWIG_AsVal_double(obj1, &val2);
12651   if (!SWIG_IsOK(ecode2)) {
12652     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12653   } 
12654   arg2 = (PLFLT)(val2);
12655   ecode3 = SWIG_AsVal_double(obj2, &val3);
12656   if (!SWIG_IsOK(ecode3)) {
12657     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12658   } 
12659   arg3 = (PLFLT)(val3);
12660   ecode4 = SWIG_AsVal_double(obj3, &val4);
12661   if (!SWIG_IsOK(ecode4)) {
12662     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12663   } 
12664   arg4 = (PLFLT)(val4);
12665   plsvpa(arg1,arg2,arg3,arg4);
12666   resultobj = SWIG_Py_Void();
12667   return resultobj;
12668 fail:
12669   return NULL;
12670 }
12671 
12672 
12673 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674   PyObject *resultobj = 0;
12675   PLINT arg1 ;
12676   PLINT arg2 ;
12677   int val1 ;
12678   int ecode1 = 0 ;
12679   int val2 ;
12680   int ecode2 = 0 ;
12681   PyObject * obj0 = 0 ;
12682   PyObject * obj1 = 0 ;
12683   
12684   if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
12685   ecode1 = SWIG_AsVal_int(obj0, &val1);
12686   if (!SWIG_IsOK(ecode1)) {
12687     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12688   } 
12689   arg1 = (PLINT)(val1);
12690   ecode2 = SWIG_AsVal_int(obj1, &val2);
12691   if (!SWIG_IsOK(ecode2)) {
12692     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12693   } 
12694   arg2 = (PLINT)(val2);
12695   plsxax(arg1,arg2);
12696   resultobj = SWIG_Py_Void();
12697   return resultobj;
12698 fail:
12699   return NULL;
12700 }
12701 
12702 
12703 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704   PyObject *resultobj = 0;
12705   PLINT arg1 ;
12706   PLINT arg2 ;
12707   int val1 ;
12708   int ecode1 = 0 ;
12709   int val2 ;
12710   int ecode2 = 0 ;
12711   PyObject * obj0 = 0 ;
12712   PyObject * obj1 = 0 ;
12713   
12714   if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
12715   ecode1 = SWIG_AsVal_int(obj0, &val1);
12716   if (!SWIG_IsOK(ecode1)) {
12717     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12718   } 
12719   arg1 = (PLINT)(val1);
12720   ecode2 = SWIG_AsVal_int(obj1, &val2);
12721   if (!SWIG_IsOK(ecode2)) {
12722     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12723   } 
12724   arg2 = (PLINT)(val2);
12725   plsyax(arg1,arg2);
12726   resultobj = SWIG_Py_Void();
12727   return resultobj;
12728 fail:
12729   return NULL;
12730 }
12731 
12732 
12733 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734   PyObject *resultobj = 0;
12735   PLINT arg1 ;
12736   PLFLT *arg2 = (PLFLT *) 0 ;
12737   PLFLT *arg3 = (PLFLT *) 0 ;
12738   PLINT arg4 ;
12739   PyArrayObject *tmp1 ;
12740   PyArrayObject *tmp3 ;
12741   int val4 ;
12742   int ecode4 = 0 ;
12743   PyObject * obj0 = 0 ;
12744   PyObject * obj1 = 0 ;
12745   PyObject * obj2 = 0 ;
12746   
12747   if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
12748   {
12749     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 1, 1 );
12750     if ( tmp1 == NULL )
12751     return NULL;
12752     arg1 = Alen = tmp1->dimensions[0];
12753     arg2 = (PLFLT *) tmp1->data;
12754   }
12755   {
12756     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 1, 1 );
12757     if ( tmp3 == NULL )
12758     return NULL;
12759     if ( tmp3->dimensions[0] != Alen )
12760     {
12761       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12762       return NULL;
12763     }
12764     arg3 = (PLFLT *) tmp3->data;
12765   }
12766   ecode4 = SWIG_AsVal_int(obj2, &val4);
12767   if (!SWIG_IsOK(ecode4)) {
12768     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
12769   } 
12770   arg4 = (PLINT)(val4);
12771   plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
12772   resultobj = SWIG_Py_Void();
12773   {
12774     Py_DECREF( tmp1 );
12775   }
12776   {
12777     Py_DECREF( tmp3 );
12778   }
12779   return resultobj;
12780 fail:
12781   {
12782     Py_DECREF( tmp1 );
12783   }
12784   {
12785     Py_DECREF( tmp3 );
12786   }
12787   return NULL;
12788 }
12789 
12790 
12791 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792   PyObject *resultobj = 0;
12793   PLINT arg1 ;
12794   PLINT arg2 ;
12795   int val1 ;
12796   int ecode1 = 0 ;
12797   int val2 ;
12798   int ecode2 = 0 ;
12799   PyObject * obj0 = 0 ;
12800   PyObject * obj1 = 0 ;
12801   
12802   if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
12803   ecode1 = SWIG_AsVal_int(obj0, &val1);
12804   if (!SWIG_IsOK(ecode1)) {
12805     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
12806   } 
12807   arg1 = (PLINT)(val1);
12808   ecode2 = SWIG_AsVal_int(obj1, &val2);
12809   if (!SWIG_IsOK(ecode2)) {
12810     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
12811   } 
12812   arg2 = (PLINT)(val2);
12813   plszax(arg1,arg2);
12814   resultobj = SWIG_Py_Void();
12815   return resultobj;
12816 fail:
12817   return NULL;
12818 }
12819 
12820 
12821 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822   PyObject *resultobj = 0;
12823   
12824   if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
12825   pltext();
12826   resultobj = SWIG_Py_Void();
12827   return resultobj;
12828 fail:
12829   return NULL;
12830 }
12831 
12832 
12833 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12834   PyObject *resultobj = 0;
12835   char *arg1 = (char *) 0 ;
12836   int res1 ;
12837   char *buf1 = 0 ;
12838   int alloc1 = 0 ;
12839   PyObject * obj0 = 0 ;
12840   
12841   if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
12842   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12843   if (!SWIG_IsOK(res1)) {
12844     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
12845   }
12846   arg1 = (char *)(buf1);
12847   pltimefmt((char const *)arg1);
12848   resultobj = SWIG_Py_Void();
12849   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12850   return resultobj;
12851 fail:
12852   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12853   return NULL;
12854 }
12855 
12856 
12857 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858   PyObject *resultobj = 0;
12859   PLFLT arg1 ;
12860   double val1 ;
12861   int ecode1 = 0 ;
12862   PyObject * obj0 = 0 ;
12863   
12864   if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
12865   ecode1 = SWIG_AsVal_double(obj0, &val1);
12866   if (!SWIG_IsOK(ecode1)) {
12867     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
12868   } 
12869   arg1 = (PLFLT)(val1);
12870   plvasp(arg1);
12871   resultobj = SWIG_Py_Void();
12872   return resultobj;
12873 fail:
12874   return NULL;
12875 }
12876 
12877 
12878 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879   PyObject *resultobj = 0;
12880   PLFLT **arg1 = (PLFLT **) 0 ;
12881   PLFLT **arg2 = (PLFLT **) 0 ;
12882   PLINT arg3 ;
12883   PLINT arg4 ;
12884   PLFLT arg5 ;
12885   pltr_func arg6 = (pltr_func) 0 ;
12886   PLPointer arg7 = (PLPointer) 0 ;
12887   PyArrayObject *tmp1 ;
12888   PyArrayObject *tmp2 ;
12889   double val5 ;
12890   int ecode5 = 0 ;
12891   PyObject * obj0 = 0 ;
12892   PyObject * obj1 = 0 ;
12893   PyObject * obj2 = 0 ;
12894   PyObject * obj3 = 0 ;
12895   PyObject * obj4 = 0 ;
12896   
12897   {
12898     python_pltr = 0;
12899     arg6          = NULL;
12900   }
12901   {
12902     arg7 = NULL;
12903   }
12904   if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12905   {
12906     int i, size;
12907     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
12908     if ( tmp1 == NULL )
12909     return NULL;
12910     Xlen = tmp1->dimensions[0];
12911     Ylen = tmp1->dimensions[1];
12912     size = sizeof ( PLFLT ) * Ylen;
12913     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * Xlen );
12914     for ( i = 0; i < Xlen; i++ )
12915     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
12916   }
12917   {
12918     int i, size;
12919     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, PyArray_PLFLT, 2, 2 );
12920     if ( tmp2 == NULL )
12921     return NULL;
12922     if ( Xlen != tmp2->dimensions[0] || Ylen != tmp2->dimensions[1] )
12923     {
12924       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
12925       return NULL;
12926     }
12927     arg3   = tmp2->dimensions[0];
12928     arg4   = tmp2->dimensions[1];
12929     size = sizeof ( PLFLT ) * arg4;
12930     arg2   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg3 );
12931     for ( i = 0; i < arg3; i++ )
12932     arg2[i] = (PLFLT *) ( tmp2->data + i * size );
12933   }
12934   ecode5 = SWIG_AsVal_double(obj2, &val5);
12935   if (!SWIG_IsOK(ecode5)) {
12936     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
12937   } 
12938   arg5 = (PLFLT)(val5);
12939   if (obj3) {
12940     {
12941       // it must be a callable or None
12942       if ( obj3 == Py_None )
12943       {
12944         arg6 = NULL;
12945       }
12946       else
12947       {
12948         if ( !PyCallable_Check( (PyObject *) obj3 ) )
12949         {
12950           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12951           return NULL;
12952         }
12953         arg6 = marshal_pltr( obj3 );
12954       }
12955     }
12956   }
12957   if (obj4) {
12958     {
12959       if ( obj4 == Py_None )
12960       arg7 = NULL;
12961       else
12962       {
12963         arg7 = marshal_PLPointer( obj4, 0 );
12964       }
12965     }
12966   }
12967   plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
12968   resultobj = SWIG_Py_Void();
12969   {
12970     Py_DECREF( tmp1 );
12971     free( arg1 );
12972   }
12973   {
12974     Py_DECREF( tmp2 );
12975     free( arg2 );
12976   }
12977   {
12978     cleanup_pltr();
12979   }
12980   {
12981     cleanup_PLPointer();
12982   }
12983   return resultobj;
12984 fail:
12985   {
12986     Py_DECREF( tmp1 );
12987     free( arg1 );
12988   }
12989   {
12990     Py_DECREF( tmp2 );
12991     free( arg2 );
12992   }
12993   {
12994     cleanup_pltr();
12995   }
12996   {
12997     cleanup_PLPointer();
12998   }
12999   return NULL;
13000 }
13001 
13002 
13003 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004   PyObject *resultobj = 0;
13005   PLFLT arg1 ;
13006   PLFLT arg2 ;
13007   PLFLT arg3 ;
13008   PLFLT arg4 ;
13009   PLFLT arg5 ;
13010   double val1 ;
13011   int ecode1 = 0 ;
13012   double val2 ;
13013   int ecode2 = 0 ;
13014   double val3 ;
13015   int ecode3 = 0 ;
13016   double val4 ;
13017   int ecode4 = 0 ;
13018   double val5 ;
13019   int ecode5 = 0 ;
13020   PyObject * obj0 = 0 ;
13021   PyObject * obj1 = 0 ;
13022   PyObject * obj2 = 0 ;
13023   PyObject * obj3 = 0 ;
13024   PyObject * obj4 = 0 ;
13025   
13026   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13027   ecode1 = SWIG_AsVal_double(obj0, &val1);
13028   if (!SWIG_IsOK(ecode1)) {
13029     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13030   } 
13031   arg1 = (PLFLT)(val1);
13032   ecode2 = SWIG_AsVal_double(obj1, &val2);
13033   if (!SWIG_IsOK(ecode2)) {
13034     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13035   } 
13036   arg2 = (PLFLT)(val2);
13037   ecode3 = SWIG_AsVal_double(obj2, &val3);
13038   if (!SWIG_IsOK(ecode3)) {
13039     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13040   } 
13041   arg3 = (PLFLT)(val3);
13042   ecode4 = SWIG_AsVal_double(obj3, &val4);
13043   if (!SWIG_IsOK(ecode4)) {
13044     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13045   } 
13046   arg4 = (PLFLT)(val4);
13047   ecode5 = SWIG_AsVal_double(obj4, &val5);
13048   if (!SWIG_IsOK(ecode5)) {
13049     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13050   } 
13051   arg5 = (PLFLT)(val5);
13052   plvpas(arg1,arg2,arg3,arg4,arg5);
13053   resultobj = SWIG_Py_Void();
13054   return resultobj;
13055 fail:
13056   return NULL;
13057 }
13058 
13059 
13060 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061   PyObject *resultobj = 0;
13062   PLFLT arg1 ;
13063   PLFLT arg2 ;
13064   PLFLT arg3 ;
13065   PLFLT arg4 ;
13066   double val1 ;
13067   int ecode1 = 0 ;
13068   double val2 ;
13069   int ecode2 = 0 ;
13070   double val3 ;
13071   int ecode3 = 0 ;
13072   double val4 ;
13073   int ecode4 = 0 ;
13074   PyObject * obj0 = 0 ;
13075   PyObject * obj1 = 0 ;
13076   PyObject * obj2 = 0 ;
13077   PyObject * obj3 = 0 ;
13078   
13079   if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13080   ecode1 = SWIG_AsVal_double(obj0, &val1);
13081   if (!SWIG_IsOK(ecode1)) {
13082     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13083   } 
13084   arg1 = (PLFLT)(val1);
13085   ecode2 = SWIG_AsVal_double(obj1, &val2);
13086   if (!SWIG_IsOK(ecode2)) {
13087     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13088   } 
13089   arg2 = (PLFLT)(val2);
13090   ecode3 = SWIG_AsVal_double(obj2, &val3);
13091   if (!SWIG_IsOK(ecode3)) {
13092     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13093   } 
13094   arg3 = (PLFLT)(val3);
13095   ecode4 = SWIG_AsVal_double(obj3, &val4);
13096   if (!SWIG_IsOK(ecode4)) {
13097     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13098   } 
13099   arg4 = (PLFLT)(val4);
13100   plvpor(arg1,arg2,arg3,arg4);
13101   resultobj = SWIG_Py_Void();
13102   return resultobj;
13103 fail:
13104   return NULL;
13105 }
13106 
13107 
13108 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109   PyObject *resultobj = 0;
13110   
13111   if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13112   plvsta();
13113   resultobj = SWIG_Py_Void();
13114   return resultobj;
13115 fail:
13116   return NULL;
13117 }
13118 
13119 
13120 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13121   PyObject *resultobj = 0;
13122   PLFLT arg1 ;
13123   PLFLT arg2 ;
13124   PLFLT arg3 ;
13125   PLFLT arg4 ;
13126   PLFLT arg5 ;
13127   PLFLT arg6 ;
13128   PLFLT arg7 ;
13129   PLFLT arg8 ;
13130   PLFLT arg9 ;
13131   PLFLT arg10 ;
13132   PLFLT arg11 ;
13133   double val1 ;
13134   int ecode1 = 0 ;
13135   double val2 ;
13136   int ecode2 = 0 ;
13137   double val3 ;
13138   int ecode3 = 0 ;
13139   double val4 ;
13140   int ecode4 = 0 ;
13141   double val5 ;
13142   int ecode5 = 0 ;
13143   double val6 ;
13144   int ecode6 = 0 ;
13145   double val7 ;
13146   int ecode7 = 0 ;
13147   double val8 ;
13148   int ecode8 = 0 ;
13149   double val9 ;
13150   int ecode9 = 0 ;
13151   double val10 ;
13152   int ecode10 = 0 ;
13153   double val11 ;
13154   int ecode11 = 0 ;
13155   PyObject * obj0 = 0 ;
13156   PyObject * obj1 = 0 ;
13157   PyObject * obj2 = 0 ;
13158   PyObject * obj3 = 0 ;
13159   PyObject * obj4 = 0 ;
13160   PyObject * obj5 = 0 ;
13161   PyObject * obj6 = 0 ;
13162   PyObject * obj7 = 0 ;
13163   PyObject * obj8 = 0 ;
13164   PyObject * obj9 = 0 ;
13165   PyObject * obj10 = 0 ;
13166   
13167   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13168   ecode1 = SWIG_AsVal_double(obj0, &val1);
13169   if (!SWIG_IsOK(ecode1)) {
13170     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13171   } 
13172   arg1 = (PLFLT)(val1);
13173   ecode2 = SWIG_AsVal_double(obj1, &val2);
13174   if (!SWIG_IsOK(ecode2)) {
13175     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13176   } 
13177   arg2 = (PLFLT)(val2);
13178   ecode3 = SWIG_AsVal_double(obj2, &val3);
13179   if (!SWIG_IsOK(ecode3)) {
13180     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13181   } 
13182   arg3 = (PLFLT)(val3);
13183   ecode4 = SWIG_AsVal_double(obj3, &val4);
13184   if (!SWIG_IsOK(ecode4)) {
13185     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13186   } 
13187   arg4 = (PLFLT)(val4);
13188   ecode5 = SWIG_AsVal_double(obj4, &val5);
13189   if (!SWIG_IsOK(ecode5)) {
13190     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13191   } 
13192   arg5 = (PLFLT)(val5);
13193   ecode6 = SWIG_AsVal_double(obj5, &val6);
13194   if (!SWIG_IsOK(ecode6)) {
13195     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13196   } 
13197   arg6 = (PLFLT)(val6);
13198   ecode7 = SWIG_AsVal_double(obj6, &val7);
13199   if (!SWIG_IsOK(ecode7)) {
13200     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13201   } 
13202   arg7 = (PLFLT)(val7);
13203   ecode8 = SWIG_AsVal_double(obj7, &val8);
13204   if (!SWIG_IsOK(ecode8)) {
13205     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13206   } 
13207   arg8 = (PLFLT)(val8);
13208   ecode9 = SWIG_AsVal_double(obj8, &val9);
13209   if (!SWIG_IsOK(ecode9)) {
13210     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13211   } 
13212   arg9 = (PLFLT)(val9);
13213   ecode10 = SWIG_AsVal_double(obj9, &val10);
13214   if (!SWIG_IsOK(ecode10)) {
13215     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13216   } 
13217   arg10 = (PLFLT)(val10);
13218   ecode11 = SWIG_AsVal_double(obj10, &val11);
13219   if (!SWIG_IsOK(ecode11)) {
13220     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13221   } 
13222   arg11 = (PLFLT)(val11);
13223   plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13224   resultobj = SWIG_Py_Void();
13225   return resultobj;
13226 fail:
13227   return NULL;
13228 }
13229 
13230 
13231 SWIGINTERN PyObject *_wrap_plwid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232   PyObject *resultobj = 0;
13233   PLINT arg1 ;
13234   int val1 ;
13235   int ecode1 = 0 ;
13236   PyObject * obj0 = 0 ;
13237   
13238   if (!PyArg_ParseTuple(args,(char *)"O:plwid",&obj0)) SWIG_fail;
13239   ecode1 = SWIG_AsVal_int(obj0, &val1);
13240   if (!SWIG_IsOK(ecode1)) {
13241     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwid" "', argument " "1"" of type '" "PLINT""'");
13242   } 
13243   arg1 = (PLINT)(val1);
13244   plwid(arg1);
13245   resultobj = SWIG_Py_Void();
13246   return resultobj;
13247 fail:
13248   return NULL;
13249 }
13250 
13251 
13252 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253   PyObject *resultobj = 0;
13254   PLFLT arg1 ;
13255   PLFLT arg2 ;
13256   PLFLT arg3 ;
13257   PLFLT arg4 ;
13258   double val1 ;
13259   int ecode1 = 0 ;
13260   double val2 ;
13261   int ecode2 = 0 ;
13262   double val3 ;
13263   int ecode3 = 0 ;
13264   double val4 ;
13265   int ecode4 = 0 ;
13266   PyObject * obj0 = 0 ;
13267   PyObject * obj1 = 0 ;
13268   PyObject * obj2 = 0 ;
13269   PyObject * obj3 = 0 ;
13270   
13271   if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13272   ecode1 = SWIG_AsVal_double(obj0, &val1);
13273   if (!SWIG_IsOK(ecode1)) {
13274     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13275   } 
13276   arg1 = (PLFLT)(val1);
13277   ecode2 = SWIG_AsVal_double(obj1, &val2);
13278   if (!SWIG_IsOK(ecode2)) {
13279     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13280   } 
13281   arg2 = (PLFLT)(val2);
13282   ecode3 = SWIG_AsVal_double(obj2, &val3);
13283   if (!SWIG_IsOK(ecode3)) {
13284     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13285   } 
13286   arg3 = (PLFLT)(val3);
13287   ecode4 = SWIG_AsVal_double(obj3, &val4);
13288   if (!SWIG_IsOK(ecode4)) {
13289     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13290   } 
13291   arg4 = (PLFLT)(val4);
13292   plwind(arg1,arg2,arg3,arg4);
13293   resultobj = SWIG_Py_Void();
13294   return resultobj;
13295 fail:
13296   return NULL;
13297 }
13298 
13299 
13300 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301   PyObject *resultobj = 0;
13302   PLBOOL arg1 ;
13303   PLBOOL *arg2 = (PLBOOL *) 0 ;
13304   int val1 ;
13305   int ecode1 = 0 ;
13306   PLBOOL temp2 ;
13307   int res2 = SWIG_TMPOBJ ;
13308   PyObject * obj0 = 0 ;
13309   
13310   arg2 = &temp2;
13311   if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
13312   ecode1 = SWIG_AsVal_int(obj0, &val1);
13313   if (!SWIG_IsOK(ecode1)) {
13314     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13315   } 
13316   arg1 = (PLBOOL)(val1);
13317   plxormod(arg1,arg2);
13318   resultobj = SWIG_Py_Void();
13319   if (SWIG_IsTmpObj(res2)) {
13320     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13321   } else {
13322     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
13323     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13324   }
13325   return resultobj;
13326 fail:
13327   return NULL;
13328 }
13329 
13330 
13331 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13332   PyObject *resultobj = 0;
13333   mapform_func arg1 = (mapform_func) 0 ;
13334   char *arg2 = (char *) 0 ;
13335   PLFLT arg3 ;
13336   PLFLT arg4 ;
13337   PLFLT arg5 ;
13338   PLFLT arg6 ;
13339   int res2 ;
13340   char *buf2 = 0 ;
13341   int alloc2 = 0 ;
13342   double val3 ;
13343   int ecode3 = 0 ;
13344   double val4 ;
13345   int ecode4 = 0 ;
13346   double val5 ;
13347   int ecode5 = 0 ;
13348   double val6 ;
13349   int ecode6 = 0 ;
13350   PyObject * obj0 = 0 ;
13351   PyObject * obj1 = 0 ;
13352   PyObject * obj2 = 0 ;
13353   PyObject * obj3 = 0 ;
13354   PyObject * obj4 = 0 ;
13355   PyObject * obj5 = 0 ;
13356   
13357   {
13358     python_mapform = 0;
13359     arg1             = NULL;
13360   }
13361   if (!PyArg_ParseTuple(args,(char *)"|OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13362   if (obj0) {
13363     {
13364       // it must be a callable or none
13365       if ( obj0 == Py_None )
13366       {
13367         arg1 = NULL;
13368       }
13369       else
13370       {
13371         if ( !PyCallable_Check( (PyObject *) obj0 ) )
13372         {
13373           PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13374           return NULL;
13375         }
13376         arg1 = marshal_mapform( obj0 );
13377       }
13378     }
13379   }
13380   if (obj1) {
13381     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13382     if (!SWIG_IsOK(res2)) {
13383       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13384     }
13385     arg2 = (char *)(buf2);
13386   }
13387   if (obj2) {
13388     ecode3 = SWIG_AsVal_double(obj2, &val3);
13389     if (!SWIG_IsOK(ecode3)) {
13390       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13391     } 
13392     arg3 = (PLFLT)(val3);
13393   }
13394   if (obj3) {
13395     ecode4 = SWIG_AsVal_double(obj3, &val4);
13396     if (!SWIG_IsOK(ecode4)) {
13397       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13398     } 
13399     arg4 = (PLFLT)(val4);
13400   }
13401   if (obj4) {
13402     ecode5 = SWIG_AsVal_double(obj4, &val5);
13403     if (!SWIG_IsOK(ecode5)) {
13404       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13405     } 
13406     arg5 = (PLFLT)(val5);
13407   }
13408   if (obj5) {
13409     ecode6 = SWIG_AsVal_double(obj5, &val6);
13410     if (!SWIG_IsOK(ecode6)) {
13411       SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13412     } 
13413     arg6 = (PLFLT)(val6);
13414   }
13415   plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13416   resultobj = SWIG_Py_Void();
13417   {
13418     cleanup_mapform();
13419   }
13420   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13421   return resultobj;
13422 fail:
13423   {
13424     cleanup_mapform();
13425   }
13426   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13427   return NULL;
13428 }
13429 
13430 
13431 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432   PyObject *resultobj = 0;
13433   mapform_func arg1 = (mapform_func) 0 ;
13434   PLFLT arg2 ;
13435   PLFLT arg3 ;
13436   PLFLT arg4 ;
13437   PLFLT arg5 ;
13438   PLFLT arg6 ;
13439   PLFLT arg7 ;
13440   double val2 ;
13441   int ecode2 = 0 ;
13442   double val3 ;
13443   int ecode3 = 0 ;
13444   double val4 ;
13445   int ecode4 = 0 ;
13446   double val5 ;
13447   int ecode5 = 0 ;
13448   double val6 ;
13449   int ecode6 = 0 ;
13450   double val7 ;
13451   int ecode7 = 0 ;
13452   PyObject * obj0 = 0 ;
13453   PyObject * obj1 = 0 ;
13454   PyObject * obj2 = 0 ;
13455   PyObject * obj3 = 0 ;
13456   PyObject * obj4 = 0 ;
13457   PyObject * obj5 = 0 ;
13458   PyObject * obj6 = 0 ;
13459   
13460   {
13461     python_mapform = 0;
13462     arg1             = NULL;
13463   }
13464   if (!PyArg_ParseTuple(args,(char *)"|OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13465   if (obj0) {
13466     {
13467       // it must be a callable or none
13468       if ( obj0 == Py_None )
13469       {
13470         arg1 = NULL;
13471       }
13472       else
13473       {
13474         if ( !PyCallable_Check( (PyObject *) obj0 ) )
13475         {
13476           PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13477           return NULL;
13478         }
13479         arg1 = marshal_mapform( obj0 );
13480       }
13481     }
13482   }
13483   if (obj1) {
13484     ecode2 = SWIG_AsVal_double(obj1, &val2);
13485     if (!SWIG_IsOK(ecode2)) {
13486       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
13487     } 
13488     arg2 = (PLFLT)(val2);
13489   }
13490   if (obj2) {
13491     ecode3 = SWIG_AsVal_double(obj2, &val3);
13492     if (!SWIG_IsOK(ecode3)) {
13493       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
13494     } 
13495     arg3 = (PLFLT)(val3);
13496   }
13497   if (obj3) {
13498     ecode4 = SWIG_AsVal_double(obj3, &val4);
13499     if (!SWIG_IsOK(ecode4)) {
13500       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
13501     } 
13502     arg4 = (PLFLT)(val4);
13503   }
13504   if (obj4) {
13505     ecode5 = SWIG_AsVal_double(obj4, &val5);
13506     if (!SWIG_IsOK(ecode5)) {
13507       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
13508     } 
13509     arg5 = (PLFLT)(val5);
13510   }
13511   if (obj5) {
13512     ecode6 = SWIG_AsVal_double(obj5, &val6);
13513     if (!SWIG_IsOK(ecode6)) {
13514       SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
13515     } 
13516     arg6 = (PLFLT)(val6);
13517   }
13518   if (obj6) {
13519     ecode7 = SWIG_AsVal_double(obj6, &val7);
13520     if (!SWIG_IsOK(ecode7)) {
13521       SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
13522     } 
13523     arg7 = (PLFLT)(val7);
13524   }
13525   plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13526   resultobj = SWIG_Py_Void();
13527   {
13528     cleanup_mapform();
13529   }
13530   return resultobj;
13531 fail:
13532   {
13533     cleanup_mapform();
13534   }
13535   return NULL;
13536 }
13537 
13538 
13539 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13540   PyObject *resultobj = 0;
13541   PLFLT **arg1 = (PLFLT **) 0 ;
13542   PLINT arg2 ;
13543   PLINT arg3 ;
13544   PLFLT arg4 ;
13545   PLFLT arg5 ;
13546   PLFLT arg6 ;
13547   PLFLT arg7 ;
13548   PLFLT arg8 ;
13549   PLFLT arg9 ;
13550   PLFLT arg10 ;
13551   PLFLT arg11 ;
13552   PLFLT arg12 ;
13553   PLFLT arg13 ;
13554   PyArrayObject *tmp1 ;
13555   double val4 ;
13556   int ecode4 = 0 ;
13557   double val5 ;
13558   int ecode5 = 0 ;
13559   double val6 ;
13560   int ecode6 = 0 ;
13561   double val7 ;
13562   int ecode7 = 0 ;
13563   double val8 ;
13564   int ecode8 = 0 ;
13565   double val9 ;
13566   int ecode9 = 0 ;
13567   double val10 ;
13568   int ecode10 = 0 ;
13569   double val11 ;
13570   int ecode11 = 0 ;
13571   double val12 ;
13572   int ecode12 = 0 ;
13573   double val13 ;
13574   int ecode13 = 0 ;
13575   PyObject * obj0 = 0 ;
13576   PyObject * obj1 = 0 ;
13577   PyObject * obj2 = 0 ;
13578   PyObject * obj3 = 0 ;
13579   PyObject * obj4 = 0 ;
13580   PyObject * obj5 = 0 ;
13581   PyObject * obj6 = 0 ;
13582   PyObject * obj7 = 0 ;
13583   PyObject * obj8 = 0 ;
13584   PyObject * obj9 = 0 ;
13585   PyObject * obj10 = 0 ;
13586   
13587   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13588   {
13589     int i, size;
13590     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13591     if ( tmp1 == NULL )
13592     return NULL;
13593     Xlen = arg2 = tmp1->dimensions[0];
13594     Ylen = arg3 = tmp1->dimensions[1];
13595     size = sizeof ( PLFLT ) * arg3;
13596     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13597     for ( i = 0; i < arg2; i++ )
13598     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13599   }
13600   ecode4 = SWIG_AsVal_double(obj1, &val4);
13601   if (!SWIG_IsOK(ecode4)) {
13602     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
13603   } 
13604   arg4 = (PLFLT)(val4);
13605   ecode5 = SWIG_AsVal_double(obj2, &val5);
13606   if (!SWIG_IsOK(ecode5)) {
13607     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
13608   } 
13609   arg5 = (PLFLT)(val5);
13610   ecode6 = SWIG_AsVal_double(obj3, &val6);
13611   if (!SWIG_IsOK(ecode6)) {
13612     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
13613   } 
13614   arg6 = (PLFLT)(val6);
13615   ecode7 = SWIG_AsVal_double(obj4, &val7);
13616   if (!SWIG_IsOK(ecode7)) {
13617     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
13618   } 
13619   arg7 = (PLFLT)(val7);
13620   ecode8 = SWIG_AsVal_double(obj5, &val8);
13621   if (!SWIG_IsOK(ecode8)) {
13622     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
13623   } 
13624   arg8 = (PLFLT)(val8);
13625   ecode9 = SWIG_AsVal_double(obj6, &val9);
13626   if (!SWIG_IsOK(ecode9)) {
13627     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
13628   } 
13629   arg9 = (PLFLT)(val9);
13630   ecode10 = SWIG_AsVal_double(obj7, &val10);
13631   if (!SWIG_IsOK(ecode10)) {
13632     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
13633   } 
13634   arg10 = (PLFLT)(val10);
13635   ecode11 = SWIG_AsVal_double(obj8, &val11);
13636   if (!SWIG_IsOK(ecode11)) {
13637     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
13638   } 
13639   arg11 = (PLFLT)(val11);
13640   ecode12 = SWIG_AsVal_double(obj9, &val12);
13641   if (!SWIG_IsOK(ecode12)) {
13642     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
13643   } 
13644   arg12 = (PLFLT)(val12);
13645   ecode13 = SWIG_AsVal_double(obj10, &val13);
13646   if (!SWIG_IsOK(ecode13)) {
13647     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
13648   } 
13649   arg13 = (PLFLT)(val13);
13650   plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13651   resultobj = SWIG_Py_Void();
13652   {
13653     Py_DECREF( tmp1 );
13654     free( arg1 );
13655   }
13656   return resultobj;
13657 fail:
13658   {
13659     Py_DECREF( tmp1 );
13660     free( arg1 );
13661   }
13662   return NULL;
13663 }
13664 
13665 
13666 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13667   PyObject *resultobj = 0;
13668   PLFLT **arg1 = (PLFLT **) 0 ;
13669   PLINT arg2 ;
13670   PLINT arg3 ;
13671   PLFLT arg4 ;
13672   PLFLT arg5 ;
13673   PLFLT arg6 ;
13674   PLFLT arg7 ;
13675   PLFLT arg8 ;
13676   PLFLT arg9 ;
13677   PLFLT arg10 ;
13678   PLFLT arg11 ;
13679   pltr_func arg12 = (pltr_func) 0 ;
13680   PLPointer arg13 = (PLPointer) 0 ;
13681   PyArrayObject *tmp1 ;
13682   double val4 ;
13683   int ecode4 = 0 ;
13684   double val5 ;
13685   int ecode5 = 0 ;
13686   double val6 ;
13687   int ecode6 = 0 ;
13688   double val7 ;
13689   int ecode7 = 0 ;
13690   double val8 ;
13691   int ecode8 = 0 ;
13692   double val9 ;
13693   int ecode9 = 0 ;
13694   double val10 ;
13695   int ecode10 = 0 ;
13696   double val11 ;
13697   int ecode11 = 0 ;
13698   PyObject * obj0 = 0 ;
13699   PyObject * obj1 = 0 ;
13700   PyObject * obj2 = 0 ;
13701   PyObject * obj3 = 0 ;
13702   PyObject * obj4 = 0 ;
13703   PyObject * obj5 = 0 ;
13704   PyObject * obj6 = 0 ;
13705   PyObject * obj7 = 0 ;
13706   PyObject * obj8 = 0 ;
13707   PyObject * obj9 = 0 ;
13708   PyObject * obj10 = 0 ;
13709   
13710   {
13711     python_pltr = 0;
13712     arg12          = NULL;
13713   }
13714   {
13715     arg13 = NULL;
13716   }
13717   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13718   {
13719     int i, size;
13720     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13721     if ( tmp1 == NULL )
13722     return NULL;
13723     Xlen = arg2 = tmp1->dimensions[0];
13724     Ylen = arg3 = tmp1->dimensions[1];
13725     size = sizeof ( PLFLT ) * arg3;
13726     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13727     for ( i = 0; i < arg2; i++ )
13728     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13729   }
13730   ecode4 = SWIG_AsVal_double(obj1, &val4);
13731   if (!SWIG_IsOK(ecode4)) {
13732     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
13733   } 
13734   arg4 = (PLFLT)(val4);
13735   ecode5 = SWIG_AsVal_double(obj2, &val5);
13736   if (!SWIG_IsOK(ecode5)) {
13737     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
13738   } 
13739   arg5 = (PLFLT)(val5);
13740   ecode6 = SWIG_AsVal_double(obj3, &val6);
13741   if (!SWIG_IsOK(ecode6)) {
13742     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
13743   } 
13744   arg6 = (PLFLT)(val6);
13745   ecode7 = SWIG_AsVal_double(obj4, &val7);
13746   if (!SWIG_IsOK(ecode7)) {
13747     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
13748   } 
13749   arg7 = (PLFLT)(val7);
13750   ecode8 = SWIG_AsVal_double(obj5, &val8);
13751   if (!SWIG_IsOK(ecode8)) {
13752     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
13753   } 
13754   arg8 = (PLFLT)(val8);
13755   ecode9 = SWIG_AsVal_double(obj6, &val9);
13756   if (!SWIG_IsOK(ecode9)) {
13757     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
13758   } 
13759   arg9 = (PLFLT)(val9);
13760   ecode10 = SWIG_AsVal_double(obj7, &val10);
13761   if (!SWIG_IsOK(ecode10)) {
13762     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
13763   } 
13764   arg10 = (PLFLT)(val10);
13765   ecode11 = SWIG_AsVal_double(obj8, &val11);
13766   if (!SWIG_IsOK(ecode11)) {
13767     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
13768   } 
13769   arg11 = (PLFLT)(val11);
13770   if (obj9) {
13771     {
13772       // it must be a callable or None
13773       if ( obj9 == Py_None )
13774       {
13775         arg12 = NULL;
13776       }
13777       else
13778       {
13779         if ( !PyCallable_Check( (PyObject *) obj9 ) )
13780         {
13781           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13782           return NULL;
13783         }
13784         arg12 = marshal_pltr( obj9 );
13785       }
13786     }
13787   }
13788   if (obj10) {
13789     {
13790       if ( obj10 == Py_None )
13791       arg13 = NULL;
13792       else
13793       {
13794         arg13 = marshal_PLPointer( obj10, 1 );
13795       }
13796     }
13797   }
13798   plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13799   resultobj = SWIG_Py_Void();
13800   {
13801     Py_DECREF( tmp1 );
13802     free( arg1 );
13803   }
13804   {
13805     cleanup_pltr();
13806   }
13807   {
13808     cleanup_PLPointer();
13809   }
13810   return resultobj;
13811 fail:
13812   {
13813     Py_DECREF( tmp1 );
13814     free( arg1 );
13815   }
13816   {
13817     cleanup_pltr();
13818   }
13819   {
13820     cleanup_PLPointer();
13821   }
13822   return NULL;
13823 }
13824 
13825 
13826 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13827   PyObject *resultobj = 0;
13828   
13829   if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
13830   plClearOpts();
13831   resultobj = SWIG_Py_Void();
13832   return resultobj;
13833 fail:
13834   return NULL;
13835 }
13836 
13837 
13838 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13839   PyObject *resultobj = 0;
13840   
13841   if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
13842   plResetOpts();
13843   resultobj = SWIG_Py_Void();
13844   return resultobj;
13845 fail:
13846   return NULL;
13847 }
13848 
13849 
13850 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13851   PyObject *resultobj = 0;
13852   char *arg1 = (char *) 0 ;
13853   char *arg2 = (char *) 0 ;
13854   int res1 ;
13855   char *buf1 = 0 ;
13856   int alloc1 = 0 ;
13857   int res2 ;
13858   char *buf2 = 0 ;
13859   int alloc2 = 0 ;
13860   PyObject * obj0 = 0 ;
13861   PyObject * obj1 = 0 ;
13862   
13863   if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
13864   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13865   if (!SWIG_IsOK(res1)) {
13866     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
13867   }
13868   arg1 = (char *)(buf1);
13869   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13870   if (!SWIG_IsOK(res2)) {
13871     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
13872   }
13873   arg2 = (char *)(buf2);
13874   plSetUsage((char const *)arg1,(char const *)arg2);
13875   resultobj = SWIG_Py_Void();
13876   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13877   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13878   return resultobj;
13879 fail:
13880   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13881   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13882   return NULL;
13883 }
13884 
13885 
13886 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13887   PyObject *resultobj = 0;
13888   
13889   if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
13890   plOptUsage();
13891   resultobj = SWIG_Py_Void();
13892   return resultobj;
13893 fail:
13894   return NULL;
13895 }
13896 
13897 
13898 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13899   PyObject *resultobj = 0;
13900   PLFLT **arg1 = (PLFLT **) 0 ;
13901   PLINT arg2 ;
13902   PLINT arg3 ;
13903   PLFLT *arg4 = (PLFLT *) 0 ;
13904   PLFLT *arg5 = (PLFLT *) 0 ;
13905   PyArrayObject *tmp1 ;
13906   PLFLT temp4 ;
13907   int res4 = SWIG_TMPOBJ ;
13908   PLFLT temp5 ;
13909   int res5 = SWIG_TMPOBJ ;
13910   PyObject * obj0 = 0 ;
13911   
13912   arg4 = &temp4;
13913   arg5 = &temp5;
13914   if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
13915   {
13916     int i, size;
13917     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, PyArray_PLFLT, 2, 2 );
13918     if ( tmp1 == NULL )
13919     return NULL;
13920     Xlen = arg2 = tmp1->dimensions[0];
13921     Ylen = arg3 = tmp1->dimensions[1];
13922     size = sizeof ( PLFLT ) * arg3;
13923     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * arg2 );
13924     for ( i = 0; i < arg2; i++ )
13925     arg1[i] = (PLFLT *) ( tmp1->data + i * size );
13926   }
13927   plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
13928   resultobj = SWIG_Py_Void();
13929   if (SWIG_IsTmpObj(res4)) {
13930     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
13931   } else {
13932     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
13933     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
13934   }
13935   if (SWIG_IsTmpObj(res5)) {
13936     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
13937   } else {
13938     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
13939     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
13940   }
13941   {
13942     Py_DECREF( tmp1 );
13943     free( arg1 );
13944   }
13945   return resultobj;
13946 fail:
13947   {
13948     Py_DECREF( tmp1 );
13949     free( arg1 );
13950   }
13951   return NULL;
13952 }
13953 
13954 
13955 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13956   PyObject *resultobj = 0;
13957   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13958   void *argp1 = 0 ;
13959   int res1 = 0 ;
13960   PyObject * obj0 = 0 ;
13961   PLINT result;
13962   
13963   if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
13964   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
13965   if (!SWIG_IsOK(res1)) {
13966     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
13967   }
13968   arg1 = (PLGraphicsIn *)(argp1);
13969   result = (PLINT)plGetCursor(arg1);
13970   resultobj = SWIG_From_int((int)(result));
13971   return resultobj;
13972 fail:
13973   return NULL;
13974 }
13975 
13976 
13977 static PyMethodDef SwigMethods[] = {
13978          { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
13979          { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
13980          { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
13981          { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
13982          { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
13983          { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
13984          { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
13985          { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
13986          { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
13987          { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
13988          { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
13989          { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
13990          { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
13991          { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
13992          { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
13993          { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
13994          { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
13995          { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
13996          { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
13997          { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
13998          { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
13999          { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14000          { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14001          { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14002          { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14003          { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14004          { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14005          { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14006          { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14007          { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14008          { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14009          { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14010          { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14011                 "Set format of numerical label for contours\n"
14012                 "\n"
14013                 "DESCRIPTION:\n"
14014                 "\n"
14015                 "    Set format of numerical label for contours. \n"
14016                 "\n"
14017                 "    Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14018                 "\n"
14019                 "    This function is used example 9. \n"
14020                 "\n"
14021                 "\n"
14022                 "\n"
14023                 "SYNOPSIS:\n"
14024                 "\n"
14025                 "pl_setcontlabelformat(lexp, sigdig)\n"
14026                 "\n"
14027                 "ARGUMENTS:\n"
14028                 "\n"
14029                 "    lexp (PLINT, input) :    If the contour numerical label is greater\n"
14030                 "    than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14031                 "    format is used.  Default value of lexp is 4. \n"
14032                 "\n"
14033                 "    sigdig (PLINT, input) :    Number of significant digits.  Default\n"
14034                 "    value is 2. \n"
14035                 "\n"
14036                 ""},
14037          { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14038                 "Set parameters of contour labelling other than format of numerical label\n"
14039                 "\n"
14040                 "DESCRIPTION:\n"
14041                 "\n"
14042                 "    Set parameters of contour labelling other than those handled by\n"
14043                 "    pl_setcontlabelformat. \n"
14044                 "\n"
14045                 "    Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14046                 "\n"
14047                 "    This function is used in example 9. \n"
14048                 "\n"
14049                 "\n"
14050                 "\n"
14051                 "SYNOPSIS:\n"
14052                 "\n"
14053                 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14054                 "\n"
14055                 "ARGUMENTS:\n"
14056                 "\n"
14057                 "    offset (PLFLT, input) :    Offset of label from contour line (if set\n"
14058                 "    to 0.0, labels are printed on the lines).  Default value is 0.006. \n"
14059                 "\n"
14060                 "    size (PLFLT, input) :    Font height for contour labels (normalized). \n"
14061                 "    Default value is 0.3. \n"
14062                 "\n"
14063                 "    spacing (PLFLT, input) :    Spacing parameter for contour labels. \n"
14064                 "    Default value is 0.1. \n"
14065                 "\n"
14066                 "    active (PLINT, input) :    Activate labels.  Set to 1 if you want\n"
14067                 "    contour labels on. Default is off (0). \n"
14068                 "\n"
14069                 ""},
14070          { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14071                 "Advance the (sub-)page\n"
14072                 "\n"
14073                 "DESCRIPTION:\n"
14074                 "\n"
14075                 "    Advances to the next subpage if sub=0, performing a page advance if\n"
14076                 "    there are no remaining subpages on the current page.  If subpages\n"
14077                 "    aren't being used, pladv(0) will always advance the page.  If sub>0,\n"
14078                 "    PLplot switches to the specified subpage.  Note that this allows you\n"
14079                 "    to overwrite a plot on the specified subpage; if this is not what you\n"
14080                 "    intended, use pleop followed by plbop to first advance the page.  This\n"
14081                 "    routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14082                 "    not used, pladv must be called after initializing PLplot but before\n"
14083                 "    defining the viewport. \n"
14084                 "\n"
14085                 "    Redacted form: pladv(sub)\n"
14086                 "\n"
14087                 "    This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14088                 "\n"
14089                 "\n"
14090                 "\n"
14091                 "SYNOPSIS:\n"
14092                 "\n"
14093                 "pladv(sub)\n"
14094                 "\n"
14095                 "ARGUMENTS:\n"
14096                 "\n"
14097                 "    sub (PLINT, input) :    Specifies the subpage number (starting from 1\n"
14098                 "    in the top left corner and increasing along the rows) to which to\n"
14099                 "    advance.  Set to zero to advance to the next subpage. \n"
14100                 "\n"
14101                 ""},
14102          { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14103                 "Draw a circular or elliptical arc \n"
14104                 "\n"
14105                 "DESCRIPTION:\n"
14106                 "\n"
14107                 "    Draw a possible filled arc centered at x, y with semimajor axis  a and\n"
14108                 "    semiminor axis  b, starting at  angle1 and ending at  angle2. \n"
14109                 "\n"
14110                 "    Redacted form:  General: plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14111                 "\n"
14112                 "\n"
14113                 "    This function is used in example 3. \n"
14114                 "\n"
14115                 "\n"
14116                 "\n"
14117                 "SYNOPSIS:\n"
14118                 "\n"
14119                 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14120                 "\n"
14121                 "ARGUMENTS:\n"
14122                 "\n"
14123                 "    x (PLFLT, input) :      X coordinate of arc center. \n"
14124                 "\n"
14125                 "    y (PLFLT, input) :      Y coordinate of arc center. \n"
14126                 "\n"
14127                 "    a (PLFLT, input) :      Length of the semimajor axis of the arc. \n"
14128                 "\n"
14129                 "    b (PLFLT, input) :      Length of the semiminor axis of the arc. \n"
14130                 "\n"
14131                 "    angle1 (PLFLT, input) :    Starting angle of the arc. \n"
14132                 "\n"
14133                 "    angle2 (PLFLT, input) :    Ending angle of the arc. \n"
14134                 "\n"
14135                 "    rotate (PLFLT, input) :    Rotation of arc\n"
14136                 "\n"
14137                 "    fill (PLBOOL, input) :    Draw a filled arc. \n"
14138                 "\n"
14139                 ""},
14140          { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14141                 "Draw a box with axes, etc. with arbitrary origin \n"
14142                 "\n"
14143                 "DESCRIPTION:\n"
14144                 "\n"
14145                 "    Draws a box around the currently defined viewport with arbitrary\n"
14146                 "    world-coordinate origin specified by x0 and y0 and labels it with\n"
14147                 "    world coordinate values appropriate to the window. Thus plaxes should\n"
14148                 "    only be called after defining both viewport and window.  The character\n"
14149                 "    strings xopt and yopt specify how the box should be drawn as described\n"
14150                 "    below.  If ticks and/or subticks are to be drawn for a particular\n"
14151                 "    axis, the tick intervals and number of subintervals may be specified\n"
14152                 "    explicitly, or they may be defaulted by setting the appropriate\n"
14153                 "    arguments to zero. \n"
14154                 "\n"
14155                 "    Redacted form:  General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14156                 "    ytick, nysub)\n"
14157                 "           Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14158                 "    yopt)\n"
14159                 "\n"
14160                 "\n"
14161                 "    This function is not used in any examples. \n"
14162                 "\n"
14163                 "\n"
14164                 "\n"
14165                 "SYNOPSIS:\n"
14166                 "\n"
14167                 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14168                 "\n"
14169                 "ARGUMENTS:\n"
14170                 "\n"
14171                 "    x0 (PLFLT, input) :    World X coordinate of origin. \n"
14172                 "\n"
14173                 "    y0 (PLFLT, input) :    World Y coordinate of origin. \n"
14174                 "\n"
14175                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
14176                 "    options for horizontal axis.  The string can include any\n"
14177                 "    combination of the following letters (upper or lower case) in any\n"
14178                 "    order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14179                 "    is vertical line (x=0). \n"
14180                 "        b: Draws bottom (X) or left (Y) edge of frame. \n"
14181                 "        c: Draws top (X) or right (Y) edge of frame. \n"
14182                 "        d: Plot labels as date / time.  Values are assumed to be\n"
14183                 "        seconds since the epoch  (as used by gmtime). \n"
14184                 "        f:    Always use fixed point numeric labels. \n"
14185                 "        g: Draws a grid at the major tick interval. \n"
14186                 "        h: Draws a grid at the minor tick interval. \n"
14187                 "        i: Inverts tick marks, so they are drawn outwards, rather than\n"
14188                 "        inwards. \n"
14189                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
14190                 "        not the data, and so it is necessary to compute the logarithms\n"
14191                 "        of data points before passing them to any of the drawing\n"
14192                 "        routines. \n"
14193                 "        m: Writes numeric labels at major tick intervals in the\n"
14194                 "        unconventional location (above box for X, right of box for Y). \n"
14195                 "        n: Writes numeric labels at major tick intervals in the\n"
14196                 "        conventional location (below box for X, left of box for Y). \n"
14197                 "        o: Use custom labeling function to generate axis label text. \n"
14198                 "        The custom labeling function can be defined with the\n"
14199                 "        plslabelfuncplslabelfunc; command. \n"
14200                 "        s: Enables subticks between major ticks, only valid if t is\n"
14201                 "        also specified. \n"
14202                 "        t: Draws major ticks. \n"
14203                 "\n"
14204                 "\n"
14205                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
14206                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
14207                 "    generates a suitable tick interval. \n"
14208                 "\n"
14209                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
14210                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14211                 "    generates a suitable minor tick interval. \n"
14212                 "\n"
14213                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
14214                 "    options for vertical axis.  The string can include any combination\n"
14215                 "    of the letters defined above for xopt, and in addition may\n"
14216                 "    contain: v: Write numeric labels for vertical axis parallel to the\n"
14217                 "    base of the graph, rather than parallel to the axis. \n"
14218                 "\n"
14219                 "\n"
14220                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
14221                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
14222                 "    generates a suitable tick interval. \n"
14223                 "\n"
14224                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
14225                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14226                 "    generates a suitable minor tick interval. \n"
14227                 "\n"
14228                 ""},
14229          { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14230                 "Plot a histogram from binned data \n"
14231                 "\n"
14232                 "DESCRIPTION:\n"
14233                 "\n"
14234                 "    Plots a histogram consisting of nbin bins. The value associated with\n"
14235                 "    the i'th bin is placed in x[i], and the number of points in the bin is\n"
14236                 "    placed in y[i].  For proper operation, the values in x[i] must form a\n"
14237                 "    strictly increasing sequence.  By default, x[i] is the left-hand edge\n"
14238                 "    of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14239                 "    placed midway between the values in the x array.  Also see plhist for\n"
14240                 "    drawing histograms from unbinned data. \n"
14241                 "\n"
14242                 "    Redacted form:  General: plbin(x, y, opt)\n"
14243                 "           Perl/PDL: plbin(nbin, x, y, opt)\n"
14244                 "           Python: plbin(nbin, x, y, opt)\n"
14245                 "\n"
14246                 "\n"
14247                 "    This function is not used in any examples. \n"
14248                 "\n"
14249                 "\n"
14250                 "\n"
14251                 "SYNOPSIS:\n"
14252                 "\n"
14253                 "plbin(nbin, x, y, opt)\n"
14254                 "\n"
14255                 "ARGUMENTS:\n"
14256                 "\n"
14257                 "    nbin (PLINT, input) :    Number of bins (i.e., number of values in x\n"
14258                 "    and y arrays.) \n"
14259                 "\n"
14260                 "    x (PLFLT *, input) :    Pointer to array containing values associated\n"
14261                 "    with bins.  These must form a strictly increasing sequence. \n"
14262                 "\n"
14263                 "    y (PLFLT *, input) :    Pointer to array containing number of points\n"
14264                 "    in bin.  This is a PLFLT (instead of PLINT) array so as to allow\n"
14265                 "    histograms of probabilities, etc. \n"
14266                 "\n"
14267                 "    opt (PLINT, input) :    Is a combination of several flags:\n"
14268                 "    opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14269                 "    outer bins are expanded to fill up the entire x-axis and bins of\n"
14270                 "    zero height are simply drawn. \n"
14271                 "        opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14272                 "        between the x values. If the values in x are equally spaced,\n"
14273                 "        the values are the center values of the bins. \n"
14274                 "        opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14275                 "        size as the ones inside. \n"
14276                 "        opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14277                 "        (there is a gap for such bins). \n"
14278                 "\n"
14279                 ""},
14280          { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, NULL},
14281          { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
14282                 "Begin a new page\n"
14283                 "\n"
14284                 "DESCRIPTION:\n"
14285                 "\n"
14286                 "    Begins a new page. For a file driver, the output file is opened if\n"
14287                 "    necessary. Advancing the page via pleop and plbop is useful when a\n"
14288                 "    page break is desired at a particular point when plotting to subpages.\n"
14289                 "     Another use for pleop and plbop is when plotting pages to different\n"
14290                 "    files, since you can manually set the file name by calling plsfnam\n"
14291                 "    after the call to pleop. (In fact some drivers may only support a\n"
14292                 "    single page per file, making this a necessity.)  One way to handle\n"
14293                 "    this case automatically is to page advance via pladv, but enable\n"
14294                 "    familying (see plsfam) with a small limit on the file size so that a\n"
14295                 "    new family member file will be created on each page break. \n"
14296                 "\n"
14297                 "    Redacted form: plbop()\n"
14298                 "\n"
14299                 "    This function is used in examples 2,20. \n"
14300                 "\n"
14301                 "\n"
14302                 "\n"
14303                 "SYNOPSIS:\n"
14304                 "\n"
14305                 "plbop()\n"
14306                 "\n"
14307                 ""},
14308          { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
14309                 "Draw a box with axes, etc\n"
14310                 "\n"
14311                 "DESCRIPTION:\n"
14312                 "\n"
14313                 "    Draws a box around the currently defined viewport, and labels it with\n"
14314                 "    world coordinate values appropriate to the window. Thus plbox should\n"
14315                 "    only be called after defining both viewport and window.  The character\n"
14316                 "    strings xopt and yopt specify how the box should be drawn as described\n"
14317                 "    below.  If ticks and/or subticks are to be drawn for a particular\n"
14318                 "    axis, the tick intervals and number of subintervals may be specified\n"
14319                 "    explicitly, or they may be defaulted by setting the appropriate\n"
14320                 "    arguments to zero. \n"
14321                 "\n"
14322                 "    Redacted form:  General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14323                 "           Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
14324                 "\n"
14325                 "\n"
14326                 "    This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
14327                 "\n"
14328                 "\n"
14329                 "\n"
14330                 "SYNOPSIS:\n"
14331                 "\n"
14332                 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14333                 "\n"
14334                 "ARGUMENTS:\n"
14335                 "\n"
14336                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
14337                 "    options for horizontal axis.  The string can include any\n"
14338                 "    combination of the following letters (upper or lower case) in any\n"
14339                 "    order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14340                 "    is vertical line (x=0). \n"
14341                 "        b: Draws bottom (X) or left (Y) edge of frame. \n"
14342                 "        c: Draws top (X) or right (Y) edge of frame. \n"
14343                 "        d: Plot labels as date / time.  Values are assumed to be\n"
14344                 "        seconds since the epoch  (as used by gmtime). \n"
14345                 "        f:    Always use fixed point numeric labels. \n"
14346                 "        g: Draws a grid at the major tick interval. \n"
14347                 "        h: Draws a grid at the minor tick interval. \n"
14348                 "        i: Inverts tick marks, so they are drawn outwards, rather than\n"
14349                 "        inwards. \n"
14350                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
14351                 "        not the data, and so it is necessary to compute the logarithms\n"
14352                 "        of data points before passing them to any of the drawing\n"
14353                 "        routines. \n"
14354                 "        m: Writes numeric labels at major tick intervals in the\n"
14355                 "        unconventional location (above box for X, right of box for Y). \n"
14356                 "        n: Writes numeric labels at major tick intervals in the\n"
14357                 "        conventional location (below box for X, left of box for Y). \n"
14358                 "        o: Use custom labeling function to generate axis label text. \n"
14359                 "        The custom labeling function can be defined with the\n"
14360                 "        plslabelfuncplslabelfunc; command. \n"
14361                 "        s: Enables subticks between major ticks, only valid if t is\n"
14362                 "        also specified. \n"
14363                 "        t: Draws major ticks. \n"
14364                 "\n"
14365                 "\n"
14366                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
14367                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
14368                 "    generates a suitable tick interval. \n"
14369                 "\n"
14370                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
14371                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14372                 "    generates a suitable minor tick interval. \n"
14373                 "\n"
14374                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
14375                 "    options for vertical axis.  The string can include any combination\n"
14376                 "    of the letters defined above for xopt, and in addition may\n"
14377                 "    contain: v: Write numeric labels for vertical axis parallel to the\n"
14378                 "    base of the graph, rather than parallel to the axis. \n"
14379                 "\n"
14380                 "\n"
14381                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
14382                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
14383                 "    generates a suitable tick interval. \n"
14384                 "\n"
14385                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
14386                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14387                 "    generates a suitable minor tick interval. \n"
14388                 "\n"
14389                 ""},
14390          { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
14391                 "Draw a box with axes, etc, in 3-d \n"
14392                 "\n"
14393                 "DESCRIPTION:\n"
14394                 "\n"
14395                 "    Draws axes, numeric and text labels for a three-dimensional surface\n"
14396                 "    plot.  For a more complete description of three-dimensional plotting\n"
14397                 "    see the PLplot documentation. \n"
14398                 "\n"
14399                 "    Redacted form:  General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
14400                 "    ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
14401                 "           Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
14402                 "    xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
14403                 "\n"
14404                 "\n"
14405                 "    This function is used in examples 8,11,18,21. \n"
14406                 "\n"
14407                 "\n"
14408                 "\n"
14409                 "SYNOPSIS:\n"
14410                 "\n"
14411                 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
14412                 "\n"
14413                 "ARGUMENTS:\n"
14414                 "\n"
14415                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
14416                 "    options for the x axis. The string can include any combination of\n"
14417                 "    the following letters (upper or lower case) in any order: b: Draws\n"
14418                 "    axis at base, at height z=\n"
14419                 "    zmin where zmin is defined by call to plw3d.  This character must be\n"
14420                 "    specified in order to use any of the other options. \n"
14421                 "        f: Always use fixed point numeric labels. \n"
14422                 "        i: Inverts tick marks, so they are drawn downwards, rather\n"
14423                 "        than upwards. \n"
14424                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
14425                 "        not the data, and so it is necessary to compute the logarithms\n"
14426                 "        of data points before passing them to any of the drawing\n"
14427                 "        routines. \n"
14428                 "        n: Writes numeric labels at major tick intervals. \n"
14429                 "        o: Use custom labeling function to generate axis label text. \n"
14430                 "        The custom labeling function can be defined with the\n"
14431                 "        plslabelfuncplslabelfunc; command. \n"
14432                 "        s: Enables subticks between major ticks, only valid if t is\n"
14433                 "        also specified. \n"
14434                 "        t: Draws major ticks. \n"
14435                 "        u: If this is specified, the text label for the axis is\n"
14436                 "        written under the axis. \n"
14437                 "\n"
14438                 "\n"
14439                 "    xlabel (const char *, input) :    Pointer to character string\n"
14440                 "    specifying text label for the x axis.  It is only drawn if u is in\n"
14441                 "    the xopt string. \n"
14442                 "\n"
14443                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
14444                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
14445                 "    generates a suitable tick interval. \n"
14446                 "\n"
14447                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
14448                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14449                 "    generates a suitable minor tick interval. \n"
14450                 "\n"
14451                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
14452                 "    options for the y axis. The string is interpreted in the same way\n"
14453                 "    as xopt. \n"
14454                 "\n"
14455                 "    ylabel (const char *, input) :    Pointer to character string\n"
14456                 "    specifying text label for the y axis.  It is only drawn if u is in\n"
14457                 "    the yopt string. \n"
14458                 "\n"
14459                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
14460                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
14461                 "    generates a suitable tick interval. \n"
14462                 "\n"
14463                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
14464                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14465                 "    generates a suitable minor tick interval. \n"
14466                 "\n"
14467                 "    zopt (const char *, input) :    Pointer to character string specifying\n"
14468                 "    options for the z axis. The string can include any combination of\n"
14469                 "    the following letters (upper or lower case) in any order: b: Draws\n"
14470                 "    z axis to the left of the surface plot. \n"
14471                 "        c: Draws z axis to the right of the surface plot. \n"
14472                 "        d: Draws grid lines parallel to the x-y plane behind the\n"
14473                 "        figure.  These lines are not drawn until after plot3d or\n"
14474                 "        plmesh are called because of the need for hidden line removal. \n"
14475                 "        f: Always use fixed point numeric labels. \n"
14476                 "        i: Inverts tick marks, so they are drawn away from the center. \n"
14477                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
14478                 "        not the data, and so it is necessary to compute the logarithms\n"
14479                 "        of data points before passing them to any of the drawing\n"
14480                 "        routines. \n"
14481                 "        m: Writes numeric labels at major tick intervals on the\n"
14482                 "        right-hand vertical axis. \n"
14483                 "        n: Writes numeric labels at major tick intervals on the\n"
14484                 "        left-hand vertical axis. \n"
14485                 "        o: Use custom labeling function to generate axis label text. \n"
14486                 "        The custom labeling function can be defined with the\n"
14487                 "        plslabelfuncplslabelfunc; command. \n"
14488                 "        s: Enables subticks between major ticks, only valid if t is\n"
14489                 "        also specified. \n"
14490                 "        t: Draws major ticks. \n"
14491                 "        u: If this is specified, the text label is written beside the\n"
14492                 "        left-hand axis. \n"
14493                 "        v: If this is specified, the text label is written beside the\n"
14494                 "        right-hand axis. \n"
14495                 "\n"
14496                 "\n"
14497                 "    zlabel (const char *, input) :    Pointer to character string\n"
14498                 "    specifying text label for the z axis.  It is only drawn if u or v\n"
14499                 "    are in the zopt string. \n"
14500                 "\n"
14501                 "    ztick (PLFLT, input) :    World coordinate interval between major\n"
14502                 "    ticks on the z axis. If it is set to zero, PLplot automatically\n"
14503                 "    generates a suitable tick interval. \n"
14504                 "\n"
14505                 "    nzsub (PLINT, input) :    Number of subintervals between major z axis\n"
14506                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14507                 "    generates a suitable minor tick interval. \n"
14508                 "\n"
14509                 ""},
14510          { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
14511                 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
14512                 "\n"
14513                 "DESCRIPTION:\n"
14514                 "\n"
14515                 "    Calculate world coordinates, wx and wy, and corresponding window index\n"
14516                 "    from relative device coordinates, rx and ry. \n"
14517                 "\n"
14518                 "    Redacted form:  General: plcalc_world(rx, ry, wx, wy, window)\n"
14519                 "           Perl/PDL: Not available? \n"
14520                 "\n"
14521                 "\n"
14522                 "    This function is used in example 31. \n"
14523                 "\n"
14524                 "\n"
14525                 "\n"
14526                 "SYNOPSIS:\n"
14527                 "\n"
14528                 "plcalc_world(rx, ry, wx, wy, window)\n"
14529                 "\n"
14530                 "ARGUMENTS:\n"
14531                 "\n"
14532                 "    rx (PLFLT, input) :    Input relative device coordinate (ranging from\n"
14533                 "    0. to 1.) for the x coordinate. \n"
14534                 "\n"
14535                 "    ry (PLFLT, input) :    Input relative device coordinate (ranging from\n"
14536                 "    0. to 1.) for the y coordinate. \n"
14537                 "\n"
14538                 "    wx (PLFLT *, output) :    Pointer to the returned world coordinate for\n"
14539                 "    x corresponding to the relative device coordinates rx and ry. \n"
14540                 "\n"
14541                 "    wy (PLFLT *, output) :    Pointer to the returned world coordinate for\n"
14542                 "    y corresponding to the relative device coordinates rx and ry. \n"
14543                 "\n"
14544                 "    window (PLINT *, output) :      Pointer to the returned last defined\n"
14545                 "    window index that corresponds to the input relative device\n"
14546                 "    coordinates (and the returned world coordinates).  To give some\n"
14547                 "    background on the window index, for each page the initial window\n"
14548                 "    index is set to zero, and each time plwind is called within the\n"
14549                 "    page, world and device coordinates are stored for the window and\n"
14550                 "    the window index is incremented.  Thus, for a simple page layout\n"
14551                 "    with non-overlapping viewports and one window per viewport, window\n"
14552                 "    corresponds to the viewport index (in the order which the\n"
14553                 "    viewport/windows were created) of the only viewport/window\n"
14554                 "    corresponding to rx and ry.  However, for more complicated layouts\n"
14555                 "    with potentially overlapping viewports and possibly more than one\n"
14556                 "    window (set of world coordinates) per viewport, window and the\n"
14557                 "    corresponding output world coordinates corresponds to the last\n"
14558                 "    window created that fulfils the criterion that the relative device\n"
14559                 "    coordinates are inside it.  Finally, in all cases where the input\n"
14560                 "    relative device coordinates are not inside any viewport/window,\n"
14561                 "    then window is set to -1. \n"
14562                 "\n"
14563                 ""},
14564          { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
14565                 "Clear current (sub)page \n"
14566                 "\n"
14567                 "DESCRIPTION:\n"
14568                 "\n"
14569                 "    Clears the current page, effectively erasing everything that have been\n"
14570                 "    drawn.  This command only works with interactive drivers; if the\n"
14571                 "    driver does not support this, the page is filled with the background\n"
14572                 "    color in use. If the current page is divided into subpages, only the\n"
14573                 "    current subpage is erased. The nth subpage can be selected with\n"
14574                 "    pladv(n). \n"
14575                 "\n"
14576                 "    Redacted form:  General: plclear()\n"
14577                 "           Perl/PDL: Not available? \n"
14578                 "\n"
14579                 "\n"
14580                 "    This function is not used in any examples. \n"
14581                 "\n"
14582                 "\n"
14583                 "\n"
14584                 "SYNOPSIS:\n"
14585                 "\n"
14586                 "plclear()\n"
14587                 "\n"
14588                 ""},
14589          { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
14590                 "Set color, map0 \n"
14591                 "\n"
14592                 "DESCRIPTION:\n"
14593                 "\n"
14594                 "    Sets the color for color map0 (see the PLplot documentation). \n"
14595                 "\n"
14596                 "    Redacted form: plcol0(color)\n"
14597                 "\n"
14598                 "    This function is used in examples 1-9,11-16,18-27,29. \n"
14599                 "\n"
14600                 "\n"
14601                 "\n"
14602                 "SYNOPSIS:\n"
14603                 "\n"
14604                 "plcol0(color)\n"
14605                 "\n"
14606                 "ARGUMENTS:\n"
14607                 "\n"
14608                 "    color (PLINT, input) :    Integer representing the color.  The\n"
14609                 "    defaults at present are (these may change): \n"
14610                 "    0       black (default background) \n"
14611                 "    1       red (default foreground) \n"
14612                 "    2       yellow \n"
14613                 "    3       green \n"
14614                 "    4       aquamarine \n"
14615                 "    5       pink \n"
14616                 "    6       wheat \n"
14617                 "    7       grey \n"
14618                 "    8       brown \n"
14619                 "    9       blue \n"
14620                 "    10        BlueViolet \n"
14621                 "    11        cyan \n"
14622                 "    12        turquoise \n"
14623                 "    13        magenta \n"
14624                 "    14        salmon \n"
14625                 "    15        white \n"
14626                 "      Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
14627                 "     change an individual color in the map0 color palette. \n"
14628                 "\n"
14629                 ""},
14630          { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
14631                 "Set color, map1 \n"
14632                 "\n"
14633                 "DESCRIPTION:\n"
14634                 "\n"
14635                 "    Sets the color for color map1 (see the PLplot documentation).  \n"
14636                 "\n"
14637                 "    Redacted form: plcol1(col1)\n"
14638                 "\n"
14639                 "    This function is used in example 12. \n"
14640                 "\n"
14641                 "\n"
14642                 "\n"
14643                 "SYNOPSIS:\n"
14644                 "\n"
14645                 "plcol1(col1)\n"
14646                 "\n"
14647                 "ARGUMENTS:\n"
14648                 "\n"
14649                 "    col1 (PLFLT, input) :    This value must be in the range from 0. to 1.\n"
14650                 "    and is mapped to color using the continuous map1 color palette\n"
14651                 "    which by default ranges from blue to the background color to red. \n"
14652                 "    The map1 palette can also be straightforwardly changed by the user\n"
14653                 "    with plscmap1 or plscmap1l. \n"
14654                 "\n"
14655                 ""},
14656          { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, NULL},
14657          { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
14658                 "Contour plot \n"
14659                 "\n"
14660                 "DESCRIPTION:\n"
14661                 "\n"
14662                 "    Draws a contour plot of the data in z[\n"
14663                 "    nx][\n"
14664                 "    ny], using the nlevel contour levels specified by clevel. Only the\n"
14665                 "    region of the array from kx to lx and from ky to ly is plotted out.  A\n"
14666                 "    transformation routine pointed to by pltr with a pointer pltr_data for\n"
14667                 "    additional data required by the transformation routine is used to map\n"
14668                 "    indices within the array to the world coordinates. See the following\n"
14669                 "    discussion of the arguments and the PLplot documentation for more\n"
14670                 "    information. \n"
14671                 "\n"
14672                 "    Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
14673                 "    plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
14674                 "    clevel, xgrid, ygrid)\n"
14675                 "           Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
14676                 "           Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
14677                 "           Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
14678                 "\n"
14679                 "\n"
14680                 "    This function is used in examples 9,14,16,22. \n"
14681                 "\n"
14682                 "\n"
14683                 "\n"
14684                 "SYNOPSIS:\n"
14685                 "\n"
14686                 "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
14687                 "\n"
14688                 "ARGUMENTS:\n"
14689                 "\n"
14690                 "    z (PLFLT **, input) :    Pointer to a vectored two-dimensional array\n"
14691                 "    containing data to be contoured. \n"
14692                 "\n"
14693                 "    nx, ny (PLINT, input) :    Physical dimensions of array z. \n"
14694                 "\n"
14695                 "    kx, lx (PLINT, input) :    Range of x indices to consider. \n"
14696                 "\n"
14697                 "    ky, ly (PLINT, input) :    Range of y indices to consider. \n"
14698                 "\n"
14699                 "    clevel (PLFLT *, input) :     Pointer to array specifying levels at\n"
14700                 "    which to draw contours. \n"
14701                 "\n"
14702                 "    nlevel (PLINT, input) :    Number of contour levels to draw. \n"
14703                 "\n"
14704                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
14705                 "      Pointer to function that defines transformation between indices\n"
14706                 "    in array z and the world coordinates (C only).    Transformation\n"
14707                 "    functions are provided in the PLplot library: pltr0 for identity\n"
14708                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
14709                 "    defined by one- and two-dimensional arrays.  In addition,\n"
14710                 "    user-supplied routines for the transformation can be used as well.\n"
14711                 "     Examples of all of these approaches are given in the PLplot\n"
14712                 "    documentation. The transformation function should have the form\n"
14713                 "    given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
14714                 "    and similar PLplot functions which have a pltr argument, plcont\n"
14715                 "    requires that a transformation function be provided in the C\n"
14716                 "    interface.  Leaving  pltr NULL will result in an error. \n"
14717                 "\n"
14718                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
14719                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
14720                 "    externally supplied. \n"
14721                 "\n"
14722                 ""},
14723          { (char *)"plctime", _wrap_plctime, METH_VARARGS, NULL},
14724          { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
14725                 "Copy state parameters from the reference stream to the current stream \n"
14726                 "\n"
14727                 "DESCRIPTION:\n"
14728                 "\n"
14729                 "    Copies state parameters from the reference stream to the current\n"
14730                 "    stream. Tell driver interface to map device coordinates unless flags\n"
14731                 "    == 1. \n"
14732                 "\n"
14733                 "    This function is used for making save files of selected plots (e.g.\n"
14734                 "    from the TK driver).  After initializing, you can get a copy of the\n"
14735                 "    current plot to the specified device by switching to this stream and\n"
14736                 "    issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
14737                 "    appropriate.  The plot buffer must have previously been enabled (done\n"
14738                 "    automatically by some display drivers, such as X). \n"
14739                 "\n"
14740                 "    Redacted form: plcpstrm(iplsr, flags)\n"
14741                 "\n"
14742                 "    This function is used in example 1,20. \n"
14743                 "\n"
14744                 "\n"
14745                 "\n"
14746                 "SYNOPSIS:\n"
14747                 "\n"
14748                 "plcpstrm(iplsr, flags)\n"
14749                 "\n"
14750                 "ARGUMENTS:\n"
14751                 "\n"
14752                 "    iplsr (PLINT, input) :    Number of reference stream. \n"
14753                 "\n"
14754                 "    flags (PLBOOL, input) :    If flags is set to true the device\n"
14755                 "    coordinates are not copied from the reference to current stream. \n"
14756                 "\n"
14757                 ""},
14758          { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
14759                 "End plotting session \n"
14760                 "\n"
14761                 "DESCRIPTION:\n"
14762                 "\n"
14763                 "    Ends a plotting session, tidies up all the output files, switches\n"
14764                 "    interactive devices back into text mode and frees up any memory that\n"
14765                 "    was allocated.  Must be called before end of program. \n"
14766                 "\n"
14767                 "    By default, PLplot's interactive devices (Xwin, TK, etc.)  go into a\n"
14768                 "    wait state after a call to plend or other functions which trigger the\n"
14769                 "    end of a plot page. To avoid this, use the plspause function. \n"
14770                 "\n"
14771                 "    Redacted form: plend()\n"
14772                 "\n"
14773                 "    This function is used in all of the examples. \n"
14774                 "\n"
14775                 "\n"
14776                 "\n"
14777                 "SYNOPSIS:\n"
14778                 "\n"
14779                 "plend()\n"
14780                 "\n"
14781                 ""},
14782          { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
14783                 "End plotting session for current stream \n"
14784                 "\n"
14785                 "DESCRIPTION:\n"
14786                 "\n"
14787                 "    Ends a plotting session for the current output stream only.  See\n"
14788                 "    plsstrm for more info. \n"
14789                 "\n"
14790                 "    Redacted form: plend1()\n"
14791                 "\n"
14792                 "    This function is used in examples 1,20. \n"
14793                 "\n"
14794                 "\n"
14795                 "\n"
14796                 "SYNOPSIS:\n"
14797                 "\n"
14798                 "plend1()\n"
14799                 "\n"
14800                 ""},
14801          { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
14802                 "Set up standard window and draw box \n"
14803                 "\n"
14804                 "DESCRIPTION:\n"
14805                 "\n"
14806                 "    Sets up plotter environment for simple graphs by calling pladv and\n"
14807                 "    setting up viewport and window to sensible default values. plenv\n"
14808                 "    leaves enough room around most graphs for axis labels and a title.\n"
14809                 "    When these defaults are not suitable, use the individual routines\n"
14810                 "    plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
14811                 "    defining the window, and plbox for drawing the box. \n"
14812                 "\n"
14813                 "    Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
14814                 "\n"
14815                 "    This function is used in example 1,3,9,13,14,19-22,29. \n"
14816                 "\n"
14817                 "\n"
14818                 "\n"
14819                 "SYNOPSIS:\n"
14820                 "\n"
14821                 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
14822                 "\n"
14823                 "ARGUMENTS:\n"
14824                 "\n"
14825                 "    xmin (PLFLT, input) :    Value of x at left-hand edge of window (in\n"
14826                 "    world coordinates). \n"
14827                 "\n"
14828                 "    xmax (PLFLT, input) :    Value of x at right-hand edge of window (in\n"
14829                 "    world coordinates). \n"
14830                 "\n"
14831                 "    ymin (PLFLT, input) :    Value of y at bottom edge of window (in world\n"
14832                 "    coordinates). \n"
14833                 "\n"
14834                 "    ymax (PLFLT, input) :    Value of y at top edge of window (in world\n"
14835                 "    coordinates). \n"
14836                 "\n"
14837                 "    just (PLINT, input) :    Controls how the axes will be scaled: -1: the\n"
14838                 "    scales will not be set, the user must set up the scale before\n"
14839                 "    calling plenv using plsvpa, plvasp or other. \n"
14840                 "        0: the x and y axes are scaled independently to use as much of\n"
14841                 "        the screen as possible. \n"
14842                 "        1: the scales of the x and y axes are made equal. \n"
14843                 "        2: the axis of the x and y axes are made equal, and the plot\n"
14844                 "        box will be square. \n"
14845                 "\n"
14846                 "\n"
14847                 "    axis (PLINT, input) :    Controls drawing of the box around the plot:\n"
14848                 "    -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
14849                 "        -1: draw box only. \n"
14850                 "        0: draw box, ticks, and numeric tick labels. \n"
14851                 "        1: also draw coordinate axes at x=0 and y=0. \n"
14852                 "        2: also draw a grid at major tick positions in both\n"
14853                 "        coordinates. \n"
14854                 "        3: also draw a grid at minor tick positions in both\n"
14855                 "        coordinates. \n"
14856                 "        10: same as 0 except logarithmic x tick marks. (The x data\n"
14857                 "        have to be converted to logarithms separately.) \n"
14858                 "        11: same as 1 except logarithmic x tick marks. (The x data\n"
14859                 "        have to be converted to logarithms separately.) \n"
14860                 "        12: same as 2 except logarithmic x tick marks. (The x data\n"
14861                 "        have to be converted to logarithms separately.) \n"
14862                 "        13: same as 3 except logarithmic x tick marks. (The x data\n"
14863                 "        have to be converted to logarithms separately.) \n"
14864                 "        20: same as 0 except logarithmic y tick marks. (The y data\n"
14865                 "        have to be converted to logarithms separately.) \n"
14866                 "        21: same as 1 except logarithmic y tick marks. (The y data\n"
14867                 "        have to be converted to logarithms separately.) \n"
14868                 "        22: same as 2 except logarithmic y tick marks. (The y data\n"
14869                 "        have to be converted to logarithms separately.) \n"
14870                 "        23: same as 3 except logarithmic y tick marks. (The y data\n"
14871                 "        have to be converted to logarithms separately.) \n"
14872                 "        30: same as 0 except logarithmic x and y tick marks. (The x\n"
14873                 "        and y data have to be converted to logarithms separately.) \n"
14874                 "        31: same as 1 except logarithmic x and y tick marks. (The x\n"
14875                 "        and y data have to be converted to logarithms separately.) \n"
14876                 "        32: same as 2 except logarithmic x and y tick marks. (The x\n"
14877                 "        and y data have to be converted to logarithms separately.) \n"
14878                 "        33: same as 3 except logarithmic x and y tick marks. (The x\n"
14879                 "        and y data have to be converted to logarithms separately.) \n"
14880                 "        40: same as 0 except date / time x labels.    \n"
14881                 "        41: same as 1 except date / time x labels.    \n"
14882                 "        42: same as 2 except date / time x labels.    \n"
14883                 "        43: same as 3 except date / time x labels.    \n"
14884                 "        50: same as 0 except date / time y labels.    \n"
14885                 "        51: same as 1 except date / time y labels.    \n"
14886                 "        52: same as 2 except date / time y labels. \n"
14887                 "        53: same as 3 except date / time y labels.    \n"
14888                 "        60: same as 0 except date / time x and y labels.  \n"
14889                 "        61: same as 1 except date / time x and y labels.  \n"
14890                 "        62: same as 2 except date / time x and y labels.  \n"
14891                 "        63: same as 3 except date / time x and y labels. \n"
14892                 "        70: same as 0 except custom x and y labels. \n"
14893                 "        71: same as 1 except custom x and y labels. \n"
14894                 "        72: same as 2 except custom x and y labels. \n"
14895                 "        73: same as 3 except custom x and y labels. \n"
14896                 "\n"
14897                 ""},
14898          { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
14899                 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
14900                 "\n"
14901                 "DESCRIPTION:\n"
14902                 "\n"
14903                 "    Sets up plotter environment for simple graphs by calling pladv and\n"
14904                 "    setting up viewport and window to sensible default values. plenv0\n"
14905                 "    leaves enough room around most graphs for axis labels and a title.\n"
14906                 "    When these defaults are not suitable, use the individual routines\n"
14907                 "    plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
14908                 "    defining the window, and plbox for drawing the box. \n"
14909                 "\n"
14910                 "    Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
14911                 "\n"
14912                 "    This function is used in example 21. \n"
14913                 "\n"
14914                 "\n"
14915                 "\n"
14916                 "SYNOPSIS:\n"
14917                 "\n"
14918                 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
14919                 "\n"
14920                 "ARGUMENTS:\n"
14921                 "\n"
14922                 "    xmin (PLFLT, input) :    Value of x at left-hand edge of window (in\n"
14923                 "    world coordinates). \n"
14924                 "\n"
14925                 "    xmax (PLFLT, input) :    Value of x at right-hand edge of window (in\n"
14926                 "    world coordinates). \n"
14927                 "\n"
14928                 "    ymin (PLFLT, input) :    Value of y at bottom edge of window (in world\n"
14929                 "    coordinates). \n"
14930                 "\n"
14931                 "    ymax (PLFLT, input) :    Value of y at top edge of window (in world\n"
14932                 "    coordinates). \n"
14933                 "\n"
14934                 "    just (PLINT, input) :    Controls how the axes will be scaled: -1: the\n"
14935                 "    scales will not be set, the user must set up the scale before\n"
14936                 "    calling plenv0 using plsvpa, plvasp or other. \n"
14937                 "        0: the x and y axes are scaled independently to use as much of\n"
14938                 "        the screen as possible. \n"
14939                 "        1: the scales of the x and y axes are made equal. \n"
14940                 "        2: the axis of the x and y axes are made equal, and the plot\n"
14941                 "        box will be square. \n"
14942                 "\n"
14943                 "\n"
14944                 "    axis (PLINT, input) :    Controls drawing of the box around the plot:\n"
14945                 "    -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
14946                 "        -1: draw box only. \n"
14947                 "        0: draw box, ticks, and numeric tick labels. \n"
14948                 "        1: also draw coordinate axes at x=0 and y=0. \n"
14949                 "        2: also draw a grid at major tick positions in both\n"
14950                 "        coordinates. \n"
14951                 "        3: also draw a grid at minor tick positions in both\n"
14952                 "        coordinates. \n"
14953                 "        10: same as 0 except logarithmic x tick marks. (The x data\n"
14954                 "        have to be converted to logarithms separately.) \n"
14955                 "        11: same as 1 except logarithmic x tick marks. (The x data\n"
14956                 "        have to be converted to logarithms separately.) \n"
14957                 "        12: same as 2 except logarithmic x tick marks. (The x data\n"
14958                 "        have to be converted to logarithms separately.) \n"
14959                 "        13: same as 3 except logarithmic x tick marks. (The x data\n"
14960                 "        have to be converted to logarithms separately.) \n"
14961                 "        20: same as 0 except logarithmic y tick marks. (The y data\n"
14962                 "        have to be converted to logarithms separately.) \n"
14963                 "        21: same as 1 except logarithmic y tick marks. (The y data\n"
14964                 "        have to be converted to logarithms separately.) \n"
14965                 "        22: same as 2 except logarithmic y tick marks. (The y data\n"
14966                 "        have to be converted to logarithms separately.) \n"
14967                 "        23: same as 3 except logarithmic y tick marks. (The y data\n"
14968                 "        have to be converted to logarithms separately.) \n"
14969                 "        30: same as 0 except logarithmic x and y tick marks. (The x\n"
14970                 "        and y data have to be converted to logarithms separately.) \n"
14971                 "        31: same as 1 except logarithmic x and y tick marks. (The x\n"
14972                 "        and y data have to be converted to logarithms separately.) \n"
14973                 "        32: same as 2 except logarithmic x and y tick marks. (The x\n"
14974                 "        and y data have to be converted to logarithms separately.) \n"
14975                 "        33: same as 3 except logarithmic x and y tick marks. (The x\n"
14976                 "        and y data have to be converted to logarithms separately.) \n"
14977                 "        40: same as 0 except date / time x labels.    \n"
14978                 "        41: same as 1 except date / time x labels.    \n"
14979                 "        42: same as 2 except date / time x labels.    \n"
14980                 "        43: same as 3 except date / time x labels.    \n"
14981                 "        50: same as 0 except date / time y labels.    \n"
14982                 "        51: same as 1 except date / time y labels.    \n"
14983                 "        52: same as 2 except date / time y labels. \n"
14984                 "        53: same as 3 except date / time y labels.    \n"
14985                 "        60: same as 0 except date / time x and y labels.  \n"
14986                 "        61: same as 1 except date / time x and y labels.  \n"
14987                 "        62: same as 2 except date / time x and y labels.  \n"
14988                 "        63: same as 3 except date / time x and y labels. \n"
14989                 "        70: same as 0 except custom x and y labels. \n"
14990                 "        71: same as 1 except custom x and y labels. \n"
14991                 "        72: same as 2 except custom x and y labels. \n"
14992                 "        73: same as 3 except custom x and y labels. \n"
14993                 "\n"
14994                 ""},
14995          { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
14996                 "Eject current page \n"
14997                 "\n"
14998                 "DESCRIPTION:\n"
14999                 "\n"
15000                 "    Clears the graphics screen of an interactive device, or ejects a page\n"
15001                 "    on a plotter.  See plbop for more information. \n"
15002                 "\n"
15003                 "    Redacted form: pleop()\n"
15004                 "\n"
15005                 "    This function is used in example 2,14. \n"
15006                 "\n"
15007                 "\n"
15008                 "\n"
15009                 "SYNOPSIS:\n"
15010                 "\n"
15011                 "pleop()\n"
15012                 "\n"
15013                 ""},
15014          { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15015                 "Draw x error bar \n"
15016                 "\n"
15017                 "DESCRIPTION:\n"
15018                 "\n"
15019                 "    Draws a set of n horizontal error bars, the i'th error bar extending\n"
15020                 "    from xmin[i] to xmax[i] at y coordinate y[i].  The terminals of the\n"
15021                 "    error bar are of length equal to the minor tick length (settable using\n"
15022                 "    plsmin). \n"
15023                 "\n"
15024                 "    Redacted form:  General: plerrx(xmin, ymax, y)\n"
15025                 "           Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15026                 "\n"
15027                 "\n"
15028                 "    This function is used in example 29. \n"
15029                 "\n"
15030                 "\n"
15031                 "\n"
15032                 "SYNOPSIS:\n"
15033                 "\n"
15034                 "plerrx(n, xmin, xmax, y)\n"
15035                 "\n"
15036                 "ARGUMENTS:\n"
15037                 "\n"
15038                 "    n (PLINT, input) :      Number of error bars to draw. \n"
15039                 "\n"
15040                 "    xmin (PLFLT *, input) :    Pointer to array with x coordinates of\n"
15041                 "    left-hand endpoint of error bars. \n"
15042                 "\n"
15043                 "    xmax (PLFLT *, input) :    Pointer to array with x coordinates of\n"
15044                 "    right-hand endpoint of error bars. \n"
15045                 "\n"
15046                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of error\n"
15047                 "    bar. \n"
15048                 "\n"
15049                 ""},
15050          { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15051                 "Draw y error bar \n"
15052                 "\n"
15053                 "DESCRIPTION:\n"
15054                 "\n"
15055                 "    Draws a set of n vertical error bars, the i'th error bar extending\n"
15056                 "    from ymin[i] to ymax[i] at x coordinate x[i].  The terminals of the\n"
15057                 "    error bar are of length equal to the minor tick length (settable using\n"
15058                 "    plsmin). \n"
15059                 "\n"
15060                 "    Redacted form:  General: plerry(x, ymin, ymax)\n"
15061                 "           Perl/PDL: plerry(n, x, ymin, ymax)\n"
15062                 "\n"
15063                 "\n"
15064                 "    This function is used in example 29. \n"
15065                 "\n"
15066                 "\n"
15067                 "\n"
15068                 "SYNOPSIS:\n"
15069                 "\n"
15070                 "plerry(n, x, ymin, ymax)\n"
15071                 "\n"
15072                 "ARGUMENTS:\n"
15073                 "\n"
15074                 "    n (PLINT, input) :      Number of error bars to draw. \n"
15075                 "\n"
15076                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of error\n"
15077                 "    bars. \n"
15078                 "\n"
15079                 "    ymin (PLFLT *, input) :    Pointer to array with y coordinates of\n"
15080                 "    lower endpoint of error bars. \n"
15081                 "\n"
15082                 "    ymax (PLFLT *, input) :    Pointer to array with y coordinate of upper\n"
15083                 "    endpoint of error bar. \n"
15084                 "\n"
15085                 ""},
15086          { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
15087                 "Advance to the next family file on the next new page \n"
15088                 "\n"
15089                 "DESCRIPTION:\n"
15090                 "\n"
15091                 "    Advance to the next family file on the next new page. \n"
15092                 "\n"
15093                 "    Redacted form: plfamadv()\n"
15094                 "\n"
15095                 "    This function is not used in any examples. \n"
15096                 "\n"
15097                 "\n"
15098                 "\n"
15099                 "SYNOPSIS:\n"
15100                 "\n"
15101                 "plfamadv()\n"
15102                 "\n"
15103                 ""},
15104          { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
15105                 "Draw filled polygon \n"
15106                 "\n"
15107                 "DESCRIPTION:\n"
15108                 "\n"
15109                 "    Fills the polygon defined by the n points (\n"
15110                 "    x[i], \n"
15111                 "    y[i]) using the pattern defined by plpsty or plpat.  The routine will\n"
15112                 "    automatically close the polygon between the last and first vertices. \n"
15113                 "    If multiple closed polygons are passed in x and y then plfill will\n"
15114                 "    fill in between them. \n"
15115                 "\n"
15116                 "    Redacted form: plfill(x,y)\n"
15117                 "\n"
15118                 "    This function is used in examples 12,13,15,16,21,24,25. \n"
15119                 "\n"
15120                 "\n"
15121                 "\n"
15122                 "SYNOPSIS:\n"
15123                 "\n"
15124                 "plfill(n, x, y)\n"
15125                 "\n"
15126                 "ARGUMENTS:\n"
15127                 "\n"
15128                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
15129                 "\n"
15130                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of\n"
15131                 "    vertices. \n"
15132                 "\n"
15133                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of\n"
15134                 "    vertices. \n"
15135                 "\n"
15136                 ""},
15137          { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
15138                 "Draw filled polygon in 3D \n"
15139                 "\n"
15140                 "DESCRIPTION:\n"
15141                 "\n"
15142                 "    Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15143                 "    using the pattern defined by plpsty or plpat.  The routine will\n"
15144                 "    automatically close the polygon between the last and first vertices. \n"
15145                 "    If multiple closed polygons are passed in x, y, and z then plfill3\n"
15146                 "    will fill in between them. \n"
15147                 "\n"
15148                 "    Redacted form:  General: plfill3(x, y, z)\n"
15149                 "           Perl/PDL: plfill3(n, x, y, z)\n"
15150                 "\n"
15151                 "\n"
15152                 "    This function is used in example 15. \n"
15153                 "\n"
15154                 "\n"
15155                 "\n"
15156                 "SYNOPSIS:\n"
15157                 "\n"
15158                 "plfill3(n, x, y, z)\n"
15159                 "\n"
15160                 "ARGUMENTS:\n"
15161                 "\n"
15162                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
15163                 "\n"
15164                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of\n"
15165                 "    vertices. \n"
15166                 "\n"
15167                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of\n"
15168                 "    vertices. \n"
15169                 "\n"
15170                 "    z (PLFLT *, input) :    Pointer to array with z coordinates of\n"
15171                 "    vertices. \n"
15172                 "\n"
15173                 ""},
15174          { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
15175                 "Draw linear gradient inside polygon \n"
15176                 "\n"
15177                 "DESCRIPTION:\n"
15178                 "\n"
15179                 "    Draw a linear gradient using colour map 1 inside the polygon defined\n"
15180                 "    by the n points (\n"
15181                 "    x[i], \n"
15182                 "    y[i]).  Interpretation of the polygon is the same as for plfill.  The\n"
15183                 "    polygon coordinates and the gradient angle are all expressed in world\n"
15184                 "    coordinates.  The angle from the x axis for both the rotated\n"
15185                 "    coordinate system and the gradient vector is specified by angle.  The\n"
15186                 "    magnitude of the gradient vector is the difference between the maximum\n"
15187                 "    and minimum values of x for the vertices in the rotated coordinate\n"
15188                 "    system.  The origin of the gradient vector can be interpreted as being\n"
15189                 "    anywhere on the line corresponding to the minimum x value for the\n"
15190                 "    vertices in the rotated coordinate system. The distance along the\n"
15191                 "    gradient vector is linearly transformed to the independent variable of\n"
15192                 "    colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15193                 "    to 1. at the head of the gradient vector.  What is drawn is the RGBA\n"
15194                 "    colour corresponding to the independent variable of colour map 1.  For\n"
15195                 "    more information about colour map 1 (see the PLplot documentation). \n"
15196                 "\n"
15197                 "    Redacted form: plgradient(x,y,angle)\n"
15198                 "\n"
15199                 "    This function is used in examples 25,30. \n"
15200                 "\n"
15201                 "\n"
15202                 "\n"
15203                 "SYNOPSIS:\n"
15204                 "\n"
15205                 "plgradient(n, x, y, angle)\n"
15206                 "\n"
15207                 "ARGUMENTS:\n"
15208                 "\n"
15209                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
15210                 "\n"
15211                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of\n"
15212                 "    vertices. \n"
15213                 "\n"
15214                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of\n"
15215                 "    vertices. \n"
15216                 "\n"
15217                 "    angle (PLFLT, input) :    Angle (degrees) of gradient vector from x\n"
15218                 "    axis. \n"
15219                 "\n"
15220                 ""},
15221          { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
15222                 "Flushes the output stream \n"
15223                 "\n"
15224                 "DESCRIPTION:\n"
15225                 "\n"
15226                 "    Flushes the output stream. Use sparingly, if at all. \n"
15227                 "\n"
15228                 "    Redacted form: plflush()\n"
15229                 "\n"
15230                 "    This function is used in examples 1,14. \n"
15231                 "\n"
15232                 "\n"
15233                 "\n"
15234                 "SYNOPSIS:\n"
15235                 "\n"
15236                 "plflush()\n"
15237                 "\n"
15238                 ""},
15239          { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
15240                 "Set character font \n"
15241                 "\n"
15242                 "DESCRIPTION:\n"
15243                 "\n"
15244                 "    Sets the default character font for subsequent character drawing. Also\n"
15245                 "    affects symbols produced by plpoin.  This routine has no effect unless\n"
15246                 "    the extended character set is loaded (see plfontld). \n"
15247                 "\n"
15248                 "    Redacted form: plfont(font)\n"
15249                 "\n"
15250                 "    This function is used in examples 1,2,4,7,13,24,26. \n"
15251                 "\n"
15252                 "\n"
15253                 "\n"
15254                 "SYNOPSIS:\n"
15255                 "\n"
15256                 "plfont(font)\n"
15257                 "\n"
15258                 "ARGUMENTS:\n"
15259                 "\n"
15260                 "    font (PLINT, input) :    Specifies the font: 1: Normal font (simplest\n"
15261                 "    and fastest) \n"
15262                 "        2: Roman font \n"
15263                 "        3: Italic font \n"
15264                 "        4: Script font \n"
15265                 "\n"
15266                 ""},
15267          { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
15268                 "Load character font \n"
15269                 "\n"
15270                 "DESCRIPTION:\n"
15271                 "\n"
15272                 "    Sets the character set to use for subsequent character drawing.  May\n"
15273                 "    be called before initializing PLplot. \n"
15274                 "\n"
15275                 "    Redacted form: plfontld(set)\n"
15276                 "\n"
15277                 "    This function is used in examples 1,7. \n"
15278                 "\n"
15279                 "\n"
15280                 "\n"
15281                 "SYNOPSIS:\n"
15282                 "\n"
15283                 "plfontld(set)\n"
15284                 "\n"
15285                 "ARGUMENTS:\n"
15286                 "\n"
15287                 "    set (PLINT, input) :    Specifies the character set to load: 0:\n"
15288                 "    Standard character set \n"
15289                 "        1: Extended character set \n"
15290                 "\n"
15291                 ""},
15292          { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
15293                 "Get character default height and current (scaled) height \n"
15294                 "\n"
15295                 "DESCRIPTION:\n"
15296                 "\n"
15297                 "    Get character default height and current (scaled) height. \n"
15298                 "\n"
15299                 "    Redacted form: plgchr(p_def, p_ht)\n"
15300                 "\n"
15301                 "    This function is used in example 23. \n"
15302                 "\n"
15303                 "\n"
15304                 "\n"
15305                 "SYNOPSIS:\n"
15306                 "\n"
15307                 "plgchr(p_def, p_ht)\n"
15308                 "\n"
15309                 "ARGUMENTS:\n"
15310                 "\n"
15311                 "    p_def (PLFLT *, output) :     Pointer to default character height (mm). \n"
15312                 "\n"
15313                 "    p_ht (PLFLT *, output) :    Pointer to current (scaled) character\n"
15314                 "    height (mm). \n"
15315                 "\n"
15316                 ""},
15317          { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
15318                 "Returns 8-bit RGB values for given color from color map0 \n"
15319                 "\n"
15320                 "DESCRIPTION:\n"
15321                 "\n"
15322                 "    Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
15323                 "    the PLplot documentation). Values are negative if an invalid color id\n"
15324                 "    is given. \n"
15325                 "\n"
15326                 "    Redacted form: plgcol0(icol0, r, g, b)\n"
15327                 "\n"
15328                 "    This function is used in example 2. \n"
15329                 "\n"
15330                 "\n"
15331                 "\n"
15332                 "SYNOPSIS:\n"
15333                 "\n"
15334                 "plgcol0(icol0, r, g, b)\n"
15335                 "\n"
15336                 "ARGUMENTS:\n"
15337                 "\n"
15338                 "    icol0 (PLINT, input) :    Index of desired cmap0 color. \n"
15339                 "\n"
15340                 "    r (PLINT *, output) :    Pointer to 8-bit red value. \n"
15341                 "\n"
15342                 "    g (PLINT *, output) :    Pointer to 8-bit green value. \n"
15343                 "\n"
15344                 "    b (PLINT *, output) :    Pointer to 8-bit blue value. \n"
15345                 "\n"
15346                 ""},
15347          { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
15348                 "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
15349                 "\n"
15350                 "DESCRIPTION:\n"
15351                 "\n"
15352                 "    Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
15353                 "    for  given color from color map0 (see the PLplot documentation). \n"
15354                 "    Values  are negative if an invalid color id is given. \n"
15355                 "\n"
15356                 "    This function is used in example 30. \n"
15357                 "\n"
15358                 "\n"
15359                 "\n"
15360                 "SYNOPSIS:\n"
15361                 "\n"
15362                 "plgcol0a(icol0, r, g, b, a)\n"
15363                 "\n"
15364                 "ARGUMENTS:\n"
15365                 "\n"
15366                 "    icol0 (PLINT, input) :    Index of desired cmap0 color. \n"
15367                 "\n"
15368                 "    r (PLINT *, output) :    Pointer to 8-bit red value. \n"
15369                 "\n"
15370                 "    g (PLINT *, output) :    Pointer to 8-bit green value. \n"
15371                 "\n"
15372                 "    b (PLINT *, output) :    Pointer to 8-bit blue value. \n"
15373                 "\n"
15374                 "    a (PLFLT *, output) :    Pointer to PLFLT alpha value. \n"
15375                 "\n"
15376                 ""},
15377          { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
15378                 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
15379                 "\n"
15380                 "ESCRIPTION:\n"
15381                 "\n"
15382                 "   Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
15383                 "\n"
15384                 "   Redacted form: plgcolbg(r, g, b)\n"
15385                 "\n"
15386                 "   This function is used in example 31. \n"
15387                 "\n"
15388                 "\n"
15389                 "\n"
15390                 "YNOPSIS:\n"
15391                 "\n"
15392                 "lgcolbg(r, g, b)\n"
15393                 "\n"
15394                 "RGUMENTS:\n"
15395                 "\n"
15396                 "   r (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15397                 "   representing the degree of red in the color. \n"
15398                 "\n"
15399                 "   g (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15400                 "   representing the degree of green in the color. \n"
15401                 "\n"
15402                 "   b (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15403                 "   representing the degree of blue in the color. \n"
15404                 "\n"
15405                 ""},
15406          { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
15407                 "Returns the background color (cmap0[0])  by 8-bit RGB value and double alpha value. \n"
15408                 "\n"
15409                 "ESCRIPTION:\n"
15410                 "\n"
15411                 "   Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
15412                 "   alpha value. \n"
15413                 "\n"
15414                 "   This function is used in example 31. \n"
15415                 "\n"
15416                 "\n"
15417                 "\n"
15418                 "YNOPSIS:\n"
15419                 "\n"
15420                 "lgcolbga(r, g, b, a)\n"
15421                 "\n"
15422                 "RGUMENTS:\n"
15423                 "\n"
15424                 "   r (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15425                 "   representing the degree of red in the color. \n"
15426                 "\n"
15427                 "   g (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15428                 "   representing the degree of green in the color. \n"
15429                 "\n"
15430                 "   b (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
15431                 "   representing the degree of blue in the color. \n"
15432                 "\n"
15433                 "   a (PLFLT *, output) :    Pointer to PLFLT alpha value. \n"
15434                 "\n"
15435                 ""},
15436          { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
15437                 "Get the current device-compression setting \n"
15438                 "\n"
15439                 "DESCRIPTION:\n"
15440                 "\n"
15441                 "    Get the current device-compression setting.  This parameter is only\n"
15442                 "    used for drivers that provide compression. \n"
15443                 "\n"
15444                 "    Redacted form: plgcompression(compression)\n"
15445                 "\n"
15446                 "    This function is used in example 31. \n"
15447                 "\n"
15448                 "\n"
15449                 "\n"
15450                 "SYNOPSIS:\n"
15451                 "\n"
15452                 "plgcompression(compression)\n"
15453                 "\n"
15454                 "ARGUMENTS:\n"
15455                 "\n"
15456                 "    compression (PLINT *, output) :    Pointer to a variable to be filled\n"
15457                 "    with the current device-compression setting. \n"
15458                 "\n"
15459                 ""},
15460          { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
15461                 "Get the current device (keyword) name \n"
15462                 "\n"
15463                 "DESCRIPTION:\n"
15464                 "\n"
15465                 "    Get the current device (keyword) name.  Note: you must have allocated\n"
15466                 "    space for this (80 characters is safe). \n"
15467                 "\n"
15468                 "    Redacted form: plgdev(p_dev)\n"
15469                 "\n"
15470                 "    This function is used in example 14. \n"
15471                 "\n"
15472                 "\n"
15473                 "\n"
15474                 "SYNOPSIS:\n"
15475                 "\n"
15476                 "plgdev(p_dev)\n"
15477                 "\n"
15478                 "ARGUMENTS:\n"
15479                 "\n"
15480                 "    p_dev (char *, output) :    Pointer to device (keyword) name string. \n"
15481                 "\n"
15482                 ""},
15483          { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
15484                 "Get parameters that define current device-space window \n"
15485                 "\n"
15486                 "DESCRIPTION:\n"
15487                 "\n"
15488                 "    Get relative margin width, aspect ratio, and relative justification\n"
15489                 "    that define current device-space window. If plsdidev has not been\n"
15490                 "    called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
15491                 "    p_jy will all be 0. \n"
15492                 "\n"
15493                 "    Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
15494                 "\n"
15495                 "    This function is used in example 31. \n"
15496                 "\n"
15497                 "\n"
15498                 "\n"
15499                 "SYNOPSIS:\n"
15500                 "\n"
15501                 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
15502                 "\n"
15503                 "ARGUMENTS:\n"
15504                 "\n"
15505                 "    p_mar (PLFLT *, output) :     Pointer to relative margin width. \n"
15506                 "\n"
15507                 "    p_aspect (PLFLT *, output) :    Pointer to aspect ratio. \n"
15508                 "\n"
15509                 "    p_jx (PLFLT *, output) :    Pointer to relative justification in x. \n"
15510                 "\n"
15511                 "    p_jy (PLFLT *, output) :    Pointer to relative justification in y. \n"
15512                 "\n"
15513                 ""},
15514          { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
15515                 "Get plot orientation \n"
15516                 "\n"
15517                 "DESCRIPTION:\n"
15518                 "\n"
15519                 "    Get plot orientation parameter which is multiplied by 90 degrees to\n"
15520                 "    obtain the angle of rotation.  Note, arbitrary rotation parameters\n"
15521                 "    such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
15522                 "    values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
15523                 "    to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
15524                 "    (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
15525                 "    not been called the default value pointed to by p_rot will be 0. \n"
15526                 "\n"
15527                 "    Redacted form: plgdiori(p_rot)\n"
15528                 "\n"
15529                 "    This function is not used in any examples. \n"
15530                 "\n"
15531                 "\n"
15532                 "\n"
15533                 "SYNOPSIS:\n"
15534                 "\n"
15535                 "plgdiori(p_rot)\n"
15536                 "\n"
15537                 "ARGUMENTS:\n"
15538                 "\n"
15539                 "    p_rot (PLFLT *, output) :     Pointer to orientation parameter. \n"
15540                 "\n"
15541                 ""},
15542          { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
15543                 "Get parameters that define current plot-space window \n"
15544                 "\n"
15545                 "DESCRIPTION:\n"
15546                 "\n"
15547                 "    Get relative minima and maxima that define current plot-space window.\n"
15548                 "    If plsdiplt has not been called the default values pointed to by\n"
15549                 "    p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
15550                 "\n"
15551                 "    Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
15552                 "\n"
15553                 "    This function is used in example 31. \n"
15554                 "\n"
15555                 "\n"
15556                 "\n"
15557                 "SYNOPSIS:\n"
15558                 "\n"
15559                 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
15560                 "\n"
15561                 "ARGUMENTS:\n"
15562                 "\n"
15563                 "    p_xmin (PLFLT *, output) :      Pointer to relative minimum in x. \n"
15564                 "\n"
15565                 "    p_ymin (PLFLT *, output) :      Pointer to relative minimum in y. \n"
15566                 "\n"
15567                 "    p_xmax (PLFLT *, output) :      Pointer to relative maximum in x. \n"
15568                 "\n"
15569                 "    p_ymax (PLFLT *, output) :      Pointer to relative maximum in y. \n"
15570                 "\n"
15571                 ""},
15572          { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
15573                 "Get family file parameters \n"
15574                 "\n"
15575                 "DESCRIPTION:\n"
15576                 "\n"
15577                 "    Gets information about current family file, if familying is enabled. \n"
15578                 "    See the PLplot documentation for more information. \n"
15579                 "\n"
15580                 "    Redacted form: plgfam(fam, num, bmax)\n"
15581                 "\n"
15582                 "    This function is used in examples 14,31. \n"
15583                 "\n"
15584                 "\n"
15585                 "\n"
15586                 "SYNOPSIS:\n"
15587                 "\n"
15588                 "plgfam(fam, num, bmax)\n"
15589                 "\n"
15590                 "ARGUMENTS:\n"
15591                 "\n"
15592                 "    fam (PLINT *, output) :    Pointer to variable with the Boolean family\n"
15593                 "    flag value.  If nonzero, familying is enabled. \n"
15594                 "\n"
15595                 "    num (PLINT *, output) :    Pointer to variable with the current family\n"
15596                 "    file number. \n"
15597                 "\n"
15598                 "    bmax (PLINT *, output) :    Pointer to variable with the maximum file\n"
15599                 "    size (in bytes) for a family file. \n"
15600                 "\n"
15601                 ""},
15602          { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
15603                 "Get FCI (font characterization integer) \n"
15604                 "\n"
15605                 "DESCRIPTION:\n"
15606                 "\n"
15607                 "    Gets information about the current font using the FCI approach. See\n"
15608                 "    the PLplot documentation for more information. \n"
15609                 "\n"
15610                 "    Redacted form: plgfci(fci)\n"
15611                 "\n"
15612                 "    This function is used in example 23. \n"
15613                 "\n"
15614                 "\n"
15615                 "\n"
15616                 "SYNOPSIS:\n"
15617                 "\n"
15618                 "plgfci(fci)\n"
15619                 "\n"
15620                 "ARGUMENTS:\n"
15621                 "\n"
15622                 "    fci (PLUNICODE *, output) :    Pointer to PLUNICODE (unsigned 32-bit\n"
15623                 "    integer) variable which is updated with current FCI value. \n"
15624                 "\n"
15625                 ""},
15626          { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
15627                 "Get output file name \n"
15628                 "\n"
15629                 "DESCRIPTION:\n"
15630                 "\n"
15631                 "    Gets the current output file name, if applicable. \n"
15632                 "\n"
15633                 "    Redacted form: plgfnam(fnam)\n"
15634                 "\n"
15635                 "    This function is used in example 31. \n"
15636                 "\n"
15637                 "\n"
15638                 "\n"
15639                 "SYNOPSIS:\n"
15640                 "\n"
15641                 "plgfnam(fnam)\n"
15642                 "\n"
15643                 "ARGUMENTS:\n"
15644                 "\n"
15645                 "    fnam (char *, output) :    Pointer to file name string (a preallocated\n"
15646                 "    string of 80 characters or more). \n"
15647                 "\n"
15648                 ""},
15649          { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
15650                 "Get family, style and weight of the current font \n"
15651                 "\n"
15652                 "DESCRIPTION:\n"
15653                 "\n"
15654                 "    Gets information about current font.  See the PLplot documentation for\n"
15655                 "    more information on font selection. \n"
15656                 "\n"
15657                 "    Redacted form: plgfont(p_family, p_style, p_weight)\n"
15658                 "\n"
15659                 "    This function is used in example 23. \n"
15660                 "\n"
15661                 "\n"
15662                 "\n"
15663                 "SYNOPSIS:\n"
15664                 "\n"
15665                 "plgfont(p_family, p_style, p_weight)\n"
15666                 "\n"
15667                 "ARGUMENTS:\n"
15668                 "\n"
15669                 "    p_family (PLINT *, output) :    Pointer to variable with the current\n"
15670                 "    font family. The available values are given by the PL_FCI_*\n"
15671                 "    constants in plplot.h. Current options are PL_FCI_SANS,\n"
15672                 "    PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
15673                 "    p_family is NULL then the font family is not returned. \n"
15674                 "\n"
15675                 "    p_style (PLINT *, output) :    Pointer to variable with the current\n"
15676                 "    font style. The available values are given by the PL_FCI_*\n"
15677                 "    constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
15678                 "    PL_FCI_ITALIC  and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
15679                 "    font style is not returned. \n"
15680                 "\n"
15681                 "    p_weight (PLINT *, output) :    Pointer to variable with the current\n"
15682                 "    font weight. The available values are given by the PL_FCI_*\n"
15683                 "    constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
15684                 "    PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
15685                 "    returned. \n"
15686                 "\n"
15687                 ""},
15688          { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
15689                 "Get the (current) run level \n"
15690                 "\n"
15691                 "DESCRIPTION:\n"
15692                 "\n"
15693                 "    Get the (current) run level. Valid settings are: 0,  uninitialized \n"
15694                 "           1,  initialized \n"
15695                 "           2,  viewport defined \n"
15696                 "           3,  world coordinates defined \n"
15697                 "\n"
15698                 "\n"
15699                 "    Redacted form: plglevel(p_level)\n"
15700                 "\n"
15701                 "    This function is used in example 31. \n"
15702                 "\n"
15703                 "\n"
15704                 "\n"
15705                 "SYNOPSIS:\n"
15706                 "\n"
15707                 "plglevel(p_level)\n"
15708                 "\n"
15709                 "ARGUMENTS:\n"
15710                 "\n"
15711                 "    p_level (PLINT *, output) :    Pointer to the run level. \n"
15712                 "\n"
15713                 ""},
15714          { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
15715                 "Get page parameters \n"
15716                 "\n"
15717                 "DESCRIPTION:\n"
15718                 "\n"
15719                 "    Gets the current page configuration. The length and offset values are\n"
15720                 "    expressed in units that are specific to the current driver. For\n"
15721                 "    instance: screen drivers will usually interpret them as number of\n"
15722                 "    pixels, whereas printer drivers will usually use mm. \n"
15723                 "\n"
15724                 "    Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
15725                 "\n"
15726                 "    This function is used in example 31. \n"
15727                 "\n"
15728                 "\n"
15729                 "\n"
15730                 "SYNOPSIS:\n"
15731                 "\n"
15732                 "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
15733                 "\n"
15734                 "ARGUMENTS:\n"
15735                 "\n"
15736                 "    xp (PLFLT *, output) :    Pointer to number of pixels/inch (DPI), x. \n"
15737                 "\n"
15738                 "    yp (PLFLT *, output) :    Pointer to number of pixels/inch (DPI) in y. \n"
15739                 "\n"
15740                 "    xleng (PLINT *, output) :     Pointer to x page length value. \n"
15741                 "\n"
15742                 "    yleng (PLINT *, output) :     Pointer to y page length value. \n"
15743                 "\n"
15744                 "    xoff (PLINT *, output) :    Pointer to x page offset. \n"
15745                 "\n"
15746                 "    yoff (PLINT *, output) :    Pointer to y page offset. \n"
15747                 "\n"
15748                 ""},
15749          { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
15750                 "Switch to graphics screen \n"
15751                 "\n"
15752                 "DESCRIPTION:\n"
15753                 "\n"
15754                 "    Sets an interactive device to graphics mode, used in conjunction with\n"
15755                 "    pltext to allow graphics and text to be interspersed.  On a device\n"
15756                 "    which supports separate text and graphics windows, this command causes\n"
15757                 "    control to be switched to the graphics window.  If already in graphics\n"
15758                 "    mode, this command is ignored.  It is also ignored on devices which\n"
15759                 "    only support a single window or use a different method for shifting\n"
15760                 "    focus.  See also pltext. \n"
15761                 "\n"
15762                 "    Redacted form: plgra()\n"
15763                 "\n"
15764                 "    This function is used in example 1. \n"
15765                 "\n"
15766                 "\n"
15767                 "\n"
15768                 "SYNOPSIS:\n"
15769                 "\n"
15770                 "plgra()\n"
15771                 "\n"
15772                 ""},
15773          { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
15774                 "Grid data from irregularly sampled data \n"
15775                 "\n"
15776                 "DESCRIPTION:\n"
15777                 "\n"
15778                 "    Real world data is frequently irregularly sampled, but all PLplot 3D\n"
15779                 "    plots require data placed in a uniform grid. This function takes\n"
15780                 "    irregularly sampled data from three input arrays x[npts], y[npts], and\n"
15781                 "    z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
15782                 "    and yg[nptsy], and returns the gridded data into output array\n"
15783                 "    zg[nptsx][nptsy].  The algorithm used to grid the data is specified\n"
15784                 "    with the argument type which can have one parameter specified in\n"
15785                 "    argument data. \n"
15786                 "\n"
15787                 "    Redacted form:  General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
15788                 "           Perl/PDL: Not available? \n"
15789                 "\n"
15790                 "\n"
15791                 "    This function is used in example 21. \n"
15792                 "\n"
15793                 "\n"
15794                 "\n"
15795                 "SYNOPSIS:\n"
15796                 "\n"
15797                 "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
15798                 "\n"
15799                 "ARGUMENTS:\n"
15800                 "\n"
15801                 "    x (PLFLT *, input) :    The input x array. \n"
15802                 "\n"
15803                 "    y (PLFLT *, input) :    The input y array. \n"
15804                 "\n"
15805                 "    z (PLFLT *, input) :    The input z array. Each triple x[i], y[i],\n"
15806                 "    z[i] represents one data sample coordinate. \n"
15807                 "\n"
15808                 "    npts (PLINT, input) :    The number of data samples in the x, y and z\n"
15809                 "    arrays. \n"
15810                 "\n"
15811                 "    xg (PLFLT *, input) :    The input array that specifies the grid\n"
15812                 "    spacing in the x direction. Usually xg has nptsx equally spaced\n"
15813                 "    values from the minimum to the maximum values of the x input\n"
15814                 "    array. \n"
15815                 "\n"
15816                 "    nptsx (PLINT, input) :    The number of points in the xg array. \n"
15817                 "\n"
15818                 "    yg (PLFLT *, input) :    The input array that specifies the grid\n"
15819                 "    spacing in the y direction. Similar to the xg parameter. \n"
15820                 "\n"
15821                 "    nptsy (PLINT, input) :    The number of points in the yg array. \n"
15822                 "\n"
15823                 "    zg (PLFLT **, output) :    The output array, where data lies in the\n"
15824                 "    regular grid specified by xg and yg. the zg array must exist or be\n"
15825                 "    allocated by the user prior to the call, and must have dimension\n"
15826                 "    zg[nptsx][nptsy]. \n"
15827                 "\n"
15828                 "    type (PLINT, input) :    The type of gridding algorithm to use, which\n"
15829                 "    can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
15830                 "        GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
15831                 "        GRID_NNI: Natural Neighbors Interpolation \n"
15832                 "        GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
15833                 "        GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
15834                 "        GRID_NNAIDW:  Nearest Neighbors Around Inverse Distance\n"
15835                 "        Weighted \n"
15836                 "    For details of the algorithms read the source file plgridd.c. \n"
15837                 "\n"
15838                 "    data (PLFLT, input) :    Some gridding algorithms require extra data,\n"
15839                 "    which can be specified through this argument. Currently, for\n"
15840                 "    algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
15841                 "    use, the lower the value, the noisier (more local) the\n"
15842                 "    approximation is. \n"
15843                 "        GRID_NNLI, data specifies what a thin triangle is, in the\n"
15844                 "        range [1. .. 2.]. High values enable the usage of very thin\n"
15845                 "        triangles for interpolation, possibly resulting in error in\n"
15846                 "        the approximation. \n"
15847                 "        GRID_NNI, only weights greater than data will be accepted. If\n"
15848                 "        0, all weights will be accepted. \n"
15849                 "\n"
15850                 ""},
15851          { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
15852                 "Get current subpage parameters \n"
15853                 "\n"
15854                 "DESCRIPTION:\n"
15855                 "\n"
15856                 "    Gets the size of the current subpage in millimeters measured from the\n"
15857                 "    bottom left hand corner of the output device page or screen.  Can be\n"
15858                 "    used in conjunction with plsvpa for setting the size of a viewport in\n"
15859                 "    absolute coordinates (millimeters). \n"
15860                 "\n"
15861                 "    Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
15862                 "\n"
15863                 "    This function is used in example 23. \n"
15864                 "\n"
15865                 "\n"
15866                 "\n"
15867                 "SYNOPSIS:\n"
15868                 "\n"
15869                 "plgspa(xmin, xmax, ymin, ymax)\n"
15870                 "\n"
15871                 "ARGUMENTS:\n"
15872                 "\n"
15873                 "    xmin (PLFLT *, output) :    Pointer to variable with position of left\n"
15874                 "    hand edge of subpage in millimeters. \n"
15875                 "\n"
15876                 "    xmax (PLFLT *, output) :    Pointer to variable with position of right\n"
15877                 "    hand edge of subpage in millimeters. \n"
15878                 "\n"
15879                 "    ymin (PLFLT *, output) :    Pointer to variable with position of\n"
15880                 "    bottom edge of subpage in millimeters. \n"
15881                 "\n"
15882                 "    ymax (PLFLT *, output) :    Pointer to variable with position of top\n"
15883                 "    edge of subpage in millimeters. \n"
15884                 "\n"
15885                 ""},
15886          { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
15887                 "Get current stream number \n"
15888                 "\n"
15889                 "DESCRIPTION:\n"
15890                 "\n"
15891                 "    Gets the number of the current output stream. See also plsstrm. \n"
15892                 "\n"
15893                 "    Redacted form: plgstrm(strm)\n"
15894                 "\n"
15895                 "    This function is used in example 1,20. \n"
15896                 "\n"
15897                 "\n"
15898                 "\n"
15899                 "SYNOPSIS:\n"
15900                 "\n"
15901                 "plgstrm(strm)\n"
15902                 "\n"
15903                 "ARGUMENTS:\n"
15904                 "\n"
15905                 "    strm (PLINT *, output) :    Pointer to current stream value. \n"
15906                 "\n"
15907                 ""},
15908          { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
15909                 "Get the current library version number \n"
15910                 "\n"
15911                 "DESCRIPTION:\n"
15912                 "\n"
15913                 "    Get the current library version number.  Note: you must have allocated\n"
15914                 "    space for this (80 characters is safe). \n"
15915                 "\n"
15916                 "    Redacted form: plgver(p_ver)\n"
15917                 "\n"
15918                 "    This function is used in example 1. \n"
15919                 "\n"
15920                 "\n"
15921                 "\n"
15922                 "SYNOPSIS:\n"
15923                 "\n"
15924                 "plgver(p_ver)\n"
15925                 "\n"
15926                 "ARGUMENTS:\n"
15927                 "\n"
15928                 "    p_ver (char *, output) :    Pointer to the current library version\n"
15929                 "    number. \n"
15930                 "\n"
15931                 ""},
15932          { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
15933                 "Get viewport limits in normalized device coordinates \n"
15934                 "\n"
15935                 "DESCRIPTION:\n"
15936                 "\n"
15937                 "    Get viewport limits in normalized device coordinates. \n"
15938                 "\n"
15939                 "    Redacted form:  General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15940                 "           Perl/PDL: Not available? \n"
15941                 "\n"
15942                 "\n"
15943                 "    This function is used in example 31. \n"
15944                 "\n"
15945                 "\n"
15946                 "\n"
15947                 "SYNOPSIS:\n"
15948                 "\n"
15949                 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15950                 "\n"
15951                 "ARGUMENTS:\n"
15952                 "\n"
15953                 "    p_xmin (PLFLT *, output) :      Lower viewport limit of the normalized\n"
15954                 "    device coordinate in x. \n"
15955                 "\n"
15956                 "    p_xmax (PLFLT *, output) :      Upper viewport limit of the normalized\n"
15957                 "    device coordinate in x. \n"
15958                 "\n"
15959                 "    p_ymin (PLFLT *, output) :      Lower viewport limit of the normalized\n"
15960                 "    device coordinate in y. \n"
15961                 "\n"
15962                 "    p_ymax (PLFLT *, output) :      Upper viewport limit of the normalized\n"
15963                 "    device coordinate in y. \n"
15964                 "\n"
15965                 ""},
15966          { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
15967                 "Get viewport limits in world coordinates \n"
15968                 "\n"
15969                 "DESCRIPTION:\n"
15970                 "\n"
15971                 "    Get viewport limits in world coordinates. \n"
15972                 "\n"
15973                 "    Redacted form:  General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15974                 "           Perl/PDL: Not available? \n"
15975                 "\n"
15976                 "\n"
15977                 "    This function is used in example 31. \n"
15978                 "\n"
15979                 "\n"
15980                 "\n"
15981                 "SYNOPSIS:\n"
15982                 "\n"
15983                 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
15984                 "\n"
15985                 "ARGUMENTS:\n"
15986                 "\n"
15987                 "    p_xmin (PLFLT *, output) :      Lower viewport limit of the world\n"
15988                 "    coordinate in x. \n"
15989                 "\n"
15990                 "    p_xmax (PLFLT *, output) :      Upper viewport limit of the world\n"
15991                 "    coordinate in x. \n"
15992                 "\n"
15993                 "    p_ymin (PLFLT *, output) :      Lower viewport limit of the world\n"
15994                 "    coordinate in y. \n"
15995                 "\n"
15996                 "    p_ymax (PLFLT *, output) :      Upper viewport limit of the world\n"
15997                 "    coordinate in y. \n"
15998                 "\n"
15999                 ""},
16000          { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16001                 "Get x axis parameters \n"
16002                 "\n"
16003                 "DESCRIPTION:\n"
16004                 "\n"
16005                 "    Returns current values of the digmax and digits flags for the x axis. \n"
16006                 "    digits is updated after the plot is drawn, so this routine should only\n"
16007                 "    be called after the call to plbox (or plbox3) is complete. See the\n"
16008                 "    PLplot documentation for more information. \n"
16009                 "\n"
16010                 "    Redacted form: plgxax(digmax, digits)\n"
16011                 "\n"
16012                 "    This function is used in example 31. \n"
16013                 "\n"
16014                 "\n"
16015                 "\n"
16016                 "SYNOPSIS:\n"
16017                 "\n"
16018                 "plgxax(digmax, digits)\n"
16019                 "\n"
16020                 "ARGUMENTS:\n"
16021                 "\n"
16022                 "    digmax (PLINT *, output) :      Pointer to variable with the maximum\n"
16023                 "    number of digits for the x axis.  If nonzero, the printed label\n"
16024                 "    has been switched to a floating point representation when the\n"
16025                 "    number of digits exceeds digmax. \n"
16026                 "\n"
16027                 "    digits (PLINT *, output) :      Pointer to variable with the actual\n"
16028                 "    number of digits for the numeric labels (x axis) from the last\n"
16029                 "    plot. \n"
16030                 "\n"
16031                 ""},
16032          { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16033                 "Get y axis parameters \n"
16034                 "\n"
16035                 "DESCRIPTION:\n"
16036                 "\n"
16037                 "    Identical to plgxax, except that arguments are flags for y axis. See\n"
16038                 "    the description of plgxax for more detail. \n"
16039                 "\n"
16040                 "    Redacted form: plgyax(digmax, digits)\n"
16041                 "\n"
16042                 "    This function is used in example 31. \n"
16043                 "\n"
16044                 "\n"
16045                 "\n"
16046                 "SYNOPSIS:\n"
16047                 "\n"
16048                 "plgyax(digmax, digits)\n"
16049                 "\n"
16050                 "ARGUMENTS:\n"
16051                 "\n"
16052                 "    digmax (PLINT *, output) :      Pointer to variable with the maximum\n"
16053                 "    number of digits for the y axis.  If nonzero, the printed label\n"
16054                 "    has been switched to a floating point representation when the\n"
16055                 "    number of digits exceeds digmax. \n"
16056                 "\n"
16057                 "    digits (PLINT *, output) :      Pointer to variable with the actual\n"
16058                 "    number of digits for the numeric labels (y axis) from the last\n"
16059                 "    plot. \n"
16060                 "\n"
16061                 ""},
16062          { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16063                 "Get z axis parameters \n"
16064                 "\n"
16065                 "DESCRIPTION:\n"
16066                 "\n"
16067                 "    Identical to plgxax, except that arguments are flags for z axis. See\n"
16068                 "    the description of plgxax for more detail. \n"
16069                 "\n"
16070                 "    Redacted form: plgzax(digmax, digits)\n"
16071                 "\n"
16072                 "    This function is used in example 31. \n"
16073                 "\n"
16074                 "\n"
16075                 "\n"
16076                 "SYNOPSIS:\n"
16077                 "\n"
16078                 "plgzax(digmax, digits)\n"
16079                 "\n"
16080                 "ARGUMENTS:\n"
16081                 "\n"
16082                 "    digmax (PLINT *, output) :      Pointer to variable with the maximum\n"
16083                 "    number of digits for the z axis.  If nonzero, the printed label\n"
16084                 "    has been switched to a floating point representation when the\n"
16085                 "    number of digits exceeds digmax. \n"
16086                 "\n"
16087                 "    digits (PLINT *, output) :      Pointer to variable with the actual\n"
16088                 "    number of digits for the numeric labels (z axis) from the last\n"
16089                 "    plot. \n"
16090                 "\n"
16091                 ""},
16092          { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
16093                 "Plot a histogram from unbinned data \n"
16094                 "\n"
16095                 "DESCRIPTION:\n"
16096                 "\n"
16097                 "    Plots a histogram from n data points stored in the array data.  This\n"
16098                 "    routine bins the data into nbin bins equally spaced between datmin and\n"
16099                 "    datmax, and calls plbin to draw the resulting histogram.  Parameter\n"
16100                 "    opt allows, among other things, the histogram either to be plotted in\n"
16101                 "    an existing window or causes plhist to call plenv with suitable limits\n"
16102                 "    before plotting the histogram. \n"
16103                 "\n"
16104                 "    Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16105                 "\n"
16106                 "    This function is used in example 5. \n"
16107                 "\n"
16108                 "\n"
16109                 "\n"
16110                 "SYNOPSIS:\n"
16111                 "\n"
16112                 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16113                 "\n"
16114                 "ARGUMENTS:\n"
16115                 "\n"
16116                 "    n (PLINT, input) :      Number of data points. \n"
16117                 "\n"
16118                 "    data (PLFLT *, input) :    Pointer to array with values of the n data\n"
16119                 "    points. \n"
16120                 "\n"
16121                 "    datmin (PLFLT, input) :    Left-hand edge of lowest-valued bin. \n"
16122                 "\n"
16123                 "    datmax (PLFLT, input) :    Right-hand edge of highest-valued bin. \n"
16124                 "\n"
16125                 "    nbin (PLINT, input) :    Number of (equal-sized) bins into which to\n"
16126                 "    divide the interval xmin to xmax. \n"
16127                 "\n"
16128                 "    opt (PLINT, input) :    Is a combination of several flags:\n"
16129                 "    opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16130                 "    the histogram data, the outer bins are expanded to fill up the\n"
16131                 "    entire x-axis, data outside the given extremes are assigned to the\n"
16132                 "    outer bins and bins of zero height are simply drawn. \n"
16133                 "        opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16134                 "        to fit the histogram data, without this flag, plenv is called\n"
16135                 "        to set the world coordinates. \n"
16136                 "        opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16137                 "        extremes are not taken into account. This option should\n"
16138                 "        probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16139                 "        properly present the data. \n"
16140                 "        opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16141                 "        size as the ones inside. \n"
16142                 "        opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16143                 "        (there is a gap for such bins). \n"
16144                 "\n"
16145                 ""},
16146          { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
16147                 "Convert HLS color to RGB \n"
16148                 "\n"
16149                 "DESCRIPTION:\n"
16150                 "\n"
16151                 "    Convert HLS color coordinates to RGB. \n"
16152                 "\n"
16153                 "    Redacted form:  General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16154                 "           Perl/PDL: Not available? Implemented as plhls? \n"
16155                 "\n"
16156                 "\n"
16157                 "    This function is used in example 2. \n"
16158                 "\n"
16159                 "\n"
16160                 "\n"
16161                 "SYNOPSIS:\n"
16162                 "\n"
16163                 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16164                 "\n"
16165                 "ARGUMENTS:\n"
16166                 "\n"
16167                 "    h (PLFLT, input) :      Hue, in degrees on the colour cone (0.0-360.0) \n"
16168                 "\n"
16169                 "    l (PLFLT, input) :      Lightness, expressed as a fraction of the axis\n"
16170                 "    of the colour cone (0.0-1.0) \n"
16171                 "\n"
16172                 "    s (PLFLT, input) :      Saturation, expressed as a fraction of the\n"
16173                 "    radius of the colour cone (0.0-1.0) \n"
16174                 "\n"
16175                 "    p_r (PLFLT *, output) :    Pointer to red intensity (0.0-1.0) of the\n"
16176                 "    colour \n"
16177                 "\n"
16178                 "    p_g (PLFLT *, output) :    Pointer to green intensity (0.0-1.0) of the\n"
16179                 "    colour \n"
16180                 "\n"
16181                 "    p_b (PLFLT *, output) :    Pointer to blue intensity (0.0-1.0) of the\n"
16182                 "    colour \n"
16183                 "\n"
16184                 ""},
16185          { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
16186                 "Initialize PLplot \n"
16187                 "\n"
16188                 "DESCRIPTION:\n"
16189                 "\n"
16190                 "    Initializing the plotting package. The program prompts for the device\n"
16191                 "    keyword or number of the desired output device.  Hitting a RETURN in\n"
16192                 "    response to the prompt is the same as selecting the first device. \n"
16193                 "    plinit will issue no prompt if either the device was specified\n"
16194                 "    previously (via command line flag, the plsetopt function, or the\n"
16195                 "    plsdev function), or if only one device is enabled when PLplot is\n"
16196                 "    installed. If subpages have been specified, the output device is\n"
16197                 "    divided into nx by ny subpages, each of which may be used\n"
16198                 "    independently.  If plinit is called again during a program, the\n"
16199                 "    previously opened file will be closed.  The subroutine pladv is used\n"
16200                 "    to advance from one subpage to the next. \n"
16201                 "\n"
16202                 "    Redacted form: plinit()\n"
16203                 "\n"
16204                 "    This function is used in all of the examples. \n"
16205                 "\n"
16206                 "\n"
16207                 "\n"
16208                 "SYNOPSIS:\n"
16209                 "\n"
16210                 "plinit()\n"
16211                 "\n"
16212                 ""},
16213          { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
16214                 "Draw a line between two points \n"
16215                 "\n"
16216                 "DESCRIPTION:\n"
16217                 "\n"
16218                 "    Joins the point (\n"
16219                 "    x1, \n"
16220                 "    y1) to (\n"
16221                 "    x2, \n"
16222                 "    y2). \n"
16223                 "\n"
16224                 "    Redacted form: pljoin(x1,y1,x2,y2)\n"
16225                 "\n"
16226                 "    This function is used in examples 3,14. \n"
16227                 "\n"
16228                 "\n"
16229                 "\n"
16230                 "SYNOPSIS:\n"
16231                 "\n"
16232                 "pljoin(x1, y1, x2, y2)\n"
16233                 "\n"
16234                 "ARGUMENTS:\n"
16235                 "\n"
16236                 "    x1 (PLFLT, input) :    x coordinate of first point. \n"
16237                 "\n"
16238                 "    y1 (PLFLT, input) :    y coordinate of first point. \n"
16239                 "\n"
16240                 "    x2 (PLFLT, input) :    x coordinate of second point. \n"
16241                 "\n"
16242                 "    y2 (PLFLT, input) :    y coordinate of second point. \n"
16243                 "\n"
16244                 ""},
16245          { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
16246                 "Simple routine to write labels \n"
16247                 "\n"
16248                 "DESCRIPTION:\n"
16249                 "\n"
16250                 "    Routine for writing simple labels. Use plmtex for more complex labels. \n"
16251                 "\n"
16252                 "    Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16253                 "\n"
16254                 "    This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16255                 "\n"
16256                 "\n"
16257                 "\n"
16258                 "SYNOPSIS:\n"
16259                 "\n"
16260                 "pllab(xlabel, ylabel, tlabel)\n"
16261                 "\n"
16262                 "ARGUMENTS:\n"
16263                 "\n"
16264                 "    xlabel (const char *, input) :    Label for horizontal axis. \n"
16265                 "\n"
16266                 "    ylabel (const char *, input) :    Label for vertical axis. \n"
16267                 "\n"
16268                 "    tlabel (const char *, input) :    Title of graph. \n"
16269                 "\n"
16270                 ""},
16271          { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
16272                 "Create a discrete annotated legend using boxes, lines, and/or lines of symbols \n"
16273                 "\n"
16274                 "DESCRIPTION:\n"
16275                 "\n"
16276                 "    (N.B. This is an experimental API that may be subject to further\n"
16277                 "    change as we gain more experience with it.)  Routine for creating a\n"
16278                 "    discrete plot legend with a plotted box, line, and/or line of symbols\n"
16279                 "    for each annotated legend entry.  The arguments of pllegend provide\n"
16280                 "    control over the location and size of the legend within the current\n"
16281                 "    subpage as well as the location and characteristics of the elements\n"
16282                 "    (most of which are optional) within that legend.  The resulting legend\n"
16283                 "    is clipped at the boundaries of the current subpage \n"
16284                 "\n"
16285                 "    Redacted form: pllegend(opt, x, y, plot_width, bg_color, opt_array,\n"
16286                 "    text_offset, text_scale, text_spacing, test_justification,\n"
16287                 "    text_colors, text, box_colors, box_patterns, box_scales, line_colors,\n"
16288                 "    line_styles, line_widths, symbol_colors, symbol_scales,\n"
16289                 "    symbol_numbers, symbols)\n"
16290                 "\n"
16291                 "    This function is used in examples 4 and 26. \n"
16292                 "\n"
16293                 "\n"
16294                 "\n"
16295                 "SYNOPSIS:\n"
16296                 "\n"
16297                 "pllegend(opt, x, y, plot_width, bg_color, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
16298                 "\n"
16299                 "ARGUMENTS:\n"
16300                 "\n"
16301                 "    opt (PLINT, input) :    opt contains bits controlling the overall\n"
16302                 "    legend.  If the \n"
16303                 "    PL_LEGEND_BACKGROUND bit is set, plot a (semi-transparent) background\n"
16304                 "    for the legend.  If the \n"
16305                 "    PL_LEGEND_TEXT_LEFT bit is set, put the text area on the left of the\n"
16306                 "    legend and the plotted area on the right. Otherwise, put the text\n"
16307                 "    area on the right of the legend and the plotted area on the left. \n"
16308                 "\n"
16309                 "    x (PLFLT, input) :      Normalized sub-page X position of the upper-left\n"
16310                 "    corner of the legend. \n"
16311                 "\n"
16312                 "    y (PLFLT, input) :      Normalized sub-page Y position of the upper-left\n"
16313                 "    corner of the legend. \n"
16314                 "\n"
16315                 "    plot_width (PLFLT, input) :    Horizontal width in normalized subpage\n"
16316                 "    units of the plot area (where the rectangular boxes, lines, and/or\n"
16317                 "    lines of symbols are drawn) of the legend.  N.B.  The total\n"
16318                 "    horizontal width of the legend in normalized subpage coordinates\n"
16319                 "    is calculated internally from \n"
16320                 "    plot_width, \n"
16321                 "    text_offset (see below), and length (calculated internally) of the\n"
16322                 "    longest text string. \n"
16323                 "\n"
16324                 "    bg_color (PLINT, input) :     The cmap0 index of the background color\n"
16325                 "    for the legend (\n"
16326                 "    PL_LEGEND_BACKGROUND). \n"
16327                 "\n"
16328                 "    nlegend (PLINT, input) :    Number of legend entries.  N.B.  The total\n"
16329                 "    vertical height of the legend in normalized subpage coordinates is\n"
16330                 "    calculated internally from \n"
16331                 "    nlegend, \n"
16332                 "    text_scale (see below), and  \n"
16333                 "    text_spacing (see below). \n"
16334                 "\n"
16335                 "    opt_array (const PLINT *, input) :      Array of nlegend values of\n"
16336                 "    options to control each individual plotted area corresponding to a\n"
16337                 "    legend entry.  If the \n"
16338                 "    PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
16339                 "    area.  If the \n"
16340                 "    PL_LEGEND_COLOR_BOX, \n"
16341                 "    PL_LEGEND_LINE, and/or \n"
16342                 "    PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
16343                 "    entry is plotted with a colored box; a line; and/or a line of\n"
16344                 "    symbols. \n"
16345                 "\n"
16346                 "    text_offset (PLFLT, input) :    Offset of the text area from the plot\n"
16347                 "    area in units of character width.  N.B.  The total horizontal\n"
16348                 "    width of the legend in normalized subpage coordinates is\n"
16349                 "    calculated internally from \n"
16350                 "    plot_width (see above), \n"
16351                 "    text_offset, and length (calculated internally) of the longest text\n"
16352                 "    string. \n"
16353                 "\n"
16354                 "    text_scale (PLFLT, input) :    Character height scale for text\n"
16355                 "    annotations.  N.B.  The total vertical height of the legend in\n"
16356                 "    normalized subpage coordinates is calculated internally from \n"
16357                 "    nlegend (see above), \n"
16358                 "    text_scale, and \n"
16359                 "    text_spacing (see below). \n"
16360                 "\n"
16361                 "    text_spacing (PLFLT, input) :    Vertical spacing in units of the\n"
16362                 "    character height from one legend entry to the next.  N.B.  The\n"
16363                 "    total vertical height of the legend in normalized subpage\n"
16364                 "    coordinates is calculated internally from \n"
16365                 "    nlegend (see above), \n"
16366                 "    text_scale (see above), and \n"
16367                 "    text_spacing. \n"
16368                 "\n"
16369                 "    text_justification (PLFLT, input) :    Justification parameter used\n"
16370                 "    for text justification.  The most common values of\n"
16371                 "    text_justification are 0., 0.5, or 1. corresponding to a text that\n"
16372                 "    is left justified, centred, or right justified within the text\n"
16373                 "    area, but other values are allowed as well. \n"
16374                 "\n"
16375                 "    text_colors (const PLINT *, input) :    Array of nlegend text colors\n"
16376                 "    (cmap0 indices). \n"
16377                 "\n"
16378                 "    text (const char **, input) :    Array of nlegend text string\n"
16379                 "    annotations. \n"
16380                 "\n"
16381                 "    box_colors (const PLINT *, input) :    Array of nlegend colors (cmap0\n"
16382                 "    indices) for the discrete colored boxes (\n"
16383                 "    PL_LEGEND_COLOR_BOX). \n"
16384                 "\n"
16385                 "    box_patterns (const PLINT *, input) :    Array of nlegend patterns\n"
16386                 "    (plpsty indices) for the discrete colored boxes (\n"
16387                 "    PL_LEGEND_COLOR_BOX). \n"
16388                 "\n"
16389                 "    box_scales (const PLFLT *, input) :    Array of nlegend scales (units\n"
16390                 "    of fraction of character height) for the height of the discrete\n"
16391                 "    colored boxes  (\n"
16392                 "    PL_LEGEND_COLOR_BOX). \n"
16393                 "\n"
16394                 "    line_colors (const PLINT *, input) :    Array of nlegend line colors\n"
16395                 "    (cmap0 indices) (\n"
16396                 "    PL_LEGEND_LINE). \n"
16397                 "\n"
16398                 "    line_styles (const PLINT *, input) :    Array of nlegend line styles\n"
16399                 "    (plsty indices)  (\n"
16400                 "    PL_LEGEND_LINE). \n"
16401                 "\n"
16402                 "    line_widths (const PLINT *, input) :    Array of nlegend line widths (\n"
16403                 "    PL_LEGEND_LINE). \n"
16404                 "\n"
16405                 "    symbol_colors (const PLINT *, input) :    Array of nlegend symbol\n"
16406                 "    colors (cmap0 indices)    (\n"
16407                 "    PL_LEGEND_SYMBOL). \n"
16408                 "\n"
16409                 "    symbol_scales (const PLFLT *, input) :    Array of nlegend scale\n"
16410                 "    values for the symbol height  (\n"
16411                 "    PL_LEGEND_SYMBOL). \n"
16412                 "\n"
16413                 "    symbol_numbers (const PLINT *, input) :    Array of nlegend numbers of\n"
16414                 "    symbols to be drawn across the width of the plotted area (\n"
16415                 "    PL_LEGEND_SYMBOL). \n"
16416                 "\n"
16417                 "    symbols (const PLINT *, input) :    Array of nlegend symbols (plpoin\n"
16418                 "    indices)  (\n"
16419                 "    PL_LEGEND_SYMBOL). \n"
16420                 "\n"
16421                 ""},
16422          { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
16423                 "Sets the 3D position of the light source \n"
16424                 "\n"
16425                 "DESCRIPTION:\n"
16426                 "\n"
16427                 "    Sets the 3D position of the light source for use with plsurf3d. \n"
16428                 "\n"
16429                 "    Redacted form: pllightsource(x, y, z)\n"
16430                 "\n"
16431                 "    This function is used in example 8. \n"
16432                 "\n"
16433                 "\n"
16434                 "\n"
16435                 "SYNOPSIS:\n"
16436                 "\n"
16437                 "pllightsource(x, y, z)\n"
16438                 "\n"
16439                 "ARGUMENTS:\n"
16440                 "\n"
16441                 "    x (PLFLT, input) :      X-coordinate of the light source. \n"
16442                 "\n"
16443                 "    y (PLFLT, input) :      Y-coordinate of the light source. \n"
16444                 "\n"
16445                 "    z (PLFLT, input) :      Z-coordinate of the light source. \n"
16446                 "\n"
16447                 ""},
16448          { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
16449                 "Draw a line \n"
16450                 "\n"
16451                 "DESCRIPTION:\n"
16452                 "\n"
16453                 "    Draws line defined by n points in x and y. \n"
16454                 "\n"
16455                 "    Redacted form: plline(x, y)\n"
16456                 "\n"
16457                 "    This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
16458                 "\n"
16459                 "\n"
16460                 "\n"
16461                 "SYNOPSIS:\n"
16462                 "\n"
16463                 "plline(n, x, y)\n"
16464                 "\n"
16465                 "ARGUMENTS:\n"
16466                 "\n"
16467                 "    n (PLINT, input) :      Number of points defining line. \n"
16468                 "\n"
16469                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of points. \n"
16470                 "\n"
16471                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of points. \n"
16472                 "\n"
16473                 ""},
16474          { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
16475                 "Draw a line in 3 space \n"
16476                 "\n"
16477                 "DESCRIPTION:\n"
16478                 "\n"
16479                 "    Draws line in 3 space defined by n points in x, y, and z. You must\n"
16480                 "    first set up the viewport, the 2d viewing window (in world\n"
16481                 "    coordinates), and the 3d normalized coordinate box.  See x18c.c for\n"
16482                 "    more info. \n"
16483                 "\n"
16484                 "    Redacted form: plline3(x, y, z)\n"
16485                 "\n"
16486                 "    This function is used in example 18. \n"
16487                 "\n"
16488                 "\n"
16489                 "\n"
16490                 "SYNOPSIS:\n"
16491                 "\n"
16492                 "plline3(n, x, y, z)\n"
16493                 "\n"
16494                 "ARGUMENTS:\n"
16495                 "\n"
16496                 "    n (PLINT, input) :      Number of points defining line. \n"
16497                 "\n"
16498                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of points. \n"
16499                 "\n"
16500                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of points. \n"
16501                 "\n"
16502                 "    z (PLFLT *, input) :    Pointer to array with z coordinates of points. \n"
16503                 "\n"
16504                 ""},
16505          { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
16506                 "Select line style \n"
16507                 "\n"
16508                 "DESCRIPTION:\n"
16509                 "\n"
16510                 "    This sets the line style according to one of eight predefined patterns\n"
16511                 "    (also see plstyl). \n"
16512                 "\n"
16513                 "    Redacted form: pllsty(n)\n"
16514                 "\n"
16515                 "    This function is used in examples 9,12,22,25. \n"
16516                 "\n"
16517                 "\n"
16518                 "\n"
16519                 "SYNOPSIS:\n"
16520                 "\n"
16521                 "pllsty(n)\n"
16522                 "\n"
16523                 "ARGUMENTS:\n"
16524                 "\n"
16525                 "    n (PLINT, input) :      Integer value between 1 and 8. Line style 1 is a\n"
16526                 "    continuous line, line style 2 is a line with short dashes and\n"
16527                 "    gaps, line style 3 is a line with long dashes and gaps, line style\n"
16528                 "    4 has long dashes and short gaps and so on. \n"
16529                 "\n"
16530                 ""},
16531          { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
16532                 "Plot surface mesh \n"
16533                 "\n"
16534                 "DESCRIPTION:\n"
16535                 "\n"
16536                 "    Plots a surface mesh within the environment set up by plw3d.  The\n"
16537                 "    surface is defined by the two-dimensional array z[\n"
16538                 "    nx][\n"
16539                 "    ny], the point z[i][j] being the value of the function at (\n"
16540                 "    x[i], \n"
16541                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
16542                 "    equally spaced, but must be stored in ascending order.  The parameter\n"
16543                 "    opt controls the way in which the surface is displayed.  For further\n"
16544                 "    details see the PLplot documentation. \n"
16545                 "\n"
16546                 "    Redacted form: plmesh(x, y, z, opt)\n"
16547                 "\n"
16548                 "    This function is used in example 11. \n"
16549                 "\n"
16550                 "\n"
16551                 "\n"
16552                 "SYNOPSIS:\n"
16553                 "\n"
16554                 "plmesh(x, y, z, nx, ny, opt)\n"
16555                 "\n"
16556                 "ARGUMENTS:\n"
16557                 "\n"
16558                 "    x (PLFLT *, input) :    Pointer to set of x coordinate values at which\n"
16559                 "    the function is evaluated. \n"
16560                 "\n"
16561                 "    y (PLFLT *, input) :    Pointer to set of y coordinate values at which\n"
16562                 "    the function is evaluated. \n"
16563                 "\n"
16564                 "    z (PLFLT **, input) :    Pointer to a vectored two-dimensional array\n"
16565                 "    with set of function values. \n"
16566                 "\n"
16567                 "    nx (PLINT, input) :    Number of x values at which function is\n"
16568                 "    evaluated. \n"
16569                 "\n"
16570                 "    ny (PLINT, input) :    Number of y values at which function is\n"
16571                 "    evaluated. \n"
16572                 "\n"
16573                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
16574                 "    represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
16575                 "    function of x for each value of y[j]. \n"
16576                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16577                 "        for each value of x[i]. \n"
16578                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16579                 "        at which function is defined. \n"
16580                 "\n"
16581                 ""},
16582          { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
16583                 "Magnitude colored plot surface mesh with contour. \n"
16584                 "\n"
16585                 "DESCRIPTION:\n"
16586                 "\n"
16587                 "    Identical to plmesh but with extra functionalities: the surface mesh\n"
16588                 "    can be colored accordingly to the current z value being plotted, a\n"
16589                 "    contour plot can be drawn at the base XY plane, and a curtain can be\n"
16590                 "    drawn between the plotted function border and the base XY plane. \n"
16591                 "\n"
16592                 "    Redacted form: plmeshc(x, y, z, opt, clevel)\n"
16593                 "\n"
16594                 "    This function is used in example 11. \n"
16595                 "\n"
16596                 "\n"
16597                 "\n"
16598                 "SYNOPSIS:\n"
16599                 "\n"
16600                 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16601                 "\n"
16602                 "ARGUMENTS:\n"
16603                 "\n"
16604                 "    x (PLFLT *, input) :    Pointer to set of x coordinate values at which\n"
16605                 "    the function is evaluated. \n"
16606                 "\n"
16607                 "    y (PLFLT *, input) :    Pointer to set of y coordinate values at which\n"
16608                 "    the function is evaluated. \n"
16609                 "\n"
16610                 "    z (PLFLT **, input) :    Pointer to a vectored two-dimensional array\n"
16611                 "    with set of function values. \n"
16612                 "\n"
16613                 "    nx (PLINT, input) :    Number of x values at which function is\n"
16614                 "    evaluated. \n"
16615                 "\n"
16616                 "    ny (PLINT, input) :    Number of y values at which function is\n"
16617                 "    evaluated. \n"
16618                 "\n"
16619                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
16620                 "    represented. To specify more than one option just add the options,\n"
16621                 "    e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
16622                 "    showing z as a function of x for each value of y[j]. \n"
16623                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16624                 "        for each value of x[i]. \n"
16625                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16626                 "        at which function is defined. \n"
16627                 "        opt=MAG_COLOR: Each line in the mesh is colored according to\n"
16628                 "        the z value being plotted. The color is used from the current\n"
16629                 "        colormap 1. \n"
16630                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
16631                 "        using parameters \n"
16632                 "    nlevel and \n"
16633                 "    clevel. \n"
16634                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
16635                 "        the borders of the plotted function. \n"
16636                 "\n"
16637                 "\n"
16638                 "    clevel (PLFLT *, input) :     Pointer to the array that defines the\n"
16639                 "    contour level spacing. \n"
16640                 "\n"
16641                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
16642                 "\n"
16643                 ""},
16644          { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
16645                 "Creates a new stream and makes it the default \n"
16646                 "\n"
16647                 "DESCRIPTION:\n"
16648                 "\n"
16649                 "    Creates a new stream and makes it the default.  Differs from using\n"
16650                 "    plsstrm, in that a free stream number is found, and returned.\n"
16651                 "    Unfortunately, I have to start at stream 1 and work upward, since\n"
16652                 "    stream 0 is preallocated.  One of the big flaws in the PLplot API is\n"
16653                 "    that no initial, library-opening call is required. So stream 0 must\n"
16654                 "    be preallocated, and there is no simple way of determining whether it\n"
16655                 "    is already in use or not. \n"
16656                 "\n"
16657                 "    Redacted form: plmkstrm(p_strm)\n"
16658                 "\n"
16659                 "    This function is used in examples 1,20. \n"
16660                 "\n"
16661                 "\n"
16662                 "\n"
16663                 "SYNOPSIS:\n"
16664                 "\n"
16665                 "plmkstrm(p_strm)\n"
16666                 "\n"
16667                 "ARGUMENTS:\n"
16668                 "\n"
16669                 "    p_strm (PLINT *, output) :      Pointer to stream number of the created\n"
16670                 "    stream. \n"
16671                 "\n"
16672                 ""},
16673          { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
16674                 "Write text relative to viewport boundaries \n"
16675                 "\n"
16676                 "DESCRIPTION:\n"
16677                 "\n"
16678                 "    Writes text at a specified position relative to the viewport\n"
16679                 "    boundaries.  Text may be written inside or outside the viewport, but\n"
16680                 "    is clipped at the subpage boundaries.  The reference point of a string\n"
16681                 "    lies along a line passing through the string at half the height of a\n"
16682                 "    capital letter.  The position of the reference point along this line\n"
16683                 "    is determined by just, and the position of the reference point\n"
16684                 "    relative to the viewport is set by disp and pos. \n"
16685                 "\n"
16686                 "    Redacted form:  General: plmtex(side, disp, pos, just, text)\n"
16687                 "           Perl/PDL: plmtex(disp, pos, just, side, text)\n"
16688                 "\n"
16689                 "\n"
16690                 "    This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
16691                 "\n"
16692                 "\n"
16693                 "\n"
16694                 "SYNOPSIS:\n"
16695                 "\n"
16696                 "plmtex(side, disp, pos, just, text)\n"
16697                 "\n"
16698                 "ARGUMENTS:\n"
16699                 "\n"
16700                 "    side (const char *, input) :    Specifies the side of the viewport\n"
16701                 "    along which the text is to be written. The string must be one of:\n"
16702                 "    b: Bottom of viewport, text written parallel to edge. \n"
16703                 "        bv: Bottom of viewport, text written at right angles to edge. \n"
16704                 "        l: Left of viewport, text written parallel to edge. \n"
16705                 "        lv: Left of viewport, text written at right angles to edge. \n"
16706                 "        r: Right of viewport, text written parallel to edge. \n"
16707                 "        rv: Right of viewport, text written at right angles to edge. \n"
16708                 "        t: Top of viewport, text written parallel to edge. \n"
16709                 "        tv: Top of viewport, text written at right angles to edge. \n"
16710                 "\n"
16711                 "\n"
16712                 "    disp (PLFLT, input) :    Position of the reference point of string,\n"
16713                 "    measured outwards from the specified viewport edge in units of the\n"
16714                 "    current character height.  Use negative disp to write within the\n"
16715                 "    viewport. \n"
16716                 "\n"
16717                 "    pos (PLFLT, input) :    Position of the reference point of string\n"
16718                 "    along the specified edge, expressed as a fraction of the length of\n"
16719                 "    the edge. \n"
16720                 "\n"
16721                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
16722                 "    to its reference point.  If just=0., the reference point is at the\n"
16723                 "    left and if just=1., it is at the right of the string.    Other\n"
16724                 "    values of just give intermediate justifications. \n"
16725                 "\n"
16726                 "    text (const char *, input) :    The string to be written out. \n"
16727                 "\n"
16728                 ""},
16729          { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
16730                 "Write text relative to viewport boundaries in 3D plots. \n"
16731                 "\n"
16732                 "DESCRIPTION:\n"
16733                 "\n"
16734                 "    Writes text at a specified position relative to the viewport\n"
16735                 "    boundaries.  Text may be written inside or outside the viewport, but\n"
16736                 "    is clipped at the subpage boundaries.  The reference point of a string\n"
16737                 "    lies along a line passing through the string at half the height of a\n"
16738                 "    capital letter.  The position of the reference point along this line\n"
16739                 "    is determined by just, and the position of the reference point\n"
16740                 "    relative to the viewport is set by disp and pos. \n"
16741                 "\n"
16742                 "    Redacted form: plmtex3(side, disp, pos, just, text)\n"
16743                 "\n"
16744                 "    This function is used in example 28. \n"
16745                 "\n"
16746                 "\n"
16747                 "\n"
16748                 "SYNOPSIS:\n"
16749                 "\n"
16750                 "plmtex3(side, disp, pos, just, text)\n"
16751                 "\n"
16752                 "ARGUMENTS:\n"
16753                 "\n"
16754                 "    side (const char *, input) :    Specifies the side of the viewport\n"
16755                 "    along which the text is to be written. The string should contain\n"
16756                 "    one or more of the following characters: [xyz][ps][v].    Only one\n"
16757                 "    label is drawn at a time, i.e. xyp will only label the X axis, not\n"
16758                 "    both the X and Y axes. x: Label the X axis. \n"
16759                 "        y: Label the Y axis. \n"
16760                 "        z: Label the Z axis. \n"
16761                 "        p: Label the primary axis. For Z this is the leftmost Z axis.\n"
16762                 "        For X it is the axis that starts at y-min. For Y it is the\n"
16763                 "        axis that starts at x-min. \n"
16764                 "        s: Label the secondary axis. \n"
16765                 "        v: Draw the text perpendicular to the axis. \n"
16766                 "\n"
16767                 "\n"
16768                 "    disp (PLFLT, input) :    Position of the reference point of string,\n"
16769                 "    measured outwards from the specified viewport edge in units of the\n"
16770                 "    current character height.  Use negative disp to write within the\n"
16771                 "    viewport. \n"
16772                 "\n"
16773                 "    pos (PLFLT, input) :    Position of the reference point of string\n"
16774                 "    along the specified edge, expressed as a fraction of the length of\n"
16775                 "    the edge. \n"
16776                 "\n"
16777                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
16778                 "    to its reference point.  If just=0., the reference point is at the\n"
16779                 "    left and if just=1., it is at the right of the string.    Other\n"
16780                 "    values of just give intermediate justifications. \n"
16781                 "\n"
16782                 "    text (const char *, input) :    The string to be written out. \n"
16783                 "\n"
16784                 ""},
16785          { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
16786                 "Plot 3-d surface plot \n"
16787                 "\n"
16788                 "DESCRIPTION:\n"
16789                 "\n"
16790                 "    Plots a three dimensional surface plot within the environment set up\n"
16791                 "    by plw3d.  The surface is defined by the two-dimensional array z[\n"
16792                 "    nx][\n"
16793                 "    ny], the point z[i][j] being the value of the function at (\n"
16794                 "    x[i], \n"
16795                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
16796                 "    equally spaced, but must be stored in ascending order.  The parameter\n"
16797                 "    opt controls the way in which the surface is displayed.  For further\n"
16798                 "    details see the PLplot documentation. The only difference between\n"
16799                 "    plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
16800                 "    while plot3d only draws the surface as viewed from the top. \n"
16801                 "\n"
16802                 "    Redacted form: plot3d(x, y, z, opt, side)\n"
16803                 "\n"
16804                 "    This function is used in examples 11,21. \n"
16805                 "\n"
16806                 "\n"
16807                 "\n"
16808                 "SYNOPSIS:\n"
16809                 "\n"
16810                 "plot3d(x, y, z, nx, ny, opt, side)\n"
16811                 "\n"
16812                 "ARGUMENTS:\n"
16813                 "\n"
16814                 "    x (PLFLT *, input) :    Pointer to set of x coordinate values at which\n"
16815                 "    the function is evaluated. \n"
16816                 "\n"
16817                 "    y (PLFLT *, input) :    Pointer to set of y coordinate values at which\n"
16818                 "    the function is evaluated. \n"
16819                 "\n"
16820                 "    z (PLFLT **, input) :    Pointer to a vectored two-dimensional array\n"
16821                 "    with set of function values. \n"
16822                 "\n"
16823                 "    nx (PLINT, input) :    Number of x values at which function is\n"
16824                 "    evaluated. \n"
16825                 "\n"
16826                 "    ny (PLINT, input) :    Number of y values at which function is\n"
16827                 "    evaluated. \n"
16828                 "\n"
16829                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
16830                 "    represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
16831                 "    function of x for each value of y[j]. \n"
16832                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
16833                 "        for each value of x[i]. \n"
16834                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
16835                 "        at which function is defined. \n"
16836                 "\n"
16837                 "\n"
16838                 "    side (PLBOOL, input) :    Flag to indicate whether or not ``sides''\n"
16839                 "    should be draw on the figure.  If side is true sides are drawn,\n"
16840                 "    otherwise no sides are drawn. \n"
16841                 "\n"
16842                 ""},
16843          { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
16844                 "Magnitude colored plot surface with contour. \n"
16845                 "\n"
16846                 "DESCRIPTION:\n"
16847                 "\n"
16848                 "    Identical to plot3d but with extra functionalities: the surface mesh\n"
16849                 "    can be colored accordingly to the current z value being plotted, a\n"
16850                 "    contour plot can be drawn at the base XY plane, and a curtain can be\n"
16851                 "    drawn between the plotted function border and the base XY plane. The\n"
16852                 "    arguments are identical to plmeshc. The only difference between\n"
16853                 "    plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
16854                 "    surface, while plot3dc only draws the surface as viewed from the top. \n"
16855                 "\n"
16856                 "    Redacted form:  General: plot3dc(x, y, z, opt, clevel)\n"
16857                 "           Perl/PDL: Not available? \n"
16858                 "\n"
16859                 "\n"
16860                 "    This function is used in example 21. \n"
16861                 "\n"
16862                 "\n"
16863                 "\n"
16864                 "SYNOPSIS:\n"
16865                 "\n"
16866                 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16867                 "\n"
16868                 ""},
16869          { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, NULL},
16870          { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
16871                 "Plot shaded 3-d surface plot \n"
16872                 "\n"
16873                 "DESCRIPTION:\n"
16874                 "\n"
16875                 "    Plots a three dimensional shaded surface plot within the environment\n"
16876                 "    set up by plw3d.  The surface is defined by the two-dimensional array\n"
16877                 "    z[\n"
16878                 "    nx][\n"
16879                 "    ny], the point z[i][j] being the value of the function at (\n"
16880                 "    x[i], \n"
16881                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
16882                 "    equally spaced, but must be stored in ascending order. For further\n"
16883                 "    details see the PLplot documentation. \n"
16884                 "\n"
16885                 "    Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
16886                 "\n"
16887                 "    This function is not used in any examples. \n"
16888                 "\n"
16889                 "\n"
16890                 "\n"
16891                 "SYNOPSIS:\n"
16892                 "\n"
16893                 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
16894                 "\n"
16895                 "ARGUMENTS:\n"
16896                 "\n"
16897                 "    x (PLFLT *, input) :    Pointer to set of x coordinate values at which\n"
16898                 "    the function is evaluated. \n"
16899                 "\n"
16900                 "    y (PLFLT *, input) :    Pointer to set of y coordinate values at which\n"
16901                 "    the function is evaluated. \n"
16902                 "\n"
16903                 "    z (PLFLT **, input) :    Pointer to a vectored two-dimensional array\n"
16904                 "    with set of function values. \n"
16905                 "\n"
16906                 "    nx (PLINT, input) :    Number of x values at which function is\n"
16907                 "    evaluated. \n"
16908                 "\n"
16909                 "    ny (PLINT, input) :    Number of y values at which function is\n"
16910                 "    evaluated. \n"
16911                 "\n"
16912                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
16913                 "    represented. To specify more than one option just add the options,\n"
16914                 "    e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
16915                 "    connecting points at which function is defined. \n"
16916                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
16917                 "        using parameters \n"
16918                 "    nlevel and \n"
16919                 "    clevel. \n"
16920                 "        opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
16921                 "        using parameters \n"
16922                 "    nlevel and \n"
16923                 "    clevel. \n"
16924                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
16925                 "        the borders of the plotted function. \n"
16926                 "        opt=MAG_COLOR: the surface is colored according to the value\n"
16927                 "        of Z; if MAG_COLOR is not used, then the default the surface\n"
16928                 "        is colored according to the intensity of the reflected light\n"
16929                 "        in the surface from a light source whose position is set using\n"
16930                 "        pllightsource. \n"
16931                 "\n"
16932                 "\n"
16933                 "    clevel (PLFLT *, input) :     Pointer to the array that defines the\n"
16934                 "    contour level spacing. \n"
16935                 "\n"
16936                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
16937                 "\n"
16938                 ""},
16939          { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, NULL},
16940          { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
16941                 "Parse command-line arguments \n"
16942                 "\n"
16943                 "DESCRIPTION:\n"
16944                 "\n"
16945                 "    Parse command-line arguments. \n"
16946                 "\n"
16947                 "    plparseopts removes all recognized flags (decreasing argc\n"
16948                 "    accordingly), so that invalid input may be readily detected.  It can\n"
16949                 "    also be used to process user command line flags.  The user can merge\n"
16950                 "    an option table of type PLOptionTable into the internal option table\n"
16951                 "    info structure using plMergeOpts.  Or, the user can specify that ONLY\n"
16952                 "    the external table(s) be parsed by calling plClearOpts before\n"
16953                 "    plMergeOpts. \n"
16954                 "\n"
16955                 "    The default action taken by plparseopts is as follows: \n"
16956                 "    Returns with an error if an unrecognized option or badly formed\n"
16957                 "    option-value pair are encountered. \n"
16958                 "    Returns immediately (return code 0) when the first non-option command\n"
16959                 "    line argument is found.  \n"
16960                 "    Returns with the return code of the option handler, if one was called.\n"
16961                 "     \n"
16962                 "    Deletes command line arguments from argv list as they are found, and\n"
16963                 "    decrements argc accordingly.  \n"
16964                 "    Does not show \"invisible\" options in usage or help messages.  \n"
16965                 "    Assumes the program name is contained in argv[0].  \n"
16966                 "\n"
16967                 "\n"
16968                 "    These behaviors may be controlled through the  \n"
16969                 "    mode argument. \n"
16970                 "\n"
16971                 "    Redacted form:  General: plparseopts(argv, mode)\n"
16972                 "           Perl/PDL: Not available? \n"
16973                 "\n"
16974                 "\n"
16975                 "    This function is used in all of the examples. \n"
16976                 "\n"
16977                 "\n"
16978                 "\n"
16979                 "SYNOPSIS:\n"
16980                 "\n"
16981                 "int plparseopts(p_argc, argv, mode)\n"
16982                 "\n"
16983                 "ARGUMENTS:\n"
16984                 "\n"
16985                 "    p_argc (int *, input) :    pointer to number of arguments. \n"
16986                 "\n"
16987                 "    argv (char **, input) :    Pointer to character array containing\n"
16988                 "    *p_argc command-line arguments. \n"
16989                 "\n"
16990                 "    mode (PLINT, input) :    Parsing mode with the following\n"
16991                 "    possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
16992                 "    and all error messages enabled, including program exit when an\n"
16993                 "    error occurs.  Anything on the command line that isn't recognized\n"
16994                 "    as a valid option or option argument is flagged as an error. \n"
16995                 "        PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
16996                 "        of errors. \n"
16997                 "        PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
16998                 "        arguments. \n"
16999                 "        PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17000                 "        PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17001                 "        pointer to the program name. \n"
17002                 "        PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17003                 "        PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17004                 "        unrecognized arguments. \n"
17005                 "\n"
17006                 ""},
17007          { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
17008                 "Set area fill pattern \n"
17009                 "\n"
17010                 "DESCRIPTION:\n"
17011                 "\n"
17012                 "    Sets the area fill pattern.  The pattern consists of 1 or 2 sets of\n"
17013                 "    parallel lines with specified inclinations and spacings.  The\n"
17014                 "    arguments to this routine are the number of sets to use (1 or 2)\n"
17015                 "    followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17016                 "    specifying the inclinations in tenths of a degree and the spacing in\n"
17017                 "    micrometers.  (also see plpsty) \n"
17018                 "\n"
17019                 "    Redacted form:  General: plpat(inc, del)\n"
17020                 "           Perl/PDL: plpat(nlin, inc, del)\n"
17021                 "\n"
17022                 "\n"
17023                 "    This function is used in example 15. \n"
17024                 "\n"
17025                 "\n"
17026                 "\n"
17027                 "SYNOPSIS:\n"
17028                 "\n"
17029                 "plpat(nlin, inc, del)\n"
17030                 "\n"
17031                 "ARGUMENTS:\n"
17032                 "\n"
17033                 "    nlin (PLINT, input) :    Number of sets of lines making up the\n"
17034                 "    pattern, either 1 or 2. \n"
17035                 "\n"
17036                 "    inc (PLINT *, input) :    Pointer to array with nlin elements.\n"
17037                 "    Specifies the line inclination in tenths of a degree.  (Should be\n"
17038                 "    between -900 and 900). \n"
17039                 "\n"
17040                 "    del (PLINT *, input) :    Pointer to array with nlin elements.\n"
17041                 "    Specifies the spacing in micrometers between the lines making up\n"
17042                 "    the pattern. \n"
17043                 "\n"
17044                 ""},
17045          { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
17046                 "Plots a character at the specified points \n"
17047                 "\n"
17048                 "DESCRIPTION:\n"
17049                 "\n"
17050                 "    Marks a set of n points in x and y using the symbol defined by code.\n"
17051                 "    If code is between 32 and 127, the symbol is simply the corresponding\n"
17052                 "    printable ASCII character in the default font. \n"
17053                 "\n"
17054                 "    Redacted form: plpoin(x, y, code)\n"
17055                 "\n"
17056                 "    This function is used in examples 1,6,14,18,21,29. \n"
17057                 "\n"
17058                 "\n"
17059                 "\n"
17060                 "SYNOPSIS:\n"
17061                 "\n"
17062                 "plpoin(n, x, y, code)\n"
17063                 "\n"
17064                 "ARGUMENTS:\n"
17065                 "\n"
17066                 "    n (PLINT, input) :      Number of points to be marked. \n"
17067                 "\n"
17068                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of the\n"
17069                 "    points. \n"
17070                 "\n"
17071                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of the\n"
17072                 "    points. \n"
17073                 "\n"
17074                 "    code (PLINT, input) :    Code number for the symbol to be plotted. \n"
17075                 "\n"
17076                 ""},
17077          { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
17078                 "Plots a character at the specified points in 3 space \n"
17079                 "\n"
17080                 "ESCRIPTION:\n"
17081                 "\n"
17082                 "   Marks a set of n points in x, y, and z using the symbol defined by\n"
17083                 "   code. If code is between 32 and 127, the symbol is simply the\n"
17084                 "   corresponding printable ASCII character in the default font. Setup\n"
17085                 "   similar to plline3. \n"
17086                 "\n"
17087                 "   Redacted form: plpoin3(x, y, z, code)\n"
17088                 "\n"
17089                 "   This function is used in example 18. \n"
17090                 "\n"
17091                 "\n"
17092                 "\n"
17093                 "YNOPSIS:\n"
17094                 "\n"
17095                 "lpoin3(n, x, y, z, code)\n"
17096                 "\n"
17097                 "RGUMENTS:\n"
17098                 "\n"
17099                 "   n (PLINT, input) :      Number of points to be marked. \n"
17100                 "\n"
17101                 "   x (PLFLT *, input) :    Pointer to array with x coordinates of the\n"
17102                 "   points. \n"
17103                 "\n"
17104                 "   y (PLFLT *, input) :    Pointer to array with y coordinates of the\n"
17105                 "   points. \n"
17106                 "\n"
17107                 "   z (PLFLT *, input) :    Pointer to array with z coordinates of the\n"
17108                 "   points. \n"
17109                 "\n"
17110                 "   code (PLINT, input) :    Code number for the symbol to be plotted. \n"
17111                 "\n"
17112                 ""},
17113          { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
17114                 "Draw a polygon in 3 space \n"
17115                 "\n"
17116                 "DESCRIPTION:\n"
17117                 "\n"
17118                 "    Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
17119                 "    like plline3, but differs from that function in that plpoly3 attempts\n"
17120                 "    to determine if the polygon is viewable depending on the order of the\n"
17121                 "    points within the arrays and the value of ifcc.  If the back of\n"
17122                 "    polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
17123                 "    you want, then use plline3 instead. \n"
17124                 "\n"
17125                 "    The points are assumed to be in a plane, and the directionality of the\n"
17126                 "    plane is determined from the first three points.  Additional points do\n"
17127                 "    not have to lie on the plane defined by the first three, but if they\n"
17128                 "    do not, then the determination of visibility obviously can't be 100%\n"
17129                 "    accurate... So if you're 3 space polygons are too far from planar,\n"
17130                 "    consider breaking them into smaller polygons.  3 points define a plane\n"
17131                 "    :-). \n"
17132                 "\n"
17133                 "    Bugs:  If one of the first two segments is of zero length, or if they\n"
17134                 "    are co-linear, the calculation of visibility has a 50/50 chance of\n"
17135                 "    being correct.  Avoid such situations :-). See x18c.c for an example\n"
17136                 "    of this problem. (Search for 20.1). \n"
17137                 "\n"
17138                 "    Redacted form: plpoly3(x, y, z, code)\n"
17139                 "\n"
17140                 "    This function is used in example 18. \n"
17141                 "\n"
17142                 "\n"
17143                 "\n"
17144                 "SYNOPSIS:\n"
17145                 "\n"
17146                 "plpoly3(n, x, y, z, draw, ifcc)\n"
17147                 "\n"
17148                 "ARGUMENTS:\n"
17149                 "\n"
17150                 "    n (PLINT, input) :      Number of points defining line. \n"
17151                 "\n"
17152                 "    x (PLFLT *, input) :    Pointer to array with x coordinates of points. \n"
17153                 "\n"
17154                 "    y (PLFLT *, input) :    Pointer to array with y coordinates of points. \n"
17155                 "\n"
17156                 "    z (PLFLT *, input) :    Pointer to array with z coordinates of points. \n"
17157                 "\n"
17158                 "    draw (PLBOOL *, input) :    Pointer to array which controls drawing\n"
17159                 "    the segments of the polygon.  If draw[i] is true, then the polygon\n"
17160                 "    segment from index [i] to [i+1] is drawn, otherwise, not. \n"
17161                 "\n"
17162                 "    ifcc (PLBOOL, input) :    If ifcc is true the directionality of the\n"
17163                 "    polygon is determined by assuming the points are laid out in a\n"
17164                 "    counter-clockwise order.  Otherwise, the directionality of the\n"
17165                 "    polygon is determined by assuming the points are laid out in a\n"
17166                 "    clockwise order. \n"
17167                 "\n"
17168                 ""},
17169          { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
17170                 "Set precision in numeric labels \n"
17171                 "\n"
17172                 "DESCRIPTION:\n"
17173                 "\n"
17174                 "    Sets the number of places after the decimal point in numeric labels. \n"
17175                 "\n"
17176                 "    Redacted form: plprec(set, prec)\n"
17177                 "\n"
17178                 "    This function is used in example 29. \n"
17179                 "\n"
17180                 "\n"
17181                 "\n"
17182                 "SYNOPSIS:\n"
17183                 "\n"
17184                 "plprec(set, prec)\n"
17185                 "\n"
17186                 "ARGUMENTS:\n"
17187                 "\n"
17188                 "    set (PLINT, input) :    If set is equal to 0 then PLplot automatically\n"
17189                 "    determines the number of places to use after the decimal point in\n"
17190                 "    numeric labels (like those used to label axes).  If set is 1 then\n"
17191                 "    prec sets the number of places. \n"
17192                 "\n"
17193                 "    prec (PLINT, input) :    The number of characters to draw after the\n"
17194                 "    decimal point in numeric labels. \n"
17195                 "\n"
17196                 ""},
17197          { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
17198                 "Select area fill pattern \n"
17199                 "\n"
17200                 "DESCRIPTION:\n"
17201                 "\n"
17202                 "    Select one of eight predefined area fill patterns to use (also see\n"
17203                 "    plpat). \n"
17204                 "\n"
17205                 "    Redacted form: plpsty(n)\n"
17206                 "\n"
17207                 "    This function is used in examples 12,13,15,16,25. \n"
17208                 "\n"
17209                 "\n"
17210                 "\n"
17211                 "SYNOPSIS:\n"
17212                 "\n"
17213                 "plpsty(n)\n"
17214                 "\n"
17215                 "ARGUMENTS:\n"
17216                 "\n"
17217                 "    n (PLINT, input) :      The desired pattern. Pattern 1 consists of\n"
17218                 "    horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
17219                 "    consists of lines at 45 degrees angle (upward), and so on. \n"
17220                 "\n"
17221                 ""},
17222          { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
17223                 "Write text inside the viewport \n"
17224                 "\n"
17225                 "DESCRIPTION:\n"
17226                 "\n"
17227                 "    Writes text at a specified position and inclination within the\n"
17228                 "    viewport.  Text is clipped at the viewport boundaries.  The reference\n"
17229                 "    point of a string lies along a line passing through the string at half\n"
17230                 "    the height of a capital letter.  The position of the reference point\n"
17231                 "    along this line is determined by just, the reference point is placed\n"
17232                 "    at world coordinates (\n"
17233                 "    x, \n"
17234                 "    y) within the viewport.  The inclination of the string is specified in\n"
17235                 "    terms of differences of world coordinates making it easy to write text\n"
17236                 "    parallel to a line in a graph. \n"
17237                 "\n"
17238                 "    Redacted form: plptex(x, y, dx, dy, just, text)\n"
17239                 "\n"
17240                 "    This function is used in example 2-4,10,12-14,20,23,24,26. \n"
17241                 "\n"
17242                 "\n"
17243                 "\n"
17244                 "SYNOPSIS:\n"
17245                 "\n"
17246                 "plptex(x, y, dx, dy, just, text)\n"
17247                 "\n"
17248                 "ARGUMENTS:\n"
17249                 "\n"
17250                 "    x (PLFLT, input) :      x coordinate of reference point of string. \n"
17251                 "\n"
17252                 "    y (PLFLT, input) :      y coordinate of reference point of string. \n"
17253                 "\n"
17254                 "    dx (PLFLT, input) :    Together with dy, this specifies the\n"
17255                 "    inclination of the string.  The baseline of the string is parallel\n"
17256                 "    to a line joining (\n"
17257                 "    x, \n"
17258                 "    y) to (\n"
17259                 "    x+\n"
17260                 "    dx, \n"
17261                 "    y+\n"
17262                 "    dy). \n"
17263                 "\n"
17264                 "    dy (PLFLT, input) :    Together with dx, this specifies the\n"
17265                 "    inclination of the string. \n"
17266                 "\n"
17267                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
17268                 "    to its reference point.  If just=0., the reference point is at the\n"
17269                 "    left and if just=1., it is at the right of the string.    Other\n"
17270                 "    values of just give intermediate justifications. \n"
17271                 "\n"
17272                 "    text (const char *, input) :    The string to be written out. \n"
17273                 "\n"
17274                 ""},
17275          { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
17276                 "Write text inside the viewport of a 3D plot. \n"
17277                 "\n"
17278                 "DESCRIPTION:\n"
17279                 "\n"
17280                 "    Writes text at a specified position and inclination and with a\n"
17281                 "    specified shear within the viewport.  Text is clipped at the viewport\n"
17282                 "    boundaries.  The reference point of a string lies along a line passing\n"
17283                 "    through the string at half the height of a capital letter. The\n"
17284                 "    position of the reference point along this line is determined by just,\n"
17285                 "    and the reference point is placed at world coordinates (\n"
17286                 "    x, \n"
17287                 "    y, \n"
17288                 "    z) within the viewport. The inclination and shear of the string is\n"
17289                 "    specified in terms of differences of world coordinates making it easy\n"
17290                 "    to write text parallel to a line in a graph. \n"
17291                 "\n"
17292                 "    Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz,  just, text)\n"
17293                 "\n"
17294                 "    This function is used in example 28. \n"
17295                 "\n"
17296                 "\n"
17297                 "\n"
17298                 "SYNOPSIS:\n"
17299                 "\n"
17300                 "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
17301                 "\n"
17302                 "ARGUMENTS:\n"
17303                 "\n"
17304                 "    x (PLFLT, input) :      x coordinate of reference point of string. \n"
17305                 "\n"
17306                 "    y (PLFLT, input) :      y coordinate of reference point of string. \n"
17307                 "\n"
17308                 "    z (PLFLT, input) :      z coordinate of reference point of string. \n"
17309                 "\n"
17310                 "    dx (PLFLT, input) :    Together with dy and \n"
17311                 "    dz, this specifies the inclination of  the string.    The baseline of\n"
17312                 "    the string is parallel to a line  joining (\n"
17313                 "    x, \n"
17314                 "    y, \n"
17315                 "    z) to (\n"
17316                 "    x+\n"
17317                 "    dx, \n"
17318                 "    y+\n"
17319                 "    dy, \n"
17320                 "    z+\n"
17321                 "    dz). \n"
17322                 "\n"
17323                 "    dy (PLFLT, input) :    Together with dx and \n"
17324                 "    dz, this specifies the inclination of the string. \n"
17325                 "\n"
17326                 "    dz (PLFLT, input) :    Together with dx and \n"
17327                 "    dy, this specifies the inclination of the string. \n"
17328                 "\n"
17329                 "    sx (PLFLT, input) :    Together with sy and \n"
17330                 "    sz, this specifies the shear of  the string.  The string is sheared so\n"
17331                 "    that the characters are  vertically parallel to a line joining (\n"
17332                 "    x, \n"
17333                 "    y, \n"
17334                 "    z) to (\n"
17335                 "    x+\n"
17336                 "    sx, \n"
17337                 "    y+\n"
17338                 "    sy, \n"
17339                 "    z+\n"
17340                 "    sz). If sx = \n"
17341                 "    sy = \n"
17342                 "    sz = 0.) then the text is not sheared. \n"
17343                 "\n"
17344                 "    sy (PLFLT, input) :    Together with sx and \n"
17345                 "    sz, this specifies shear of the string. \n"
17346                 "\n"
17347                 "    sz (PLFLT, input) :    Together with sx and \n"
17348                 "    sy, this specifies shear of the string. \n"
17349                 "\n"
17350                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
17351                 "    to its reference point.  If just=0., the reference point is at the\n"
17352                 "    left and if just=1., it is at the right of the string.    Other\n"
17353                 "    values of just give intermediate justifications. \n"
17354                 "\n"
17355                 "    text (const char *, input) :    The string to be written out. \n"
17356                 "\n"
17357                 ""},
17358          { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
17359                 "Random number generator  returning a real random number in the range [0,1]. \n"
17360                 "\n"
17361                 "DESCRIPTION:\n"
17362                 "\n"
17363                 "    Random number generator returning a real random number in the  range\n"
17364                 "    [0,1]. The generator is based on the Mersenne Twister.  Most languages\n"
17365                 "    / compilers provide their own random number generator,  and so this is\n"
17366                 "    provided purely for convenience and to give a consistent random number\n"
17367                 "    generator across all languages supported  by PLplot. This is\n"
17368                 "    particularly useful for comparing results  from the test suite of\n"
17369                 "    examples. \n"
17370                 "\n"
17371                 "    Redacted form: plrandd()\n"
17372                 "\n"
17373                 "    This function is used in examples 17,21. \n"
17374                 "\n"
17375                 "\n"
17376                 "\n"
17377                 "SYNOPSIS:\n"
17378                 "\n"
17379                 "plrandd()\n"
17380                 "\n"
17381                 ""},
17382          { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
17383                 "Replays contents of plot buffer to current device/file \n"
17384                 "\n"
17385                 "DESCRIPTION:\n"
17386                 "\n"
17387                 "    Replays contents of plot buffer to current device/file. \n"
17388                 "\n"
17389                 "    Redacted form: plreplot()\n"
17390                 "\n"
17391                 "    This function is used in example 1,20. \n"
17392                 "\n"
17393                 "\n"
17394                 "\n"
17395                 "SYNOPSIS:\n"
17396                 "\n"
17397                 "plreplot()\n"
17398                 "\n"
17399                 ""},
17400          { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
17401                 "Convert RGB color to HLS \n"
17402                 "\n"
17403                 "DESCRIPTION:\n"
17404                 "\n"
17405                 "    Convert RGB color coordinates to HLS \n"
17406                 "\n"
17407                 "    Redacted form:  General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
17408                 "           Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
17409                 "\n"
17410                 "\n"
17411                 "    This function is used in example 2. \n"
17412                 "\n"
17413                 "\n"
17414                 "\n"
17415                 "SYNOPSIS:\n"
17416                 "\n"
17417                 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
17418                 "\n"
17419                 "ARGUMENTS:\n"
17420                 "\n"
17421                 "    r (PLFLT, input) :      Red intensity (0.0-1.0) of the colour \n"
17422                 "\n"
17423                 "    g (PLFLT, input) :      Green intensity (0.0-1.0) of the colour \n"
17424                 "\n"
17425                 "    b (PLFLT, input) :      Blue intensity (0.0-1.0) of the colour \n"
17426                 "\n"
17427                 "    p_h (PLFLT *, output) :    Pointer to hue, in degrees on the colour\n"
17428                 "    cone (0.0-360.0) \n"
17429                 "\n"
17430                 "    p_l (PLFLT *, output) :    Pointer to lightness, expressed as a\n"
17431                 "    fraction of the axis of the colour cone (0.0-1.0) \n"
17432                 "\n"
17433                 "    p_s (PLFLT *, output) :    Pointer to saturation, expressed as a\n"
17434                 "    fraction of the radius of the colour cone (0.0-1.0) \n"
17435                 "\n"
17436                 ""},
17437          { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
17438                 "Set character size \n"
17439                 "\n"
17440                 "DESCRIPTION:\n"
17441                 "\n"
17442                 "    This sets up the size of all subsequent characters drawn.  The actual\n"
17443                 "    height of a character is the product of the default character size and\n"
17444                 "    a scaling factor. \n"
17445                 "\n"
17446                 "    Redacted form: plschr(def, scale)\n"
17447                 "\n"
17448                 "    This function is used in example 2,13,23,24. \n"
17449                 "\n"
17450                 "\n"
17451                 "\n"
17452                 "SYNOPSIS:\n"
17453                 "\n"
17454                 "plschr(def, scale)\n"
17455                 "\n"
17456                 "ARGUMENTS:\n"
17457                 "\n"
17458                 "    def (PLFLT, input) :    The default height of a character in\n"
17459                 "    millimeters, should be set to zero if the default height is to\n"
17460                 "    remain unchanged. \n"
17461                 "\n"
17462                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
17463                 "    actual character height. \n"
17464                 "\n"
17465                 ""},
17466          { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
17467                 "Set color map0 colors by 8-bit RGB values \n"
17468                 "\n"
17469                 "DESCRIPTION:\n"
17470                 "\n"
17471                 "    Set color map0 colors using 8-bit RGB values (see the PLplot\n"
17472                 "    documentation).  This sets the entire color map -- only as many colors\n"
17473                 "    as specified will be allocated. \n"
17474                 "\n"
17475                 "    Redacted form: plscmap0(r, g, b, ncol0)\n"
17476                 "\n"
17477                 "    This function is used in examples 2,24. \n"
17478                 "\n"
17479                 "\n"
17480                 "\n"
17481                 "SYNOPSIS:\n"
17482                 "\n"
17483                 "plscmap0(r, g, b, ncol0)\n"
17484                 "\n"
17485                 "ARGUMENTS:\n"
17486                 "\n"
17487                 "    r (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17488                 "    integers (0-255) representing the degree of red in the color. \n"
17489                 "\n"
17490                 "    g (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17491                 "    integers (0-255) representing the degree of green in the color. \n"
17492                 "\n"
17493                 "    b (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17494                 "    integers (0-255) representing the degree of blue in the color. \n"
17495                 "\n"
17496                 "    ncol0 (PLINT, input) :    Number of items in the r, g, and b arrays. \n"
17497                 "\n"
17498                 ""},
17499          { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
17500                 "Set color map0 colors by 8-bit RGB values and  double alpha value. \n"
17501                 "\n"
17502                 "DESCRIPTION:\n"
17503                 "\n"
17504                 "    Set color map0 colors using 8-bit RGB values (see the PLplot\n"
17505                 "    documentation)  and floating point alpha value.  This sets the entire\n"
17506                 "    color map -- only as many colors as specified will be allocated. \n"
17507                 "\n"
17508                 "    This function is used in examples 30. \n"
17509                 "\n"
17510                 "\n"
17511                 "\n"
17512                 "SYNOPSIS:\n"
17513                 "\n"
17514                 "plscmap0a(r, g, b, a, ncol0)\n"
17515                 "\n"
17516                 "ARGUMENTS:\n"
17517                 "\n"
17518                 "    r (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17519                 "    integers (0-255) representing the degree of red in the color. \n"
17520                 "\n"
17521                 "    g (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17522                 "    integers (0-255) representing the degree of green in the color. \n"
17523                 "\n"
17524                 "    b (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17525                 "    integers (0-255) representing the degree of blue in the color. \n"
17526                 "\n"
17527                 "    a (PLFLT *, input) :    Pointer to array with set of PLFLT values (0.0\n"
17528                 "    - 1.0) representing the transparency of the color. \n"
17529                 "\n"
17530                 "    ncol0 (PLINT, input) :    Number of items in the r, g, b, and a\n"
17531                 "    arrays. \n"
17532                 "\n"
17533                 ""},
17534          { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
17535                 "Set number of colors in color map0 \n"
17536                 "\n"
17537                 "DESCRIPTION:\n"
17538                 "\n"
17539                 "    Set number of colors in color map0 (see the PLplot documentation).\n"
17540                 "    Allocate (or reallocate) color map0, and fill with default values for\n"
17541                 "    those colors not previously allocated. The first 16 default colors are\n"
17542                 "    given in the plcol0 documentation. For larger indices the default\n"
17543                 "    color is red. \n"
17544                 "\n"
17545                 "    The drivers are not guaranteed to support more than 16 colors. \n"
17546                 "\n"
17547                 "    Redacted form: plscmap0n(ncol0)\n"
17548                 "\n"
17549                 "    This function is used in examples 15,16,24. \n"
17550                 "\n"
17551                 "\n"
17552                 "\n"
17553                 "SYNOPSIS:\n"
17554                 "\n"
17555                 "plscmap0n(ncol0)\n"
17556                 "\n"
17557                 "ARGUMENTS:\n"
17558                 "\n"
17559                 "    ncol0 (PLINT, input) :    Number of colors that will be allocated in\n"
17560                 "    the map0 palette. If this number is zero or less, then the value\n"
17561                 "    from the previous call to plscmap0n is used and if there is no\n"
17562                 "    previous call, then a default value is used. \n"
17563                 "\n"
17564                 ""},
17565          { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
17566                 "Set color map1 colors using 8-bit RGB values \n"
17567                 "\n"
17568                 "DESCRIPTION:\n"
17569                 "\n"
17570                 "    Set color map1 colors using 8-bit RGB values (see the PLplot\n"
17571                 "    documentation).  This also sets the number of colors. \n"
17572                 "\n"
17573                 "    Redacted form: plscmap1(r, g, b, ncol1)\n"
17574                 "\n"
17575                 "    This function is used in example 31. \n"
17576                 "\n"
17577                 "\n"
17578                 "\n"
17579                 "SYNOPSIS:\n"
17580                 "\n"
17581                 "plscmap1(r, g, b, ncol1)\n"
17582                 "\n"
17583                 "ARGUMENTS:\n"
17584                 "\n"
17585                 "    r (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17586                 "    integers (0-255) representing the degree of red in the color. \n"
17587                 "\n"
17588                 "    g (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17589                 "    integers (0-255) representing the degree of green in the color. \n"
17590                 "\n"
17591                 "    b (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17592                 "    integers (0-255) representing the degree of blue in the color. \n"
17593                 "\n"
17594                 "    ncol1 (PLINT, input) :    Number of items in the r, g, and b arrays. \n"
17595                 "\n"
17596                 ""},
17597          { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
17598                 "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
17599                 "\n"
17600                 "DESCRIPTION:\n"
17601                 "\n"
17602                 "    Set color map1 colors using 8-bit RGB values (see the PLplot\n"
17603                 "    documentation) and double alpha values. This also sets  the number of\n"
17604                 "    colors.\n"
17605                 "\n"
17606                 "    This function is used in example 31. \n"
17607                 "\n"
17608                 "\n"
17609                 "\n"
17610                 "SYNOPSIS:\n"
17611                 "\n"
17612                 "plscmap1a(r, g, b, a, ncol1)\n"
17613                 "\n"
17614                 "ARGUMENTS:\n"
17615                 "\n"
17616                 "    r (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17617                 "    integers (0-255) representing the degree of red in the color. \n"
17618                 "\n"
17619                 "    g (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17620                 "    integers (0-255) representing the degree of green in the color. \n"
17621                 "\n"
17622                 "    b (PLINT *, input) :    Pointer to array with set of unsigned 8-bit\n"
17623                 "    integers (0-255) representing the degree of blue in the color. \n"
17624                 "\n"
17625                 "    a (PLFLT *, input) :    Pointer to array with set of double values\n"
17626                 "    (0.0-1.0) representing the alpha value of the color. \n"
17627                 "\n"
17628                 "    ncol1 (PLINT, input) :    Number of items in the r, g, b, and a\n"
17629                 "    arrays. \n"
17630                 "\n"
17631                 ""},
17632          { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
17633                 "Set color map1 colors using a piece-wise linear relationship \n"
17634                 "\n"
17635                 "DESCRIPTION:\n"
17636                 "\n"
17637                 "    Set color map1 colors using a piece-wise linear relationship between\n"
17638                 "    position in the color map (from 0 to 1) and position in HLS or RGB\n"
17639                 "    color space (see the PLplot documentation).  May be called at any\n"
17640                 "    time. \n"
17641                 "\n"
17642                 "    The idea here is to specify a number of control points that define the\n"
17643                 "    mapping between palette 1 input positions (intensities) and HLS (or\n"
17644                 "    RGB).  Between these points, linear interpolation is used which gives\n"
17645                 "    a smooth variation of color with input position.  Any number of\n"
17646                 "    control points may be specified, located at arbitrary positions,\n"
17647                 "    although typically 2 - 4 are enough. Another way of stating this is\n"
17648                 "    that we are traversing a given number of lines through HLS (or RGB)\n"
17649                 "    space as we move through color map1 entries.  The control points at\n"
17650                 "    the minimum and maximum position (0 and 1) must always be specified. \n"
17651                 "    By adding more control points you can get more variation.  One good\n"
17652                 "    technique for plotting functions that vary about some expected average\n"
17653                 "    is to use an additional 2 control points in the center (position ~=\n"
17654                 "    0.5) that are the same lightness as the background (typically white\n"
17655                 "    for paper output, black for crt), and same hue as the boundary control\n"
17656                 "    points.  This allows the highs and lows to be very easily\n"
17657                 "    distinguished. \n"
17658                 "\n"
17659                 "    Each control point must specify the position in color map1 as well as\n"
17660                 "    three coordinates in HLS or RGB space.  The first point must\n"
17661                 "    correspond to position = 0, and the last to position = 1. \n"
17662                 "\n"
17663                 "    The hue is interpolated around the \"front\" of the color wheel\n"
17664                 "    (red<->green<->blue<->red) unless the \"rev\" flag is set to true, in\n"
17665                 "    which case interpolation (between the i and i + 1 control point for\n"
17666                 "    rev[i]) proceeds around the back (reverse) side.  Specifying rev=NULL\n"
17667                 "    is equivalent to setting rev[]= false for every control point. \n"
17668                 "\n"
17669                 "    Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
17670                 "    1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
17671                 "    1]magnitudeHLSsaturation[0, 1]magnitude\n"
17672                 "\n"
17673                 "    Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3, rev)\n"
17674                 "\n"
17675                 "    This function is used in examples 8,11,12,15,20,21. \n"
17676                 "\n"
17677                 "\n"
17678                 "\n"
17679                 "SYNOPSIS:\n"
17680                 "\n"
17681                 "plscmap1l(itype, npts, pos, coord1, coord2, coord3, rev)\n"
17682                 "\n"
17683                 "ARGUMENTS:\n"
17684                 "\n"
17685                 "    itype (PLBOOL, input) :    true: RGB, false: HLS. \n"
17686                 "\n"
17687                 "    npts (PLINT, input) :    number of control points \n"
17688                 "\n"
17689                 "    pos (PLFLT *, input) :    position for each control point (between 0.0\n"
17690                 "    and 1.0, in ascending order) \n"
17691                 "\n"
17692                 "    coord1 (PLFLT *, input) :     first coordinate (H or R) for each\n"
17693                 "    control point \n"
17694                 "\n"
17695                 "    coord2 (PLFLT *, input) :     second coordinate (L or G) for each\n"
17696                 "    control point \n"
17697                 "\n"
17698                 "    coord3 (PLFLT *, input) :     third coordinate (S or B) for each\n"
17699                 "    control point \n"
17700                 "\n"
17701                 "    rev (PLBOOL: *, input) :    reverse flag for each control point.\n"
17702                 "    (rev[i] refers to the interpolation interval between the i and i +\n"
17703                 "    1 control points). \n"
17704                 "\n"
17705                 ""},
17706          { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
17707                 "Set color map1 colors using a piece-wise linear relationship \n"
17708                 "\n"
17709                 "DESCRIPTION:\n"
17710                 "\n"
17711                 "    This is a version of plscmap1l that supports alpha transparency. It\n"
17712                 "    sets color map1 colors using a piece-wise linear relationship between\n"
17713                 "    position in the color map (from 0 to 1) and position in HLS or RGB\n"
17714                 "    color space (see the PLplot documentation) with alpha value (0.0 -\n"
17715                 "    1.0). It may be called at any time. \n"
17716                 "\n"
17717                 "    This function is used in example 30. \n"
17718                 "\n"
17719                 "\n"
17720                 "\n"
17721                 "SYNOPSIS:\n"
17722                 "\n"
17723                 "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, rev)\n"
17724                 "\n"
17725                 "ARGUMENTS:\n"
17726                 "\n"
17727                 "    itype (PLBOOL, input) :    true: RGB, false: HLS. \n"
17728                 "\n"
17729                 "    npts (PLINT, input) :    number of control points \n"
17730                 "\n"
17731                 "    pos (PLFLT *, input) :    position for each control point (between 0.0\n"
17732                 "    and 1.0, in ascending order) \n"
17733                 "\n"
17734                 "    coord1 (PLFLT *, input) :     first coordinate (H or R) for each\n"
17735                 "    control point \n"
17736                 "\n"
17737                 "    coord2 (PLFLT *, input) :     second coordinate (L or G) for each\n"
17738                 "    control point \n"
17739                 "\n"
17740                 "    coord3 (PLFLT *, input) :     third coordinate (S or B) for each\n"
17741                 "    control point \n"
17742                 "\n"
17743                 "    coord4 (PLFLT *, input) :     fourth coordinate, the alpha value for\n"
17744                 "    each control point \n"
17745                 "\n"
17746                 "    rev (PLBOOL: *, input) :    reverse flag for each control point.\n"
17747                 "    (rev[i] refers to the interpolation interval between the i and i +\n"
17748                 "    1 control points). \n"
17749                 "\n"
17750                 ""},
17751          { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
17752                 "Set number of colors in color map1 \n"
17753                 "\n"
17754                 "DESCRIPTION:\n"
17755                 "\n"
17756                 "    Set number of colors in color map1, (re-)allocate color map1, and set\n"
17757                 "    default values if this is the first allocation (see the PLplot\n"
17758                 "    documentation). \n"
17759                 "\n"
17760                 "    Redacted form: plscmap1n(ncol1)\n"
17761                 "\n"
17762                 "    This function is used in examples 8,11,20,21. \n"
17763                 "\n"
17764                 "\n"
17765                 "\n"
17766                 "SYNOPSIS:\n"
17767                 "\n"
17768                 "plscmap1n(ncol1)\n"
17769                 "\n"
17770                 "ARGUMENTS:\n"
17771                 "\n"
17772                 "    ncol1 (PLINT, input) :    Number of colors that will be allocated in\n"
17773                 "    the map1 palette. If this number is zero or less, then the value\n"
17774                 "    from the previous call to plscmap1n is used and if there is no\n"
17775                 "    previous call, then a default value is used. \n"
17776                 "\n"
17777                 ""},
17778          { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
17779                 "Set a given color from color map0 by 8 bit RGB value \n"
17780                 "\n"
17781                 "ESCRIPTION:\n"
17782                 "\n"
17783                 "   Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
17784                 "   documentation).  Overwrites the previous color value for the given\n"
17785                 "   index and, thus, does not result in any additional allocation of space\n"
17786                 "   for colors. \n"
17787                 "\n"
17788                 "   Redacted form: plscol0(icol0, r, g, b)\n"
17789                 "\n"
17790                 "   This function is not used in any examples. \n"
17791                 "\n"
17792                 "\n"
17793                 "\n"
17794                 "YNOPSIS:\n"
17795                 "\n"
17796                 "lscol0(icol0, r, g, b)\n"
17797                 "\n"
17798                 "RGUMENTS:\n"
17799                 "\n"
17800                 "   icol0 (PLINT, input) :    Color index.  Must be less than the maximum\n"
17801                 "   number of colors (which is set by default, by plscmap0n, or even\n"
17802                 "   by plscmap0). \n"
17803                 "\n"
17804                 "   r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17805                 "   degree of red in the color. \n"
17806                 "\n"
17807                 "   g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17808                 "   degree of green in the color. \n"
17809                 "\n"
17810                 "   b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17811                 "   degree of blue in the color. \n"
17812                 "\n"
17813                 ""},
17814          { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
17815                 "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
17816                 "\n"
17817                 "ESCRIPTION:\n"
17818                 "\n"
17819                 "   Set a given color by 8-bit RGB value and double alpha value for color \n"
17820                 "   map0 (see the PLplot documentation).  Overwrites the previous color\n"
17821                 "   value  for the given index and, thus, does not result in any\n"
17822                 "   additional allocation  of space for colors. \n"
17823                 "\n"
17824                 "   This function is used in example 30. \n"
17825                 "\n"
17826                 "\n"
17827                 "\n"
17828                 "YNOPSIS:\n"
17829                 "\n"
17830                 "lscol0a(icol0, r, g, b, a)\n"
17831                 "\n"
17832                 "RGUMENTS:\n"
17833                 "\n"
17834                 "   icol0 (PLINT, input) :    Color index.  Must be less than the maximum\n"
17835                 "   number of colors (which is set by default, by plscmap0n, or even\n"
17836                 "   by plscmap0). \n"
17837                 "\n"
17838                 "   r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17839                 "   degree of red in the color. \n"
17840                 "\n"
17841                 "   g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17842                 "   degree of green in the color. \n"
17843                 "\n"
17844                 "   b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17845                 "   degree of blue in the color. \n"
17846                 "\n"
17847                 "   a (PLFLT, input) :      double value (0.0-1.0) representing the alpha\n"
17848                 "   value of the color. \n"
17849                 "\n"
17850                 ""},
17851          { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
17852                 "Set the background color by 8-bit RGB value \n"
17853                 "\n"
17854                 "DESCRIPTION:\n"
17855                 "\n"
17856                 "    Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
17857                 "    (see the PLplot documentation). \n"
17858                 "\n"
17859                 "    Redacted form: plscolbg(r, g, b)\n"
17860                 "\n"
17861                 "    This function is used in examples 15,31. \n"
17862                 "\n"
17863                 "\n"
17864                 "\n"
17865                 "SYNOPSIS:\n"
17866                 "\n"
17867                 "plscolbg(r, g, b)\n"
17868                 "\n"
17869                 "ARGUMENTS:\n"
17870                 "\n"
17871                 "    r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17872                 "    degree of red in the color. \n"
17873                 "\n"
17874                 "    g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17875                 "    degree of green in the color. \n"
17876                 "\n"
17877                 "    b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17878                 "    degree of blue in the color. \n"
17879                 "\n"
17880                 ""},
17881          { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
17882                 "Set the background color by 8-bit RGB value and double alpha value. \n"
17883                 "\n"
17884                 "DESCRIPTION:\n"
17885                 "\n"
17886                 "    Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
17887                 "    (see the PLplot documentation) and double alpha value. \n"
17888                 "\n"
17889                 "    This function is used in example 31. \n"
17890                 "\n"
17891                 "\n"
17892                 "\n"
17893                 "SYNOPSIS:\n"
17894                 "\n"
17895                 "plscolbga(r, g, b, a)\n"
17896                 "\n"
17897                 "ARGUMENTS:\n"
17898                 "\n"
17899                 "    r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17900                 "    degree of red in the color. \n"
17901                 "\n"
17902                 "    g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17903                 "    degree of green in the color. \n"
17904                 "\n"
17905                 "    b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
17906                 "    degree of blue in the color. \n"
17907                 "\n"
17908                 "    a (PLFLT, input) :      double value (0.0-1.0) representing the alpha\n"
17909                 "    value of the color. \n"
17910                 "\n"
17911                 ""},
17912          { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
17913                 "Used to globally turn color output on/off \n"
17914                 "\n"
17915                 "DESCRIPTION:\n"
17916                 "\n"
17917                 "    Used to globally turn color output on/off for those drivers/devices\n"
17918                 "    that support it. \n"
17919                 "\n"
17920                 "    Redacted form: plscolor(color)\n"
17921                 "\n"
17922                 "    This function is used in example 31. \n"
17923                 "\n"
17924                 "\n"
17925                 "\n"
17926                 "SYNOPSIS:\n"
17927                 "\n"
17928                 "plscolor(color)\n"
17929                 "\n"
17930                 "ARGUMENTS:\n"
17931                 "\n"
17932                 "    color (PLINT, input) :    Color flag (Boolean).  If zero, color is\n"
17933                 "    turned off.  If non-zero, color is turned on. \n"
17934                 "\n"
17935                 ""},
17936          { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
17937                 "Set device-compression level \n"
17938                 "\n"
17939                 "DESCRIPTION:\n"
17940                 "\n"
17941                 "    Set device-compression level.  Only used for drivers that provide\n"
17942                 "    compression.  This function, if used, should be invoked before a call\n"
17943                 "    to plinit. \n"
17944                 "\n"
17945                 "    Redacted form: plscompression(compression)\n"
17946                 "\n"
17947                 "    This function is used in example 31. \n"
17948                 "\n"
17949                 "\n"
17950                 "\n"
17951                 "SYNOPSIS:\n"
17952                 "\n"
17953                 "plscompression(compression)\n"
17954                 "\n"
17955                 "ARGUMENTS:\n"
17956                 "\n"
17957                 "    compression (PLINT, input) :    The desired compression level. This is\n"
17958                 "    a device-dependent value. Currently only the jpeg and png devices\n"
17959                 "    use these values. For jpeg  value is the jpeg quality which should\n"
17960                 "    normally be in the range 0-95. Higher values denote higher quality\n"
17961                 "    and hence larger image sizes. For png values are in the range -1\n"
17962                 "    to 99. Values of 0-9 are taken as the  compression level for zlib.\n"
17963                 "    A value of -1 denotes the default zlib    compression level. Values\n"
17964                 "    in the range 10-99 are divided by 10 and  then used as the zlib\n"
17965                 "    compression level. Higher compression levels correspond to greater\n"
17966                 "    compression and small file sizes at the expense of more\n"
17967                 "    computation. \n"
17968                 "\n"
17969                 ""},
17970          { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
17971                 "Set the device (keyword) name \n"
17972                 "\n"
17973                 "DESCRIPTION:\n"
17974                 "\n"
17975                 "    Set the device (keyword) name. \n"
17976                 "\n"
17977                 "    Redacted form: plsdev(devname)\n"
17978                 "\n"
17979                 "    This function is used in examples 1,14,20. \n"
17980                 "\n"
17981                 "\n"
17982                 "\n"
17983                 "SYNOPSIS:\n"
17984                 "\n"
17985                 "plsdev(devname)\n"
17986                 "\n"
17987                 "ARGUMENTS:\n"
17988                 "\n"
17989                 "    devname (const char *, input) :    Pointer to device (keyword) name\n"
17990                 "    string. \n"
17991                 "\n"
17992                 ""},
17993          { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
17994                 "Set parameters that define current device-space window \n"
17995                 "\n"
17996                 "DESCRIPTION:\n"
17997                 "\n"
17998                 "    Set relative margin width, aspect ratio, and relative justification\n"
17999                 "    that define current device-space window.  If you want to just use the\n"
18000                 "    previous value for any of these, just pass in the magic value\n"
18001                 "    PL_NOTSET. It is unlikely that one should ever need to change the\n"
18002                 "    aspect ratio but it's in there for completeness. If plsdidev is not\n"
18003                 "    called the default values of mar, jx, and jy are all 0. aspect is set\n"
18004                 "    to a device-specific value. \n"
18005                 "\n"
18006                 "    Redacted form: plsdidev(mar, aspect, jx, jy)\n"
18007                 "\n"
18008                 "    This function is used in example 31. \n"
18009                 "\n"
18010                 "\n"
18011                 "\n"
18012                 "SYNOPSIS:\n"
18013                 "\n"
18014                 "plsdidev(mar, aspect, jx, jy)\n"
18015                 "\n"
18016                 "ARGUMENTS:\n"
18017                 "\n"
18018                 "    mar (PLFLT, input) :    Relative margin width. \n"
18019                 "\n"
18020                 "    aspect (PLFLT, input) :    Aspect ratio. \n"
18021                 "\n"
18022                 "    jx (PLFLT, input) :    Relative justification in x. Value must lie in\n"
18023                 "    the range -0.5 to 0.5. \n"
18024                 "\n"
18025                 "    jy (PLFLT, input) :    Relative justification in y. Value must lie in\n"
18026                 "    the range -0.5 to 0.5. \n"
18027                 "\n"
18028                 ""},
18029          { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
18030                 "Set up transformation from metafile coordinates \n"
18031                 "\n"
18032                 "DESCRIPTION:\n"
18033                 "\n"
18034                 "    Set up transformation from metafile coordinates.  The size of the plot\n"
18035                 "    is scaled so as to preserve aspect ratio.  This isn't intended to be a\n"
18036                 "    general-purpose facility just yet (not sure why the user would need\n"
18037                 "    it, for one). \n"
18038                 "\n"
18039                 "    Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
18040                 "    dimypmm)\n"
18041                 "\n"
18042                 "    This function is not used in any examples. \n"
18043                 "\n"
18044                 "\n"
18045                 "\n"
18046                 "SYNOPSIS:\n"
18047                 "\n"
18048                 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
18049                 "\n"
18050                 "ARGUMENTS:\n"
18051                 "\n"
18052                 "    dimxmin (PLINT, input) :    NEEDS DOCUMENTATION \n"
18053                 "\n"
18054                 "    dimxmax (PLINT, input) :    NEEDS DOCUMENTATION \n"
18055                 "\n"
18056                 "    dimymin (PLINT, input) :    NEEDS DOCUMENTATION \n"
18057                 "\n"
18058                 "    dimymax (PLINT, input) :    NEEDS DOCUMENTATION \n"
18059                 "\n"
18060                 "    dimxpmm (PLFLT, input) :    NEEDS DOCUMENTATION \n"
18061                 "\n"
18062                 "    dimypmm (PLFLT, input) :    NEEDS DOCUMENTATION \n"
18063                 "\n"
18064                 ""},
18065          { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
18066                 "Set plot orientation \n"
18067                 "\n"
18068                 "DESCRIPTION:\n"
18069                 "\n"
18070                 "    Set plot orientation parameter which is multiplied by 90 degrees to\n"
18071                 "    obtain the angle of rotation.  Note, arbitrary rotation parameters\n"
18072                 "    such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
18073                 "    values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
18074                 "    to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
18075                 "    (seascape mode), and 270 degrees (upside-down mode).  If plsdiori is\n"
18076                 "    not called the default value of rot is 0. \n"
18077                 "\n"
18078                 "    N.B. aspect ratio is unaffected by calls to plsdiori.  So you will\n"
18079                 "    probably want to change the aspect ratio to a value suitable for the\n"
18080                 "    plot orientation using a call to plsdidev or the command-line options\n"
18081                 "    -a or -freeaspect. For more documentation of those options see the\n"
18082                 "    PLplot documentation.  Such command-line options can be set internally\n"
18083                 "    using plsetopt or set directly using the command line and parsed using\n"
18084                 "    a call to  plparseopts. \n"
18085                 "\n"
18086                 "    Redacted form: plsdiori(rot)\n"
18087                 "\n"
18088                 "    This function is not used in any examples. \n"
18089                 "\n"
18090                 "\n"
18091                 "\n"
18092                 "SYNOPSIS:\n"
18093                 "\n"
18094                 "plsdiori(rot)\n"
18095                 "\n"
18096                 "ARGUMENTS:\n"
18097                 "\n"
18098                 "    rot (PLFLT, input) :    Plot orientation parameter. \n"
18099                 "\n"
18100                 ""},
18101          { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
18102                 "Set parameters that define current plot-space window \n"
18103                 "\n"
18104                 "DESCRIPTION:\n"
18105                 "\n"
18106                 "    Set relative minima and maxima that define the current plot-space\n"
18107                 "    window.  If plsdiplt is not called the default values of xmin, ymin,\n"
18108                 "    xmax, and ymax are 0., 0., 1., and 1. \n"
18109                 "\n"
18110                 "    Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
18111                 "\n"
18112                 "    This function is used in example 31. \n"
18113                 "\n"
18114                 "\n"
18115                 "\n"
18116                 "SYNOPSIS:\n"
18117                 "\n"
18118                 "plsdiplt(xmin, ymin, xmax, ymax)\n"
18119                 "\n"
18120                 "ARGUMENTS:\n"
18121                 "\n"
18122                 "    xmin (PLFLT, input) :    Relative minimum in x. \n"
18123                 "\n"
18124                 "    ymin (PLFLT, input) :    Relative minimum in y. \n"
18125                 "\n"
18126                 "    xmax (PLFLT, input) :    Relative maximum in x. \n"
18127                 "\n"
18128                 "    ymax (PLFLT, input) :    Relative maximum in y. \n"
18129                 "\n"
18130                 ""},
18131          { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
18132                 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
18133                 "\n"
18134                 "DESCRIPTION:\n"
18135                 "\n"
18136                 "    Set relative minima and maxima incrementally (zoom mode) that define\n"
18137                 "    the current plot-space window.  This function has the same effect as\n"
18138                 "    plsdiplt if that function has not been previously called.  Otherwise,\n"
18139                 "    this function implements zoom mode using the transformation min_used =\n"
18140                 "    old_min + old_length*min  and max_used = old_min + old_length*max  for\n"
18141                 "    each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
18142                 "    repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
18143                 "\n"
18144                 "    Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
18145                 "\n"
18146                 "    This function is used in example 31. \n"
18147                 "\n"
18148                 "\n"
18149                 "\n"
18150                 "SYNOPSIS:\n"
18151                 "\n"
18152                 "plsdiplz(xmin, ymin, xmax, ymax)\n"
18153                 "\n"
18154                 "ARGUMENTS:\n"
18155                 "\n"
18156                 "    xmin (PLFLT, input) :    Relative (incremental) minimum in x. \n"
18157                 "\n"
18158                 "    ymin (PLFLT, input) :    Relative (incremental) minimum in y. \n"
18159                 "\n"
18160                 "    xmax (PLFLT, input) :    Relative (incremental) maximum in x. \n"
18161                 "\n"
18162                 "    ymax (PLFLT, input) :    Relative (incremental) maximum in y. \n"
18163                 "\n"
18164                 ""},
18165          { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
18166                 "Set seed for internal random  number generator. \n"
18167                 "\n"
18168                 "DESCRIPTION:\n"
18169                 "\n"
18170                 "    Set the seed for the internal random number generator. See plrandd for\n"
18171                 "    further details. \n"
18172                 "\n"
18173                 "    Redacted form: plseed(seed)\n"
18174                 "\n"
18175                 "    This function is used in example 21. \n"
18176                 "\n"
18177                 "\n"
18178                 "\n"
18179                 "SYNOPSIS:\n"
18180                 "\n"
18181                 "plseed(seed)\n"
18182                 "\n"
18183                 "ARGUMENTS:\n"
18184                 "\n"
18185                 "    seed (unsigned int, input) :    Seed for random number generator. \n"
18186                 "\n"
18187                 ""},
18188          { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
18189                 "Set the escape character for text strings \n"
18190                 "\n"
18191                 "DESCRIPTION:\n"
18192                 "\n"
18193                 "    Set the escape character for text strings. From C (in contrast to\n"
18194                 "    Fortran 77, see plsescfortran77) you pass esc as a character. Only\n"
18195                 "    selected characters are allowed to prevent the user from shooting\n"
18196                 "    himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
18197                 "    with C's use of backslash as a character escape).  Here are the\n"
18198                 "    allowed escape characters and their corresponding decimal ASCII\n"
18199                 "    values: !, ASCII 33 \n"
18200                 "           #, ASCII 35 \n"
18201                 "           $, ASCII 36 \n"
18202                 "           %, ASCII 37 \n"
18203                 "           &, ASCII 38 \n"
18204                 "           *, ASCII 42 \n"
18205                 "           @, ASCII 64 \n"
18206                 "           ^, ASCII 94 \n"
18207                 "           ~, ASCII 126 \n"
18208                 "\n"
18209                 "\n"
18210                 "    Redacted form:  General: plsesc(esc)\n"
18211                 "           Perl/PDL: Not available? \n"
18212                 "\n"
18213                 "\n"
18214                 "    This function is used in example 29. \n"
18215                 "\n"
18216                 "\n"
18217                 "\n"
18218                 "SYNOPSIS:\n"
18219                 "\n"
18220                 "plsesc(esc)\n"
18221                 "\n"
18222                 "ARGUMENTS:\n"
18223                 "\n"
18224                 "    esc (char, input) :    Escape character. \n"
18225                 "\n"
18226                 ""},
18227          { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
18228                 "Set any command-line option \n"
18229                 "\n"
18230                 "DESCRIPTION:\n"
18231                 "\n"
18232                 "    Set any command-line option internally from a program before it\n"
18233                 "    invokes plinit. opt is the name of the command-line option and optarg\n"
18234                 "    is the corresponding command-line option argument. \n"
18235                 "\n"
18236                 "    This function returns 0 on success. \n"
18237                 "\n"
18238                 "    Redacted form: plsetopt(opt, optarg)\n"
18239                 "\n"
18240                 "    This function is used in example 14. \n"
18241                 "\n"
18242                 "\n"
18243                 "\n"
18244                 "SYNOPSIS:\n"
18245                 "\n"
18246                 "int plsetopt(opt, optarg)\n"
18247                 "\n"
18248                 "ARGUMENTS:\n"
18249                 "\n"
18250                 "    opt (const char *, input) :    Pointer to string containing the\n"
18251                 "    command-line option. \n"
18252                 "\n"
18253                 "    optarg (const char *, input) :    Pointer to string containing the\n"
18254                 "    argument of the command-line option. \n"
18255                 "\n"
18256                 ""},
18257          { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
18258                 "Set family file parameters \n"
18259                 "\n"
18260                 "DESCRIPTION:\n"
18261                 "\n"
18262                 "    Sets variables dealing with output file familying. Does nothing if\n"
18263                 "    familying not supported by the driver.  This routine, if used, must be\n"
18264                 "    called before initializing PLplot. See the PLplot documentation for\n"
18265                 "    more information. \n"
18266                 "\n"
18267                 "    Redacted form: plsfam(fam, num, bmax)\n"
18268                 "\n"
18269                 "    This function is used in examples 14,31. \n"
18270                 "\n"
18271                 "\n"
18272                 "\n"
18273                 "SYNOPSIS:\n"
18274                 "\n"
18275                 "plsfam(fam, num, bmax)\n"
18276                 "\n"
18277                 "ARGUMENTS:\n"
18278                 "\n"
18279                 "    fam (PLINT, input) :    Family flag (Boolean).  If nonzero, familying\n"
18280                 "    is enabled. \n"
18281                 "\n"
18282                 "    num (PLINT, input) :    Current family file number. \n"
18283                 "\n"
18284                 "    bmax (PLINT, input) :    Maximum file size (in bytes) for a family\n"
18285                 "    file. \n"
18286                 "\n"
18287                 ""},
18288          { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
18289                 "Set FCI (font characterization integer) \n"
18290                 "\n"
18291                 "DESCRIPTION:\n"
18292                 "\n"
18293                 "    Sets font characteristics to be used at the start of the next string\n"
18294                 "    using the FCI approach. See the PLplot documentation for more\n"
18295                 "    information. \n"
18296                 "\n"
18297                 "    Redacted form:  General: plsfci(fci)\n"
18298                 "           Perl/PDL: Not available? \n"
18299                 "\n"
18300                 "\n"
18301                 "    This function is used in example 23. \n"
18302                 "\n"
18303                 "\n"
18304                 "\n"
18305                 "SYNOPSIS:\n"
18306                 "\n"
18307                 "plsfci(fci)\n"
18308                 "\n"
18309                 "ARGUMENTS:\n"
18310                 "\n"
18311                 "    fci (PLUNICODE, input) :    PLUNICODE (unsigned 32-bit integer) value\n"
18312                 "    of FCI. \n"
18313                 "\n"
18314                 ""},
18315          { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
18316                 "Set output file name \n"
18317                 "\n"
18318                 "DESCRIPTION:\n"
18319                 "\n"
18320                 "    Sets the current output file name, if applicable.  If the file name\n"
18321                 "    has not been specified and is required by the driver, the user will be\n"
18322                 "    prompted for it.  If using the X-windows output driver, this sets the\n"
18323                 "    display name.  This routine, if used, must be called before\n"
18324                 "    initializing PLplot. \n"
18325                 "\n"
18326                 "    Redacted form: plsfnam(fnam)\n"
18327                 "\n"
18328                 "    This function is used in examples 1,20. \n"
18329                 "\n"
18330                 "\n"
18331                 "\n"
18332                 "SYNOPSIS:\n"
18333                 "\n"
18334                 "plsfnam(fnam)\n"
18335                 "\n"
18336                 "ARGUMENTS:\n"
18337                 "\n"
18338                 "    fnam (const char *, input) :    Pointer to file name string. \n"
18339                 "\n"
18340                 ""},
18341          { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
18342                 "Set family, style and weight of the current font \n"
18343                 "\n"
18344                 "DESCRIPTION:\n"
18345                 "\n"
18346                 "    Sets the current font.  See the PLplot documentation for more\n"
18347                 "    information on font selection. \n"
18348                 "\n"
18349                 "    Redacted form: plsfont(family, style, weight)\n"
18350                 "\n"
18351                 "    This function is used in example 23. \n"
18352                 "\n"
18353                 "\n"
18354                 "\n"
18355                 "SYNOPSIS:\n"
18356                 "\n"
18357                 "plsfont(family, style, weight)\n"
18358                 "\n"
18359                 "ARGUMENTS:\n"
18360                 "\n"
18361                 "    family (PLINT, input) :    Font family to select for the current font.\n"
18362                 "    The available values are given by the PL_FCI_* constants in\n"
18363                 "    plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
18364                 "    PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
18365                 "    signifies that the font family should not be altered.  \n"
18366                 "\n"
18367                 "    style (PLINT, input) :    Font style to select for the current font.\n"
18368                 "    The available values are given by the PL_FCI_* constants in\n"
18369                 "    plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
18370                 "    PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
18371                 "    should not be altered.    \n"
18372                 "\n"
18373                 "    weight (PLINT, input) :    Font weight to select for the current font.\n"
18374                 "    The available values are given by the PL_FCI_* constants in\n"
18375                 "    plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
18376                 "    negative value signifies that the font weight should not be\n"
18377                 "    altered.  \n"
18378                 "\n"
18379                 ""},
18380          { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
18381                 "Shade regions on the basis of value \n"
18382                 "\n"
18383                 "DESCRIPTION:\n"
18384                 "\n"
18385                 "    Shade regions on the basis of value.  This is the high-level routine\n"
18386                 "    for making continuous color shaded plots with cmap1 while plshade (or\n"
18387                 "    plshade1) are used for individual shaded regions using either cmap0 or\n"
18388                 "    cmap1. examples/c/x16c.c shows a number of examples for using this\n"
18389                 "    function. See the following discussion of the arguments and the PLplot\n"
18390                 "    documentation for more information.    \n"
18391                 "\n"
18392                 "    Redacted form:  General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
18393                 "    clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
18394                 "    pltr_data)\n"
18395                 "           Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
18396                 "    fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
18397                 "    pltr_data)\n"
18398                 "\n"
18399                 "\n"
18400                 "    This function is used in examples 16,21. \n"
18401                 "\n"
18402                 "\n"
18403                 "\n"
18404                 "SYNOPSIS:\n"
18405                 "\n"
18406                 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
18407                 "\n"
18408                 "ARGUMENTS:\n"
18409                 "\n"
18410                 "    a (PLFLT **, input) :    Contains ** pointer to array to be plotted.\n"
18411                 "    The array must have been declared as PLFLT a[nx][ny]. \n"
18412                 "\n"
18413                 "    nx (PLINT, input) :    First dimension of array \"a\". \n"
18414                 "\n"
18415                 "    ny (PLINT, input) :    Second dimension of array \"a\". \n"
18416                 "\n"
18417                 "    defined (PLINT (*) (PLFLT, PLFLT), input) :    User function\n"
18418                 "    specifying regions excluded from the shading plot.  This function\n"
18419                 "    accepts x and y coordinates as input arguments and must return 0\n"
18420                 "    if the point is in the excluded region or 1 otherwise. This\n"
18421                 "    argument can be NULL if all the values are valid. \n"
18422                 "\n"
18423                 "    xmin (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
18424                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18425                 "    at (xmax,ymin) and so on. \n"
18426                 "\n"
18427                 "    xmax (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
18428                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18429                 "    at (xmax,ymin) and so on. \n"
18430                 "\n"
18431                 "    ymin (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
18432                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18433                 "    at (xmax,ymin) and so on. \n"
18434                 "\n"
18435                 "    ymax (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
18436                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
18437                 "    at (xmax,ymin) and so on. \n"
18438                 "\n"
18439                 "    clevel (PLFLT *, input) :     Pointer to array containing the data\n"
18440                 "    levels corresponding to the edges of each shaded region that will\n"
18441                 "    be plotted by this function.  To work properly the levels should\n"
18442                 "    be monotonic. \n"
18443                 "\n"
18444                 "    nlevel (PLINT, input) :    Number of shades plus 1 (i.e., the number\n"
18445                 "    of shade edge values in clevel). \n"
18446                 "\n"
18447                 "    fill_width (PLINT, input) :    Defines width used by the fill pattern. \n"
18448                 "\n"
18449                 "    cont_color (PLINT, input) :    Defines pen color used for contours\n"
18450                 "    defining edges of shaded regions.  The pen color is only temporary\n"
18451                 "    set for the contour drawing.  Set this value to zero or less if no\n"
18452                 "    shade edge contours are wanted. \n"
18453                 "\n"
18454                 "    cont_width (PLINT, input) :    Defines pen width used for contours\n"
18455                 "    defining edges of shaded regions.  This value may not be honored\n"
18456                 "    by all drivers. The pen width is only temporary set for the\n"
18457                 "    contour drawing.  Set this value to zero or less if no shade edge\n"
18458                 "    contours are wanted. \n"
18459                 "\n"
18460                 "    fill (void (*) (PLINT, PLFLT *, PLFLT *), input) :      Routine used to\n"
18461                 "    fill the region.  Use plfill.  Future version of PLplot may have\n"
18462                 "    other fill routines. \n"
18463                 "\n"
18464                 "    rectangular (PLBOOL, input) :    Set rectangular to true if rectangles\n"
18465                 "    map to rectangles after coordinate transformation with pltrl. \n"
18466                 "    Otherwise, set rectangular to false. If rectangular is set to\n"
18467                 "    true, plshade tries to save time by filling large rectangles. \n"
18468                 "    This optimization fails if the coordinate transformation distorts\n"
18469                 "    the shape of rectangles. For example a plot in polar coordinates\n"
18470                 "    has to have  rectangular set to false. \n"
18471                 "\n"
18472                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
18473                 "      Pointer to function that defines transformation between indices\n"
18474                 "    in array z and the world coordinates (C only).    Transformation\n"
18475                 "    functions are provided in the PLplot library: pltr0 for identity\n"
18476                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
18477                 "    defined by one- and two-dimensional arrays.  In addition,\n"
18478                 "    user-supplied routines for the transformation can be used as well.\n"
18479                 "     Examples of all of these approaches are given in the PLplot\n"
18480                 "    documentation. The transformation function should have the form\n"
18481                 "    given by any of pltr0, pltr1, or pltr2. \n"
18482                 "\n"
18483                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
18484                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
18485                 "    externally supplied. \n"
18486                 "\n"
18487                 ""},
18488          { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
18489                 "Shade individual region on the basis of value \n"
18490                 "\n"
18491                 "ESCRIPTION:\n"
18492                 "\n"
18493                 "   Shade individual region on the basis of value.  Use plshades if you\n"
18494                 "   want to shade a number of regions using continuous colors. plshade is\n"
18495                 "   identical to plshade1 except for the type of the first parameter. See\n"
18496                 "   plshade1 for further discussion. \n"
18497                 "\n"
18498                 "   Redacted form:  General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
18499                 "   shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
18500                 "   min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
18501                 "    Perl/PDL: Not available? \n"
18502                 "\n"
18503                 "\n"
18504                 "   This function is used in example 15. \n"
18505                 "\n"
18506                 "\n"
18507                 "\n"
18508                 "YNOPSIS:\n"
18509                 "\n"
18510                 "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
18511                 "\n"
18512                 "RGUMENTS:\n"
18513                 "\n"
18514                 "   a (PLFLT **, input) :    \n"
18515                 "\n"
18516                 "   nx (PLINT, input) :    \n"
18517                 "\n"
18518                 "   ny (PLINT, input) :    \n"
18519                 "\n"
18520                 "   defined (PLINT (*) (PLFLT, PLFLT), input) :    \n"
18521                 "\n"
18522                 "   xmin (PLFLT, input) :    \n"
18523                 "\n"
18524                 "   xmax (PLFLT, input) :    \n"
18525                 "\n"
18526                 "   ymin (PLFLT, input) :    \n"
18527                 "\n"
18528                 "   ymax (PLFLT, input) :    \n"
18529                 "\n"
18530                 "   shade_min (PLFLT, input) :      \n"
18531                 "\n"
18532                 "   shade_max (PLFLT, input) :      \n"
18533                 "\n"
18534                 "   sh_cmap (PLINT, input) :    \n"
18535                 "\n"
18536                 "   sh_color (PLFLT, input) :     \n"
18537                 "\n"
18538                 "   sh_width (PLINT, input) :     \n"
18539                 "\n"
18540                 "   min_color (PLINT, input) :      \n"
18541                 "\n"
18542                 "   min_width (PLINT, input) :      \n"
18543                 "\n"
18544                 "   max_color (PLINT, input) :      \n"
18545                 "\n"
18546                 "   max_width (PLINT, input) :      \n"
18547                 "\n"
18548                 "   fill (void (*) (PLINT, PLFLT *, PLFLT *), input) :      \n"
18549                 "\n"
18550                 "   rectangular (PLBOOL, input) :    \n"
18551                 "\n"
18552                 "   pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) :  \n"
18553                 "\n"
18554                 "   pltr_data (PLPointer, input) :    \n"
18555                 "\n"
18556                 ""},
18557          { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
18558                 "Assign a function to use for generating custom axis labels \n"
18559                 "\n"
18560                 "DESCRIPTION:\n"
18561                 "\n"
18562                 "    This function allows a user to provide their own function to provide\n"
18563                 "    axis label text.  The user function is given the numeric value for a\n"
18564                 "    point on an axis and returns a string label to correspond with that\n"
18565                 "    value.  Custom axis labels can be enabled by passing appropriate\n"
18566                 "    arguments to plenv, plbox, plbox3 and similar functions. \n"
18567                 "\n"
18568                 "    This function is used in example 19. \n"
18569                 "\n"
18570                 "\n"
18571                 "\n"
18572                 "SYNOPSIS:\n"
18573                 "\n"
18574                 "plslabelfunc(label_func, label_data)\n"
18575                 "\n"
18576                 "ARGUMENTS:\n"
18577                 "\n"
18578                 "    label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) :  \n"
18579                 "     This is the custom label function.  In order to reset to the\n"
18580                 "    default labeling, set this to NULL. The labeling function\n"
18581                 "    parameters are, in order: axis:    This indicates which axis a\n"
18582                 "    label is being requested for. The value will be one of PL_X_AXIS,\n"
18583                 "    PL_Y_AXIS or PL_Z_AXIS. \n"
18584                 "\n"
18585                 "    value:    This is the value along the axis which is being labeled. \n"
18586                 "\n"
18587                 "    label_text:    The string representation of the label value. \n"
18588                 "\n"
18589                 "    length:    The maximum length in characters allowed for label_text. \n"
18590                 "\n"
18591                 "\n"
18592                 "    label_data (void *, input) :    This parameter may be used to pass\n"
18593                 "    data to the label_func function. \n"
18594                 "\n"
18595                 ""},
18596          { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
18597                 "Set length of major ticks \n"
18598                 "\n"
18599                 "DESCRIPTION:\n"
18600                 "\n"
18601                 "    This sets up the length of the major ticks.  The actual length is the\n"
18602                 "    product of the default length and a scaling factor as for character\n"
18603                 "    height. \n"
18604                 "\n"
18605                 "    Redacted form: plsmaj(def, scale)\n"
18606                 "\n"
18607                 "    This function is used in example 29. \n"
18608                 "\n"
18609                 "\n"
18610                 "\n"
18611                 "SYNOPSIS:\n"
18612                 "\n"
18613                 "plsmaj(def, scale)\n"
18614                 "\n"
18615                 "ARGUMENTS:\n"
18616                 "\n"
18617                 "    def (PLFLT, input) :    The default length of a major tick in\n"
18618                 "    millimeters, should be set to zero if the default length is to\n"
18619                 "    remain unchanged. \n"
18620                 "\n"
18621                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
18622                 "    actual tick length. \n"
18623                 "\n"
18624                 ""},
18625          { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
18626                 "Set the memory area to be plotted (RGB) \n"
18627                 "\n"
18628                 "DESCRIPTION:\n"
18629                 "\n"
18630                 "    Set the memory area to be plotted (with the mem or memcairo driver) as\n"
18631                 "    the dev member of the stream structure.  Also set the number of pixels\n"
18632                 "    in the memory passed in \n"
18633                 "    plotmem, which is a block of memory \n"
18634                 "    maxy by \n"
18635                 "    maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
18636                 "\n"
18637                 "    This memory will have to be freed by the user! \n"
18638                 "\n"
18639                 "    Redacted form: plsmem(maxx, maxy, plotmem)\n"
18640                 "\n"
18641                 "    This function is not used in any examples. \n"
18642                 "\n"
18643                 "\n"
18644                 "\n"
18645                 "SYNOPSIS:\n"
18646                 "\n"
18647                 "plsmem(maxx, maxy, plotmem)\n"
18648                 "\n"
18649                 "ARGUMENTS:\n"
18650                 "\n"
18651                 "    maxx (PLINT, input) :    Size of memory area in the X coordinate. \n"
18652                 "\n"
18653                 "    maxy (PLINT, input) :    Size of memory area in the Y coordinate. \n"
18654                 "\n"
18655                 "    plotmem (void *, input) :     Pointer to the beginning of the\n"
18656                 "    user-supplied memory area. \n"
18657                 "\n"
18658                 ""},
18659          { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
18660                 "Set the memory area to be plotted (RGBA) \n"
18661                 "\n"
18662                 "DESCRIPTION:\n"
18663                 "\n"
18664                 "    Set the memory area to be plotted (with the memcairo driver) as the\n"
18665                 "    dev member of the stream structure. Also set the number of pixels in\n"
18666                 "    the memory passed in \n"
18667                 "    plotmem, which is a block of memory \n"
18668                 "    maxy by \n"
18669                 "    maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
18670                 "\n"
18671                 "    This memory will have to be freed by the user! \n"
18672                 "\n"
18673                 "    Redacted form: plsmema(maxx, maxy, plotmem)\n"
18674                 "\n"
18675                 "    This function is not used in any examples. \n"
18676                 "\n"
18677                 "\n"
18678                 "\n"
18679                 "SYNOPSIS:\n"
18680                 "\n"
18681                 "plsmema(maxx, maxy, plotmem)\n"
18682                 "\n"
18683                 "ARGUMENTS:\n"
18684                 "\n"
18685                 "    maxx (PLINT, input) :    Size of memory area in the X coordinate. \n"
18686                 "\n"
18687                 "    maxy (PLINT, input) :    Size of memory area in the Y coordinate. \n"
18688                 "\n"
18689                 "    plotmem (void *, input) :     Pointer to the beginning of the\n"
18690                 "    user-supplied memory area. \n"
18691                 "\n"
18692                 ""},
18693          { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
18694                 "Set length of minor ticks \n"
18695                 "\n"
18696                 "DESCRIPTION:\n"
18697                 "\n"
18698                 "    This sets up the length of the minor ticks and the length of the\n"
18699                 "    terminals on error bars.  The actual length is the product of the\n"
18700                 "    default length and a scaling factor as for character height. \n"
18701                 "\n"
18702                 "    Redacted form: plsmin(def, scale)\n"
18703                 "\n"
18704                 "    This function is used in example 29. \n"
18705                 "\n"
18706                 "\n"
18707                 "\n"
18708                 "SYNOPSIS:\n"
18709                 "\n"
18710                 "plsmin(def, scale)\n"
18711                 "\n"
18712                 "ARGUMENTS:\n"
18713                 "\n"
18714                 "    def (PLFLT, input) :    The default length of a minor tick in\n"
18715                 "    millimeters, should be set to zero if the default length is to\n"
18716                 "    remain unchanged. \n"
18717                 "\n"
18718                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
18719                 "    actual tick length. \n"
18720                 "\n"
18721                 ""},
18722          { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
18723                 "Set orientation \n"
18724                 "\n"
18725                 "DESCRIPTION:\n"
18726                 "\n"
18727                 "    Set integer plot orientation parameter.  This function is identical to\n"
18728                 "    plsdiori except for the type of the argument, and should be used in\n"
18729                 "    the same way.  See the PLplot documentation for details. \n"
18730                 "\n"
18731                 "    Redacted form: plsori(ori)\n"
18732                 "\n"
18733                 "    This function is used in example 3. \n"
18734                 "\n"
18735                 "\n"
18736                 "\n"
18737                 "SYNOPSIS:\n"
18738                 "\n"
18739                 "plsori(ori)\n"
18740                 "\n"
18741                 "ARGUMENTS:\n"
18742                 "\n"
18743                 "    ori (PLINT, input) :    Orientation value (0 for landscape, 1 for\n"
18744                 "    portrait, etc.) The value is multiplied by 90 degrees to get the\n"
18745                 "    angle. \n"
18746                 "\n"
18747                 ""},
18748          { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
18749                 "Set page parameters \n"
18750                 "\n"
18751                 "DESCRIPTION:\n"
18752                 "\n"
18753                 "    Sets the page configuration (optional).  If an individual parameter is\n"
18754                 "    zero then that parameter value is not updated.  Not all parameters are\n"
18755                 "    recognized by all drivers and the interpretation is device-dependent.\n"
18756                 "    The X-window driver uses the length and offset parameters to determine\n"
18757                 "    the window size and location.  The length and offset values are\n"
18758                 "    expressed in units that are specific to the current driver. For\n"
18759                 "    instance: screen drivers will usually interpret them as number of\n"
18760                 "    pixels, whereas printer drivers will usually use mm. This routine, if\n"
18761                 "    used, must be called before initializing PLplot. \n"
18762                 "\n"
18763                 "    Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
18764                 "\n"
18765                 "    This function is used in example 31. \n"
18766                 "\n"
18767                 "\n"
18768                 "\n"
18769                 "SYNOPSIS:\n"
18770                 "\n"
18771                 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
18772                 "\n"
18773                 "ARGUMENTS:\n"
18774                 "\n"
18775                 "    xp (PLFLT, input) :    Number of pixels/inch (DPI), x. \n"
18776                 "\n"
18777                 "    yp (PLFLT, input) :    Number of pixels/inch (DPI), y. \n"
18778                 "\n"
18779                 "    xleng (PLINT , input) :    Page length, x. \n"
18780                 "\n"
18781                 "    yleng (PLINT, input) :    Page length, y. \n"
18782                 "\n"
18783                 "    xoff (PLINT, input) :    Page offset, x. \n"
18784                 "\n"
18785                 "    yoff (PLINT, input) :    Page offset, y. \n"
18786                 "\n"
18787                 ""},
18788          { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
18789                 "Set the colors for color table 0 from a cmap0 file \n"
18790                 "\n"
18791                 "DESCRIPTION:\n"
18792                 "\n"
18793                 "    Set the colors for color table 0 from a cmap0 file \n"
18794                 "\n"
18795                 "    Redacted form: plspal0(filename)\n"
18796                 "\n"
18797                 "    This function is in example 16. \n"
18798                 "\n"
18799                 "\n"
18800                 "\n"
18801                 "SYNOPSIS:\n"
18802                 "\n"
18803                 "plspal0(filename)\n"
18804                 "\n"
18805                 "ARGUMENTS:\n"
18806                 "\n"
18807                 "    filename (const char *, input) :    The name of the cmap0 file, or a\n"
18808                 "    empty to string to specify the default cmap0 file. \n"
18809                 "\n"
18810                 ""},
18811          { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
18812                 "Set the colors for color table 1 from a cmap1 file \n"
18813                 "\n"
18814                 "DESCRIPTION:\n"
18815                 "\n"
18816                 "    Set the colors for color table 1 from a cmap1 file \n"
18817                 "\n"
18818                 "    Redacted form: plspal1(filename)\n"
18819                 "\n"
18820                 "    This function is in example 16. \n"
18821                 "\n"
18822                 "\n"
18823                 "\n"
18824                 "SYNOPSIS:\n"
18825                 "\n"
18826                 "plspal1(filename)\n"
18827                 "\n"
18828                 "ARGUMENTS:\n"
18829                 "\n"
18830                 "    filename (const char *, input) :    The name of the cmap1 file, or a\n"
18831                 "    empty to string to specify the default cmap1 file. \n"
18832                 "\n"
18833                 ""},
18834          { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
18835                 "Set the pause (on end-of-page) status \n"
18836                 "\n"
18837                 "DESCRIPTION:\n"
18838                 "\n"
18839                 "    Set the pause (on end-of-page) status. \n"
18840                 "\n"
18841                 "    Redacted form: plspause(pause)\n"
18842                 "\n"
18843                 "    This function is in examples 14,20. \n"
18844                 "\n"
18845                 "\n"
18846                 "\n"
18847                 "SYNOPSIS:\n"
18848                 "\n"
18849                 "plspause(pause)\n"
18850                 "\n"
18851                 "ARGUMENTS:\n"
18852                 "\n"
18853                 "    pause (PLBOOL, input) :    If pause is true there will be a pause on\n"
18854                 "    end-of-page for those drivers which support this.  Otherwise there\n"
18855                 "    is no pause. \n"
18856                 "\n"
18857                 ""},
18858          { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
18859                 "Set current output stream \n"
18860                 "\n"
18861                 "DESCRIPTION:\n"
18862                 "\n"
18863                 "    Sets the number of the current output stream.  The stream number\n"
18864                 "    defaults to 0 unless changed by this routine.  The first use of this\n"
18865                 "    routine must be followed by a call initializing PLplot (e.g. plstar). \n"
18866                 "\n"
18867                 "    Redacted form: plsstrm(strm)\n"
18868                 "\n"
18869                 "    This function is examples 1,14,20. \n"
18870                 "\n"
18871                 "\n"
18872                 "\n"
18873                 "SYNOPSIS:\n"
18874                 "\n"
18875                 "plsstrm(strm)\n"
18876                 "\n"
18877                 "ARGUMENTS:\n"
18878                 "\n"
18879                 "    strm (PLINT, input) :    The current stream number. \n"
18880                 "\n"
18881                 ""},
18882          { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
18883                 "Set the number of subpages in x and y \n"
18884                 "\n"
18885                 "DESCRIPTION:\n"
18886                 "\n"
18887                 "    Set the number of subpages in x and y. \n"
18888                 "\n"
18889                 "    Redacted form: plssub(nx, ny)\n"
18890                 "\n"
18891                 "    This function is examples 1,2,14,21,25,27. \n"
18892                 "\n"
18893                 "\n"
18894                 "\n"
18895                 "SYNOPSIS:\n"
18896                 "\n"
18897                 "plssub(nx, ny)\n"
18898                 "\n"
18899                 "ARGUMENTS:\n"
18900                 "\n"
18901                 "    nx (PLINT, input) :    Number of windows in x direction (i.e., number\n"
18902                 "    of window columns). \n"
18903                 "\n"
18904                 "    ny (PLINT, input) :    Number of windows in y direction (i.e., number\n"
18905                 "    of window rows). \n"
18906                 "\n"
18907                 ""},
18908          { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
18909                 "Set symbol size \n"
18910                 "\n"
18911                 "DESCRIPTION:\n"
18912                 "\n"
18913                 "    This sets up the size of all subsequent symbols drawn by plpoin and\n"
18914                 "    plsym.  The actual height of a symbol is the product of the default\n"
18915                 "    symbol size and a scaling factor as for the character height. \n"
18916                 "\n"
18917                 "    Redacted form: plssym(def, scale)\n"
18918                 "\n"
18919                 "    This function is used in example 29. \n"
18920                 "\n"
18921                 "\n"
18922                 "\n"
18923                 "SYNOPSIS:\n"
18924                 "\n"
18925                 "plssym(def, scale)\n"
18926                 "\n"
18927                 "ARGUMENTS:\n"
18928                 "\n"
18929                 "    def (PLFLT, input) :    The default height of a symbol in millimeters,\n"
18930                 "    should be set to zero if the default height is to remain\n"
18931                 "    unchanged. \n"
18932                 "\n"
18933                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
18934                 "    actual symbol height. \n"
18935                 "\n"
18936                 ""},
18937          { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
18938                 "Initialization \n"
18939                 "\n"
18940                 "DESCRIPTION:\n"
18941                 "\n"
18942                 "    Initializing the plotting package. The program prompts for the device\n"
18943                 "    keyword or number of the desired output device.  Hitting a RETURN in\n"
18944                 "    response to the prompt is the same as selecting the first device.  If\n"
18945                 "    only one device is enabled when PLplot is installed, plstar will issue\n"
18946                 "    no prompt. The output device is divided into nx by ny subpages, each\n"
18947                 "    of which may be used independently.  The subroutine pladv is used to\n"
18948                 "    advance from one subpage to the next. \n"
18949                 "\n"
18950                 "    Redacted form: plstar(nx, ny)\n"
18951                 "\n"
18952                 "    This function is used in example 1. \n"
18953                 "\n"
18954                 "\n"
18955                 "\n"
18956                 "SYNOPSIS:\n"
18957                 "\n"
18958                 "plstar(nx, ny)\n"
18959                 "\n"
18960                 "ARGUMENTS:\n"
18961                 "\n"
18962                 "    nx (PLINT, input) :    Number of subpages to divide output page in the\n"
18963                 "    horizontal direction. \n"
18964                 "\n"
18965                 "    ny (PLINT, input) :    Number of subpages to divide output page in the\n"
18966                 "    vertical direction. \n"
18967                 "\n"
18968                 ""},
18969          { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
18970                 "Initialization \n"
18971                 "\n"
18972                 "DESCRIPTION:\n"
18973                 "\n"
18974                 "    Alternative to plstar for initializing the plotting package.  The\n"
18975                 "    device name keyword for the desired output device must be supplied as\n"
18976                 "    an argument.  The device keywords are the same as those printed out by\n"
18977                 "    plstar.  If the requested device is not available, or if the input\n"
18978                 "    string is empty or begins with ``?'', the prompted startup of plstar\n"
18979                 "    is used.  This routine also divides the output device into nx by ny\n"
18980                 "    subpages, each of which may be used independently. The subroutine\n"
18981                 "    pladv is used to advance from one subpage to the next. \n"
18982                 "\n"
18983                 "    Redacted form:  General: plstart(device, nx, ny)\n"
18984                 "           Perl/PDL: plstart(nx, ny, device)\n"
18985                 "\n"
18986                 "\n"
18987                 "    This function is not used in any examples. \n"
18988                 "\n"
18989                 "\n"
18990                 "\n"
18991                 "SYNOPSIS:\n"
18992                 "\n"
18993                 "plstart(device, nx, ny)\n"
18994                 "\n"
18995                 "ARGUMENTS:\n"
18996                 "\n"
18997                 "    device (const char *, input) :    Device name (keyword) of the\n"
18998                 "    required output device.  If NULL or if the first character is a\n"
18999                 "    ``?'', the normal (prompted) startup is used. \n"
19000                 "\n"
19001                 "    nx (PLINT, input) :    Number of subpages to divide output page in the\n"
19002                 "    horizontal direction. \n"
19003                 "\n"
19004                 "    ny (PLINT, input) :    Number of subpages to divide output page in the\n"
19005                 "    vertical direction. \n"
19006                 "\n"
19007                 ""},
19008          { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
19009                 "Set a global coordinate transform function \n"
19010                 "\n"
19011                 "DESCRIPTION:\n"
19012                 "\n"
19013                 "    This function can be used to define a coordinate transformation which\n"
19014                 "    affects all elements drawn within the current plot window. The\n"
19015                 "    transformation function is similar to that provided for the plmap and\n"
19016                 "    plmeridians functions.  The data parameter may be used to pass extra\n"
19017                 "    data to transform_fun. \n"
19018                 "\n"
19019                 "    Redacted form:  General: plstransform(transform_fun, data)\n"
19020                 "\n"
19021                 "\n"
19022                 "    This function is used in example 19. \n"
19023                 "\n"
19024                 "\n"
19025                 "\n"
19026                 "SYNOPSIS:\n"
19027                 "\n"
19028                 "plstransform(transform_fun, data)\n"
19029                 "\n"
19030                 "ARGUMENTS:\n"
19031                 "\n"
19032                 "    transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
19033                 "    input) :    Pointer to a function that defines a transformation\n"
19034                 "    from the input (x, y) coordinate to a new plot world coordiante. \n"
19035                 "\n"
19036                 "    data (PLPointer, input) :     Optional extra data for \n"
19037                 "    transform_fun. \n"
19038                 "\n"
19039                 ""},
19040          { (char *)"plstring", _wrap_plstring, METH_VARARGS, NULL},
19041          { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, NULL},
19042          { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
19043                 "Add a point to a stripchart \n"
19044                 "\n"
19045                 "DESCRIPTION:\n"
19046                 "\n"
19047                 "    Add a point to a given pen of a given stripchart. There is no need for\n"
19048                 "    all pens to have the same number of points or to be equally sampled in\n"
19049                 "    the x coordinate. Allocates memory and rescales as necessary. \n"
19050                 "\n"
19051                 "    Redacted form: plstripa(id, p, x, y)\n"
19052                 "\n"
19053                 "    This function is used in example 17. \n"
19054                 "\n"
19055                 "\n"
19056                 "\n"
19057                 "SYNOPSIS:\n"
19058                 "\n"
19059                 "plstripa(id, p, x, y)\n"
19060                 "\n"
19061                 "ARGUMENTS:\n"
19062                 "\n"
19063                 "    id (PLINT, input) :    Identification number (set up in plstripc) of\n"
19064                 "    the stripchart. \n"
19065                 "\n"
19066                 "    p (PLINT, input) :      Pen number (ranges from 0 to 3). \n"
19067                 "\n"
19068                 "    x (PLFLT, input) :      X coordinate of point to plot. \n"
19069                 "\n"
19070                 "    y (PLFLT, input) :      Y coordinate of point to plot. \n"
19071                 "\n"
19072                 ""},
19073          { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
19074                 "Create a 4-pen stripchart \n"
19075                 "\n"
19076                 "DESCRIPTION:\n"
19077                 "\n"
19078                 "    Create a 4-pen stripchart, to be used afterwards by plstripa\n"
19079                 "\n"
19080                 "    Redacted form:  General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
19081                 "    ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
19082                 "    styline, legline, labx, laby, labz)\n"
19083                 "           Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
19084                 "    ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
19085                 "    ypsec, legline, labx, laby, labtop)\n"
19086                 "\n"
19087                 "\n"
19088                 "    This function is used in example 17. \n"
19089                 "\n"
19090                 "\n"
19091                 "\n"
19092                 "SYNOPSIS:\n"
19093                 "\n"
19094                 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
19095                 "\n"
19096                 "ARGUMENTS:\n"
19097                 "\n"
19098                 "    id (PLINT *, output) :    Identification number of stripchart to use\n"
19099                 "    on plstripa and plstripd. \n"
19100                 "\n"
19101                 "    xspec (char *, input) :    X-axis specification as in plbox. \n"
19102                 "\n"
19103                 "    yspec (char *, input) :    Y-axis specification as in plbox. \n"
19104                 "\n"
19105                 "    xmin (PLFLT, input) :    Initial coordinates of plot box; they will\n"
19106                 "    change as data are added. \n"
19107                 "\n"
19108                 "    xmax (PLFLT, input) :    Initial coordinates of plot box; they will\n"
19109                 "    change as data are added. \n"
19110                 "\n"
19111                 "    xjump (PLFLT, input) :    When x attains xmax, the length of the plot\n"
19112                 "    is multiplied by the factor (1 + \n"
19113                 "    xjump). \n"
19114                 "\n"
19115                 "    ymin (PLFLT, input) :    Initial coordinates of plot box; they will\n"
19116                 "    change as data are added. \n"
19117                 "\n"
19118                 "    ymax (PLFLT, input) :    Initial coordinates of plot box; they will\n"
19119                 "    change as data are added. \n"
19120                 "\n"
19121                 "    xlpos (PLFLT, input) :    X legend box position (range from 0 to 1). \n"
19122                 "\n"
19123                 "    ylpos (PLFLT, input) :    Y legend box position (range from 0 to 1). \n"
19124                 "\n"
19125                 "    y_ascl (PLBOOL, input) :    Autoscale y between x jumps if y_ascl is\n"
19126                 "    true, otherwise not. \n"
19127                 "\n"
19128                 "    acc (PLBOOL, input) :    Accumulate strip plot if acc is true,\n"
19129                 "    otherwise slide display. \n"
19130                 "\n"
19131                 "    colbox (PLINT, input) :    Plot box color index (cmap0). \n"
19132                 "\n"
19133                 "    collab (PLINT, input) :    Legend color index (cmap0). \n"
19134                 "\n"
19135                 "    colline (PLINT *, input) :      Pointer to array with color indices\n"
19136                 "    (cmap0) for the 4 pens. \n"
19137                 "\n"
19138                 "    styline (PLINT *, input) :      Pointer to array with line styles for\n"
19139                 "    the 4 pens. \n"
19140                 "\n"
19141                 "    legline (char **, input) :      Pointer to character array containing\n"
19142                 "    legends for the 4 pens. \n"
19143                 "\n"
19144                 "    labx (char *, input) :    X-axis label. \n"
19145                 "\n"
19146                 "    laby (char *, input) :    Y-axis label. \n"
19147                 "\n"
19148                 "    labtop (char *, input) :    Plot title. \n"
19149                 "\n"
19150                 ""},
19151          { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
19152                 "Deletes and releases memory used by a stripchart \n"
19153                 "\n"
19154                 "DESCRIPTION:\n"
19155                 "\n"
19156                 "    Deletes and releases memory used by a stripchart. \n"
19157                 "\n"
19158                 "    Redacted form: plstripd(id)\n"
19159                 "\n"
19160                 "    This function is used in example 17. \n"
19161                 "\n"
19162                 "\n"
19163                 "\n"
19164                 "SYNOPSIS:\n"
19165                 "\n"
19166                 "plstripd(id)\n"
19167                 "\n"
19168                 "ARGUMENTS:\n"
19169                 "\n"
19170                 "    id (PLINT, input) :    Identification number of stripchart to delete. \n"
19171                 "\n"
19172                 ""},
19173          { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
19174                 "Set line style \n"
19175                 "\n"
19176                 "DESCRIPTION:\n"
19177                 "\n"
19178                 "    This sets up the line style for all lines subsequently drawn.  A line\n"
19179                 "    consists of segments in which the pen is alternately down and up. The\n"
19180                 "    lengths of these segments are passed in the arrays mark and space\n"
19181                 "    respectively.  The number of mark-space pairs is specified by nels. \n"
19182                 "    In order to return the line style to the default continuous line,\n"
19183                 "    plstyl should be called with nels=0.(see also pllsty) \n"
19184                 "\n"
19185                 "    Redacted form: plstyl(mark, space)\n"
19186                 "\n"
19187                 "    This function is used in examples 1,9,14. \n"
19188                 "\n"
19189                 "\n"
19190                 "\n"
19191                 "SYNOPSIS:\n"
19192                 "\n"
19193                 "plstyl(nels, mark, space)\n"
19194                 "\n"
19195                 "ARGUMENTS:\n"
19196                 "\n"
19197                 "    nels (PLINT, input) :    The number of mark and space elements in a\n"
19198                 "    line.  Thus a simple broken line can be obtained by setting\n"
19199                 "    nels=1.  A continuous line is specified by setting nels=0. \n"
19200                 "\n"
19201                 "    mark (PLINT *, input) :    Pointer to array with the lengths of the\n"
19202                 "    segments during which the pen is down, measured in micrometers. \n"
19203                 "\n"
19204                 "    space (PLINT *, input) :    Pointer to array with the lengths of the\n"
19205                 "    segments during which the pen is up, measured in micrometers. \n"
19206                 "\n"
19207                 ""},
19208          { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
19209                 "Set arrow style for vector plots \n"
19210                 "\n"
19211                 "DESCRIPTION:\n"
19212                 "\n"
19213                 "    Set the style for the arrow used by plvect to plot vectors. \n"
19214                 "\n"
19215                 "    Redacted form: plsvect(arrowx, arrowy, fill)\n"
19216                 "\n"
19217                 "    This function is used in example 22. \n"
19218                 "\n"
19219                 "\n"
19220                 "\n"
19221                 "SYNOPSIS:\n"
19222                 "\n"
19223                 "plsvect(arrowx, arrowy, npts, fill)\n"
19224                 "\n"
19225                 "ARGUMENTS:\n"
19226                 "\n"
19227                 "    arrowx, arrowy (PLFLT *,input) :    Pointers to a pair of arrays\n"
19228                 "    containing the x and y points which make up the arrow. The arrow\n"
19229                 "    is plotted by joining these points to form a polygon. The scaling\n"
19230                 "    assumes that the x and y points in the arrow lie in the range -0.5\n"
19231                 "    <= x,y <= 0.5. \n"
19232                 "\n"
19233                 "    npts (PLINT,input) :    Number of points in the arrays arrowx and\n"
19234                 "    arrowy. \n"
19235                 "\n"
19236                 "    fill (PLBOOL,input) :    If fill is true then the arrow is closed, if\n"
19237                 "    fill is false then the arrow is open. \n"
19238                 "\n"
19239                 ""},
19240          { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
19241                 "Specify viewport in absolute coordinates \n"
19242                 "\n"
19243                 "DESCRIPTION:\n"
19244                 "\n"
19245                 "    Alternate routine to plvpor for setting up the viewport.  This routine\n"
19246                 "    should be used only if the viewport is required to have a definite\n"
19247                 "    size in millimeters.  The routine plgspa is useful for finding out the\n"
19248                 "    size of the current subpage. \n"
19249                 "\n"
19250                 "    Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
19251                 "\n"
19252                 "    This function is used in example 10. \n"
19253                 "\n"
19254                 "\n"
19255                 "\n"
19256                 "SYNOPSIS:\n"
19257                 "\n"
19258                 "plsvpa(xmin, xmax, ymin, ymax)\n"
19259                 "\n"
19260                 "ARGUMENTS:\n"
19261                 "\n"
19262                 "    xmin (PLFLT, input) :    The distance of the left-hand edge of the\n"
19263                 "    viewport from the left-hand edge of the subpage in millimeters. \n"
19264                 "\n"
19265                 "    xmax (PLFLT, input) :    The distance of the right-hand edge of the\n"
19266                 "    viewport from the left-hand edge of the subpage in millimeters. \n"
19267                 "\n"
19268                 "    ymin (PLFLT, input) :    The distance of the bottom edge of the\n"
19269                 "    viewport from the bottom edge of the subpage in millimeters. \n"
19270                 "\n"
19271                 "    ymax (PLFLT, input) :    The distance of the top edge of the viewport\n"
19272                 "    from the bottom edge of the subpage in millimeters. \n"
19273                 "\n"
19274                 ""},
19275          { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
19276                 "Set x axis parameters \n"
19277                 "\n"
19278                 "DESCRIPTION:\n"
19279                 "\n"
19280                 "    Sets values of the digmax and digits flags for the x axis. See the\n"
19281                 "    PLplot documentation for more information. \n"
19282                 "\n"
19283                 "    Redacted form: plsxax(digmax, digits)\n"
19284                 "\n"
19285                 "    This function is used in example 31. \n"
19286                 "\n"
19287                 "\n"
19288                 "\n"
19289                 "SYNOPSIS:\n"
19290                 "\n"
19291                 "plsxax(digmax, digits)\n"
19292                 "\n"
19293                 "ARGUMENTS:\n"
19294                 "\n"
19295                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
19296                 "    digits for the x axis.    If nonzero, the printed label will be\n"
19297                 "    switched to a floating point representation when the number of\n"
19298                 "    digits exceeds digmax. \n"
19299                 "\n"
19300                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
19301                 "    its value here has no effect since it is set only by plbox or\n"
19302                 "    plbox3.  However, the user may obtain its value after a call to\n"
19303                 "    either of these functions by calling plgxax. \n"
19304                 "\n"
19305                 ""},
19306          { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
19307                 "Set y axis parameters \n"
19308                 "\n"
19309                 "DESCRIPTION:\n"
19310                 "\n"
19311                 "    Identical to plsxax, except that arguments are flags for y axis. See\n"
19312                 "    the description of plsxax for more detail. \n"
19313                 "\n"
19314                 "    Redacted form: plsyax(digmax, digits)\n"
19315                 "\n"
19316                 "    This function is used in examples 1,14,31. \n"
19317                 "\n"
19318                 "\n"
19319                 "\n"
19320                 "SYNOPSIS:\n"
19321                 "\n"
19322                 "plsyax(digmax, digits)\n"
19323                 "\n"
19324                 "ARGUMENTS:\n"
19325                 "\n"
19326                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
19327                 "    digits for the y axis.    If nonzero, the printed label will be\n"
19328                 "    switched to a floating point representation when the number of\n"
19329                 "    digits exceeds digmax. \n"
19330                 "\n"
19331                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
19332                 "    its value here has no effect since it is set only by plbox or\n"
19333                 "    plbox3.  However, the user may obtain its value after a call to\n"
19334                 "    either of these functions by calling plgyax. \n"
19335                 "\n"
19336                 ""},
19337          { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
19338                 "Plots a symbol at the specified points \n"
19339                 "\n"
19340                 "DESCRIPTION:\n"
19341                 "\n"
19342                 "    Marks out a set of n points at positions (\n"
19343                 "    x[i], \n"
19344                 "    y[i]), using the symbol defined by code.  The code is interpreted as\n"
19345                 "    an index in the Hershey font tables. \n"
19346                 "\n"
19347                 "    Redacted form: plsym(x, y, code)\n"
19348                 "\n"
19349                 "    This function is used in example 7. \n"
19350                 "\n"
19351                 "\n"
19352                 "\n"
19353                 "SYNOPSIS:\n"
19354                 "\n"
19355                 "plsym(n, x, y, code)\n"
19356                 "\n"
19357                 "ARGUMENTS:\n"
19358                 "\n"
19359                 "    n (PLINT, input) :      Number of points to be marked. \n"
19360                 "\n"
19361                 "    x (PLFLT *, input) :    Pointer to array with set of x coordinate\n"
19362                 "    values for the points. \n"
19363                 "\n"
19364                 "    y (PLFLT *, input) :    Pointer to array with set of y coordinate\n"
19365                 "    values for the points. \n"
19366                 "\n"
19367                 "    code (PLINT, input) :    Code number for the symbol to be plotted. \n"
19368                 "\n"
19369                 ""},
19370          { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
19371                 "Set z axis parameters \n"
19372                 "\n"
19373                 "DESCRIPTION:\n"
19374                 "\n"
19375                 "    Identical to plsxax, except that arguments are flags for z axis. See\n"
19376                 "    the description of plsxax for more detail. \n"
19377                 "\n"
19378                 "    Redacted form: plszax(digmax, digits)\n"
19379                 "\n"
19380                 "    This function is used in example 31. \n"
19381                 "\n"
19382                 "\n"
19383                 "\n"
19384                 "SYNOPSIS:\n"
19385                 "\n"
19386                 "plszax(digmax, digits)\n"
19387                 "\n"
19388                 "ARGUMENTS:\n"
19389                 "\n"
19390                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
19391                 "    digits for the z axis.    If nonzero, the printed label will be\n"
19392                 "    switched to a floating point representation when the number of\n"
19393                 "    digits exceeds digmax. \n"
19394                 "\n"
19395                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
19396                 "    its value here has no effect since it is set only by plbox or\n"
19397                 "    plbox3.  However, the user may obtain its value after a call to\n"
19398                 "    either of these functions by calling plgzax. \n"
19399                 "\n"
19400                 ""},
19401          { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
19402                 "Switch to text screen \n"
19403                 "\n"
19404                 "DESCRIPTION:\n"
19405                 "\n"
19406                 "    Sets an interactive device to text mode, used in conjunction with\n"
19407                 "    plgra to allow graphics and text to be interspersed.  On a device\n"
19408                 "    which supports separate text and graphics windows, this command causes\n"
19409                 "    control to be switched to the text window. This can be useful for\n"
19410                 "    printing diagnostic messages or getting user input, which would\n"
19411                 "    otherwise interfere with the plots.  The program must switch back to\n"
19412                 "    the graphics window before issuing plot commands, as the text (or\n"
19413                 "    console) device will probably become quite confused otherwise.  If\n"
19414                 "    already in text mode, this command is ignored.  It is also ignored on\n"
19415                 "    devices which only support a single window or use a different method\n"
19416                 "    for shifting focus (see also plgra). \n"
19417                 "\n"
19418                 "    Redacted form: pltext()\n"
19419                 "\n"
19420                 "    This function is used in example 1. \n"
19421                 "\n"
19422                 "\n"
19423                 "\n"
19424                 "SYNOPSIS:\n"
19425                 "\n"
19426                 "pltext()\n"
19427                 "\n"
19428                 ""},
19429          { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
19430                 "Set format for date / time labels \n"
19431                 "\n"
19432                 "DESCRIPTION:\n"
19433                 "\n"
19434                 "    Sets the format for date / time labels. To enable date / time format\n"
19435                 "    labels see the options to plbox and plenv. \n"
19436                 "\n"
19437                 "    Redacted form: pltimefmt(fmt)\n"
19438                 "\n"
19439                 "    This function is used in example 29. \n"
19440                 "\n"
19441                 "\n"
19442                 "\n"
19443                 "SYNOPSIS:\n"
19444                 "\n"
19445                 "pltimefmt(fmt)\n"
19446                 "\n"
19447                 "ARGUMENTS:\n"
19448                 "\n"
19449                 "    fmt (const char *, fmt) :     This string is passed directly to the\n"
19450                 "    system strftime. See the system documentation for a full list of\n"
19451                 "    conversion specifications for your system. All conversion\n"
19452                 "    specifications take the form of a '%' character followed by\n"
19453                 "    further conversion specification character. All other text is\n"
19454                 "    printed as-is. Common options include: %c: The preferred date and\n"
19455                 "    time representation for the current locale.  \n"
19456                 "        %d: The day of the month as a decimal number.  \n"
19457                 "        %H: The hour as a decimal number using a 24-hour clock.  \n"
19458                 "        %j: The day of the year as a decimal number.  \n"
19459                 "        %m: The month as a decimal number.    \n"
19460                 "        %M: The minute as a decimal number.  \n"
19461                 "        %S: The second as a decimal number.  \n"
19462                 "        %y: The year as a decimal number without a century.  \n"
19463                 "        %Y: The year  as a decimal number including a century.  \n"
19464                 "\n"
19465                 ""},
19466          { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
19467                 "Specify viewport using aspect ratio only \n"
19468                 "\n"
19469                 "DESCRIPTION:\n"
19470                 "\n"
19471                 "    Sets the viewport so that the ratio of the length of the y axis to\n"
19472                 "    that of the x axis is equal to aspect. \n"
19473                 "\n"
19474                 "    Redacted form: plvasp(aspect)\n"
19475                 "\n"
19476                 "    This function is used in example 13. \n"
19477                 "\n"
19478                 "\n"
19479                 "\n"
19480                 "SYNOPSIS:\n"
19481                 "\n"
19482                 "plvasp(aspect)\n"
19483                 "\n"
19484                 "ARGUMENTS:\n"
19485                 "\n"
19486                 "    aspect (PLFLT, input) :    Ratio of length of y axis to length of x\n"
19487                 "    axis. \n"
19488                 "\n"
19489                 ""},
19490          { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
19491                 "Vector plot \n"
19492                 "\n"
19493                 "DESCRIPTION:\n"
19494                 "\n"
19495                 "    Draws a vector plot of the vector (\n"
19496                 "    u[\n"
19497                 "    nx][\n"
19498                 "    ny],\n"
19499                 "    v[\n"
19500                 "    nx][\n"
19501                 "    ny]). The scaling factor for the vectors is given by scale. A\n"
19502                 "    transformation routine pointed to by pltr with a pointer pltr_data for\n"
19503                 "    additional data required by the transformation routine is used to map\n"
19504                 "    indices within the array to the world coordinates. The style of the\n"
19505                 "    vector arrow may be set using plsvect. \n"
19506                 "\n"
19507                 "    Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
19508                 "\n"
19509                 "    This function is used in example 22. \n"
19510                 "\n"
19511                 "\n"
19512                 "\n"
19513                 "SYNOPSIS:\n"
19514                 "\n"
19515                 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
19516                 "\n"
19517                 "ARGUMENTS:\n"
19518                 "\n"
19519                 "    u, v (PLFLT **, input) :    Pointers to a pair of vectored\n"
19520                 "    two-dimensional arrays containing the x and y components of the\n"
19521                 "    vector data to be plotted. \n"
19522                 "\n"
19523                 "    nx, ny (PLINT, input) :    Physical dimensions of the arrays u and v. \n"
19524                 "\n"
19525                 "    scale (PLFLT, input) :    Parameter to control the scaling factor of\n"
19526                 "    the vectors for plotting. If scale = 0 then the scaling factor is\n"
19527                 "    automatically calculated for the data. If scale < 0 then the\n"
19528                 "    scaling factor is automatically calculated for the data and then\n"
19529                 "    multiplied by -\n"
19530                 "    scale. If scale > 0 then the scaling factor is set to scale. \n"
19531                 "\n"
19532                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19533                 "      Pointer to function that defines transformation between indices\n"
19534                 "    in array z and the world coordinates (C only).    Transformation\n"
19535                 "    functions are provided in the PLplot library: pltr0 for identity\n"
19536                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19537                 "    defined by one- and two-dimensional arrays.  In addition,\n"
19538                 "    user-supplied routines for the transformation can be used as well.\n"
19539                 "     Examples of all of these approaches are given in the PLplot\n"
19540                 "    documentation. The transformation function should have the form\n"
19541                 "    given by any of pltr0, pltr1, or pltr2. \n"
19542                 "\n"
19543                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
19544                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19545                 "    externally supplied. \n"
19546                 "\n"
19547                 ""},
19548          { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
19549                 "Specify viewport using coordinates and aspect ratio \n"
19550                 "\n"
19551                 "DESCRIPTION:\n"
19552                 "\n"
19553                 "    Device-independent routine for setting up the viewport.  The viewport\n"
19554                 "    is chosen to be the largest with the given aspect ratio that fits\n"
19555                 "    within the specified region (in terms of normalized subpage\n"
19556                 "    coordinates).  This routine is functionally equivalent to plvpor when\n"
19557                 "    a ``natural'' aspect ratio (0.0) is chosen.  Unlike plvasp, this\n"
19558                 "    routine reserves no extra space at the edges for labels. \n"
19559                 "\n"
19560                 "    Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
19561                 "\n"
19562                 "    This function is used in example 9. \n"
19563                 "\n"
19564                 "\n"
19565                 "\n"
19566                 "SYNOPSIS:\n"
19567                 "\n"
19568                 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
19569                 "\n"
19570                 "ARGUMENTS:\n"
19571                 "\n"
19572                 "    xmin (PLFLT, input) :    The normalized subpage coordinate of the\n"
19573                 "    left-hand edge of the viewport. \n"
19574                 "\n"
19575                 "    xmax (PLFLT, input) :    The normalized subpage coordinate of the\n"
19576                 "    right-hand edge of the viewport. \n"
19577                 "\n"
19578                 "    ymin (PLFLT, input) :    The normalized subpage coordinate of the\n"
19579                 "    bottom edge of the viewport. \n"
19580                 "\n"
19581                 "    ymax (PLFLT, input) :    The normalized subpage coordinate of the top\n"
19582                 "    edge of the viewport. \n"
19583                 "\n"
19584                 "    aspect (PLFLT, input) :    Ratio of length of y axis to length of x\n"
19585                 "    axis. \n"
19586                 "\n"
19587                 ""},
19588          { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
19589                 "Specify viewport using coordinates \n"
19590                 "\n"
19591                 "DESCRIPTION:\n"
19592                 "\n"
19593                 "    Device-independent routine for setting up the viewport.  This defines\n"
19594                 "    the viewport in terms of normalized subpage coordinates which run from\n"
19595                 "    0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
19596                 "    current subpage.  Use the alternate routine plsvpa in order to create\n"
19597                 "    a viewport of a definite size. \n"
19598                 "\n"
19599                 "    Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
19600                 "\n"
19601                 "    This function is used in examples\n"
19602                 "    2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
19603                 "\n"
19604                 "\n"
19605                 "\n"
19606                 "SYNOPSIS:\n"
19607                 "\n"
19608                 "plvpor(xmin, xmax, ymin, ymax)\n"
19609                 "\n"
19610                 "ARGUMENTS:\n"
19611                 "\n"
19612                 "    xmin (PLFLT, input) :    The normalized subpage coordinate of the\n"
19613                 "    left-hand edge of the viewport. \n"
19614                 "\n"
19615                 "    xmax (PLFLT, input) :    The normalized subpage coordinate of the\n"
19616                 "    right-hand edge of the viewport. \n"
19617                 "\n"
19618                 "    ymin (PLFLT, input) :    The normalized subpage coordinate of the\n"
19619                 "    bottom edge of the viewport. \n"
19620                 "\n"
19621                 "    ymax (PLFLT, input) :    The normalized subpage coordinate of the top\n"
19622                 "    edge of the viewport. \n"
19623                 "\n"
19624                 ""},
19625          { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
19626                 "Select standard viewport \n"
19627                 "\n"
19628                 "DESCRIPTION:\n"
19629                 "\n"
19630                 "    Sets up a standard viewport, leaving a left-hand margin of seven\n"
19631                 "    character heights, and four character heights around the other three\n"
19632                 "    sides. \n"
19633                 "\n"
19634                 "    Redacted form: plvsta()\n"
19635                 "\n"
19636                 "    This function is used in examples 1,12,14,17,25,29. \n"
19637                 "\n"
19638                 "\n"
19639                 "\n"
19640                 "SYNOPSIS:\n"
19641                 "\n"
19642                 "plvsta()\n"
19643                 "\n"
19644                 ""},
19645          { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
19646                 "Set up window for 3-d plotting \n"
19647                 "\n"
19648                 "DESCRIPTION:\n"
19649                 "\n"
19650                 "    Sets up a window for a three-dimensional surface plot within the\n"
19651                 "    currently defined two-dimensional window.  The enclosing box for the\n"
19652                 "    surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
19653                 "    user-coordinate space is mapped into a box of world coordinate size\n"
19654                 "    basex by basey by height so that xmin maps to -\n"
19655                 "    basex/2, xmax maps to basex/2, ymin maps to -\n"
19656                 "    basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
19657                 "     The resulting world-coordinate box is then viewed by an observer at\n"
19658                 "    altitude alt and azimuth az.  This routine must be called before\n"
19659                 "    plbox3 or plot3d.  For a more complete description of\n"
19660                 "    three-dimensional plotting see the PLplot documentation. \n"
19661                 "\n"
19662                 "    Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
19663                 "    zmin, zmax, alt, az)\n"
19664                 "\n"
19665                 "    This function is examples 8,11,18,21. \n"
19666                 "\n"
19667                 "\n"
19668                 "\n"
19669                 "SYNOPSIS:\n"
19670                 "\n"
19671                 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
19672                 "\n"
19673                 "ARGUMENTS:\n"
19674                 "\n"
19675                 "    basex (PLFLT, input) :    The x coordinate size of the\n"
19676                 "    world-coordinate box. \n"
19677                 "\n"
19678                 "    basey (PLFLT, input) :    The y coordinate size of the\n"
19679                 "    world-coordinate box. \n"
19680                 "\n"
19681                 "    height (PLFLT, input) :    The z coordinate size of the\n"
19682                 "    world-coordinate box. \n"
19683                 "\n"
19684                 "    xmin (PLFLT, input) :    The minimum user x coordinate value. \n"
19685                 "\n"
19686                 "    xmax (PLFLT, input) :    The maximum user x coordinate value. \n"
19687                 "\n"
19688                 "    ymin (PLFLT, input) :    The minimum user y coordinate value. \n"
19689                 "\n"
19690                 "    ymax (PLFLT, input) :    The maximum user y coordinate value. \n"
19691                 "\n"
19692                 "    zmin (PLFLT, input) :    The minimum user z coordinate value. \n"
19693                 "\n"
19694                 "    zmax (PLFLT, input) :    The maximum user z coordinate value. \n"
19695                 "\n"
19696                 "    alt (PLFLT, input) :    The viewing altitude in degrees above the XY\n"
19697                 "    plane. \n"
19698                 "\n"
19699                 "    az (PLFLT, input) :    The viewing azimuth in degrees.  When az=0, the\n"
19700                 "    observer is looking face onto the ZX plane, and as az is\n"
19701                 "    increased, the observer moves clockwise around the box when viewed\n"
19702                 "    from above the XY plane. \n"
19703                 "\n"
19704                 ""},
19705          { (char *)"plwid", _wrap_plwid, METH_VARARGS, (char *)"\n"
19706                 "Set pen width \n"
19707                 "\n"
19708                 "DESCRIPTION:\n"
19709                 "\n"
19710                 "    Sets the pen width. \n"
19711                 "\n"
19712                 "    Redacted form: plwid(width)\n"
19713                 "\n"
19714                 "    This function is used in examples 1,2. \n"
19715                 "\n"
19716                 "\n"
19717                 "\n"
19718                 "SYNOPSIS:\n"
19719                 "\n"
19720                 "plwid(width)\n"
19721                 "\n"
19722                 "ARGUMENTS:\n"
19723                 "\n"
19724                 "    width (PLINT, input) :    The desired pen width.  If width is negative\n"
19725                 "    or the same as the previous value no action is taken. width = 0\n"
19726                 "    should be interpreted as as the minimum valid pen width for the\n"
19727                 "    device.  The interpretation of positive width values is also\n"
19728                 "    device dependent. \n"
19729                 "\n"
19730                 ""},
19731          { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
19732                 "Specify world coordinates of viewport boundaries \n"
19733                 "\n"
19734                 "DESCRIPTION:\n"
19735                 "\n"
19736                 "    Sets up the world coordinates of the edges of the viewport. \n"
19737                 "\n"
19738                 "    Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
19739                 "\n"
19740                 "    This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
19741                 "\n"
19742                 "\n"
19743                 "\n"
19744                 "SYNOPSIS:\n"
19745                 "\n"
19746                 "plwind(xmin, xmax, ymin, ymax)\n"
19747                 "\n"
19748                 "ARGUMENTS:\n"
19749                 "\n"
19750                 "    xmin (PLFLT, input) :    The world x coordinate of the left-hand edge\n"
19751                 "    of the viewport. \n"
19752                 "\n"
19753                 "    xmax (PLFLT, input) :    The world x coordinate of the right-hand edge\n"
19754                 "    of the viewport. \n"
19755                 "\n"
19756                 "    ymin (PLFLT, input) :    The world y coordinate of the bottom edge of\n"
19757                 "    the viewport. \n"
19758                 "\n"
19759                 "    ymax (PLFLT, input) :    The world y coordinate of the top edge of the\n"
19760                 "    viewport. \n"
19761                 "\n"
19762                 ""},
19763          { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
19764                 "Enter or leave xor mode \n"
19765                 "\n"
19766                 "DESCRIPTION:\n"
19767                 "\n"
19768                 "    Enter (when mode is true)  or leave (when mode is false) xor mode for\n"
19769                 "    those drivers (e.g., the xwin driver) that support it.  Enables\n"
19770                 "    erasing plots by drawing twice the same line, symbol, etc. If driver\n"
19771                 "    is not capable of xor operation it returns a status of false. \n"
19772                 "\n"
19773                 "    Redacted form: plxormod(mode, status)\n"
19774                 "\n"
19775                 "    This function is used in examples 1,20. \n"
19776                 "\n"
19777                 "\n"
19778                 "\n"
19779                 "SYNOPSIS:\n"
19780                 "\n"
19781                 "plxormod(mode, status)\n"
19782                 "\n"
19783                 "ARGUMENTS:\n"
19784                 "\n"
19785                 "    mode (PLBOOL, input) :    mode is true means enter xor mode and  mode\n"
19786                 "    is false means leave xor mode. \n"
19787                 "\n"
19788                 "    status (PLBOOL *, output) :    Pointer to status. Returned    modestatus\n"
19789                 "    of true (false) means driver is capable (incapable) of xor mode. \n"
19790                 "\n"
19791                 ""},
19792          { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
19793                 "Plot continental outline in world coordinates. \n"
19794                 "\n"
19795                 "DESCRIPTION:\n"
19796                 "\n"
19797                 "    Plots continental outlines in world coordinates. examples/c/x19c\n"
19798                 "    demonstrates how to use this  function to create different\n"
19799                 "    projections. \n"
19800                 "\n"
19801                 "    Redacted form:  General: plmap(mapform, type, minlong, maxlong,\n"
19802                 "    minlat, maxlat)\n"
19803                 "           F95, Java, Perl/PDL, Python: Not implemented? \n"
19804                 "\n"
19805                 "\n"
19806                 "    This function is used in example 19. \n"
19807                 "\n"
19808                 "\n"
19809                 "\n"
19810                 "SYNOPSIS:\n"
19811                 "\n"
19812                 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
19813                 "\n"
19814                 "ARGUMENTS:\n"
19815                 "\n"
19816                 "    mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) :    A user\n"
19817                 "    supplied function to transform the coordinate  longitudes and\n"
19818                 "    latitudes to a plot coordinate system.     By using this transform,\n"
19819                 "    we can change from a longitude,  latitude coordinate to a polar\n"
19820                 "    stereographic project, for  example.  Initially, x[0]..[n-1] are\n"
19821                 "    the longitudes and y[0]..y[n-1]  are the corresponding latitudes. \n"
19822                 "    After the call to mapform(), x[]  and y[] should be replaced by\n"
19823                 "    the corresponding plot coordinates.   If no transform is desired,\n"
19824                 "    mapform can be replaced by NULL. \n"
19825                 "\n"
19826                 "    type (char *, input) :    type is a character string. The value of\n"
19827                 "    this parameter determines the type of background. The possible\n"
19828                 "    values are: \"globe\" -- continental outlines \n"
19829                 "        \"usa\" -- USA and state boundaries \n"
19830                 "        \"cglobe\" -- continental outlines and countries \n"
19831                 "        \"usaglobe\" -- USA, state boundaries and continental outlines \n"
19832                 "\n"
19833                 "\n"
19834                 "    minlong (PLFLT, input) :    The value of the longitude on the left\n"
19835                 "    side of the plot.  The value of minlong must be less than the\n"
19836                 "    value of maxlong, and the  quantity maxlong-minlong must be less\n"
19837                 "    than or equal to 360. \n"
19838                 "\n"
19839                 "    maxlong (PLFLT, input) :    The value of the longitude on the right\n"
19840                 "    side of the plot. \n"
19841                 "\n"
19842                 "    minlat (PLFLT, input) :    The minimum latitude to be plotted on the\n"
19843                 "    background.   One can always use -90.0 as the boundary outside the\n"
19844                 "    plot window  will be automatically eliminated.    However, the\n"
19845                 "    program will be  faster if one can reduce the size of the\n"
19846                 "    background plotted. \n"
19847                 "\n"
19848                 "    maxlat (PLFLT, input) :    The maximum latitudes to be plotted on the\n"
19849                 "    background.   One can always use 90.0 as the boundary outside the\n"
19850                 "    plot window  will be automatically eliminated. \n"
19851                 "\n"
19852                 ""},
19853          { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
19854                 "Plot latitude and longitude lines. \n"
19855                 "\n"
19856                 "DESCRIPTION:\n"
19857                 "\n"
19858                 "    Displays latitude and longitude on the current plot.  The lines are\n"
19859                 "    plotted in the current color and line style. \n"
19860                 "\n"
19861                 "    Redacted form:  General: plmeridians(mapform, dlong, dlat, minlong,\n"
19862                 "    maxlong, minlat, maxlat)\n"
19863                 "           F95, Java, Perl/PDL, Python: Not implemented? \n"
19864                 "\n"
19865                 "\n"
19866                 "    This function is used in example 19. \n"
19867                 "\n"
19868                 "\n"
19869                 "\n"
19870                 "SYNOPSIS:\n"
19871                 "\n"
19872                 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
19873                 "\n"
19874                 "ARGUMENTS:\n"
19875                 "\n"
19876                 "    mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) :    A user\n"
19877                 "    supplied function to transform the coordinate  longitudes and\n"
19878                 "    latitudes to a plot coordinate system.     By using this transform,\n"
19879                 "    we can change from a longitude,  latitude coordinate to a polar\n"
19880                 "    stereographic project, for  example.  Initially, x[0]..[n-1] are\n"
19881                 "    the longitudes and y[0]..y[n-1]  are the corresponding latitudes. \n"
19882                 "    After the call to mapform(), x[]  and y[] should be replaced by\n"
19883                 "    the corresponding plot coordinates.   If no transform is desired,\n"
19884                 "    mapform can be replaced by NULL. \n"
19885                 "\n"
19886                 "    dlong (PLFLT, input) :    The interval in degrees at which the\n"
19887                 "    longitude lines are to be plotted. \n"
19888                 "\n"
19889                 "    dlat (PLFLT, input) :    The interval in degrees at which the latitude\n"
19890                 "    lines are to be plotted. \n"
19891                 "\n"
19892                 "    minlong (PLFLT, input) :    The value of the longitude on the left\n"
19893                 "    side of the plot.  The value of minlong must be less than the\n"
19894                 "    value of maxlong, and the  quantity maxlong-minlong must be less\n"
19895                 "    than or equal to 360. \n"
19896                 "\n"
19897                 "    maxlong (PLFLT, input) :    The value of the longitude on the right\n"
19898                 "    side of the plot. \n"
19899                 "\n"
19900                 "    minlat (PLFLT, input) :    The minimum latitude to be plotted on the\n"
19901                 "    background.   One can always use -90.0 as the boundary outside the\n"
19902                 "    plot window  will be automatically eliminated.    However, the\n"
19903                 "    program will be  faster if one can reduce the size of the\n"
19904                 "    background plotted. \n"
19905                 "\n"
19906                 "    maxlat (PLFLT, input) :    The maximum latitudes to be plotted on the\n"
19907                 "    background.   One can always use 90.0 as the boundary outside the\n"
19908                 "    plot window  will be automatically eliminated. \n"
19909                 "\n"
19910                 ""},
19911          { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
19912                 "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
19913                 "\n"
19914                 "DESCRIPTION:\n"
19915                 "\n"
19916                 "    Plot a 2D matrix using color palette 1.  The color scale is\n"
19917                 "    automatically adjusted to use the maximum and minimum values in idata\n"
19918                 "    as valuemin and valuemax in a call to plimagefr. \n"
19919                 "\n"
19920                 "    Redacted form:  General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
19921                 "    zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
19922                 "\n"
19923                 "\n"
19924                 "    This function is used in example 20. \n"
19925                 "\n"
19926                 "\n"
19927                 "\n"
19928                 "SYNOPSIS:\n"
19929                 "\n"
19930                 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
19931                 "\n"
19932                 "ARGUMENTS:\n"
19933                 "\n"
19934                 "    idata (PLFLT**, input) :    A 2D array of values (intensities) to\n"
19935                 "    plot.  Should have dimensions idata[nx][ny]. \n"
19936                 "\n"
19937                 "    nx, ny (PLINT, input) :    Dimensions of idata \n"
19938                 "\n"
19939                 "    xmin, xmax, ymin, ymax (PLFLT, input) :    Plot coordinates to strecth\n"
19940                 "    the image data to.  idata[0][0] corresponds to (xmin, ymin) and\n"
19941                 "    idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
19942                 "\n"
19943                 "    zmin, zmax (PLFLT, input) :    Only data between zmin and zmax\n"
19944                 "    (inclusive) will be plotted. \n"
19945                 "\n"
19946                 "    Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) :    Plot only the window of\n"
19947                 "    points whose plot coordinates fall inside the window of (Dxmin,\n"
19948                 "    Dymin) to (Dxmax, Dymax). \n"
19949                 "\n"
19950                 ""},
19951          { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
19952                 "Plot a 2D matrix using color map1 \n"
19953                 "\n"
19954                 "DESCRIPTION:\n"
19955                 "\n"
19956                 "    Plot a 2D matrix using color map1. \n"
19957                 "\n"
19958                 "    Redacted form:  General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
19959                 "    zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
19960                 "\n"
19961                 "\n"
19962                 "    This function is used in example 20. \n"
19963                 "\n"
19964                 "\n"
19965                 "\n"
19966                 "SYNOPSIS:\n"
19967                 "\n"
19968                 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
19969                 "\n"
19970                 "ARGUMENTS:\n"
19971                 "\n"
19972                 "    idata (PLFLT**, input) :    A 2D array of values (intensities) to\n"
19973                 "    plot.  Should have dimensions idata[nx][ny]. \n"
19974                 "\n"
19975                 "    nx, ny (PLINT, input) :    Dimensions of idata \n"
19976                 "\n"
19977                 "    xmin, xmax, ymin, ymax (PLFLT, input) :    Plot coordinates to strecth\n"
19978                 "    the image data to.  idata[0][0] corresponds to (xmin, ymin) and\n"
19979                 "    idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
19980                 "\n"
19981                 "    zmin, zmax (PLFLT, input) :    Only data between zmin and zmax\n"
19982                 "    (inclusive) will be plotted. \n"
19983                 "\n"
19984                 "    valuemin, valuemax (PLFLT, input) :    The minimum and maximum data\n"
19985                 "    values to use for value to color mappings.  A datum equal to or\n"
19986                 "    less than valuemin will be plotted with color 0.0, while a datum\n"
19987                 "    equal to or greater than valuemax will be plotted with color 1.0. \n"
19988                 "    Data between valuemin and valuemax map linearly to colors between\n"
19989                 "    0.0 and 1.0. \n"
19990                 "\n"
19991                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19992                 "      Pointer to function that defines a transformation between the\n"
19993                 "    data in the array idata and world coordinates.    An input\n"
19994                 "    coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
19995                 "    while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
19996                 "    Some transformation functions are provided in the PLplot library:\n"
19997                 "    pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
19998                 "    mappings respectively defined by one- and two-dimensional arrays. \n"
19999                 "    In addition, user-supplied routines for the transformation can be\n"
20000                 "    used as well.  Examples of all of these approaches are given in\n"
20001                 "    the PLplot documentation.  The transformation function should have\n"
20002                 "    the form given by any of pltr0, pltr1, or pltr2. \n"
20003                 "\n"
20004                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
20005                 "    information to pltr0, pltr1, pltr2, or whatever routine is\n"
20006                 "    externally supplied. \n"
20007                 "\n"
20008                 ""},
20009          { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
20010          { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
20011          { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
20012          { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
20013          { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
20014          { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
20015          { NULL, NULL, 0, NULL }
20016 };
20017 
20018 
20019 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20020 
20021 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
20022 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
20023 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
20024 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20025 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20026 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
20027 static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void = {"_p_f_double_double_p_double_p_double_p_void__void", "ct_func|pltr_func|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
20028 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
20029 static swig_type_info _swigt__p_f_int_p_double_p_double__void = {"_p_f_int_p_double_p_double__void", "mapform_func|void (*)(int,double *,double *)", 0, 0, (void*)0, 0};
20030 static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
20031 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20032 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20033 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
20034 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20035 
20036 static swig_type_info *swig_type_initial[] = {
20037   &_swigt__p_PLGraphicsIn,
20038   &_swigt__p_PLcGrid,
20039   &_swigt__p_PLcGrid2,
20040   &_swigt__p_char,
20041   &_swigt__p_double,
20042   &_swigt__p_f_double_double__int,
20043   &_swigt__p_f_double_double_p_double_p_double_p_void__void,
20044   &_swigt__p_f_int_double_p_char_int_p_void__void,
20045   &_swigt__p_f_int_p_double_p_double__void,
20046   &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
20047   &_swigt__p_int,
20048   &_swigt__p_p_char,
20049   &_swigt__p_p_double,
20050   &_swigt__p_unsigned_int,
20051 };
20052 
20053 static swig_cast_info _swigc__p_PLGraphicsIn[] = {  {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20054 static swig_cast_info _swigc__p_PLcGrid[] = {  {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
20055 static swig_cast_info _swigc__p_PLcGrid2[] = {  {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
20056 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20057 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20058 static swig_cast_info _swigc__p_f_double_double__int[] = {  {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
20059 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = {  {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
20060 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = {  {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
20061 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = {  {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
20062 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = {  {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}};
20063 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20064 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20065 static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
20066 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20067 
20068 static swig_cast_info *swig_cast_initial[] = {
20069   _swigc__p_PLGraphicsIn,
20070   _swigc__p_PLcGrid,
20071   _swigc__p_PLcGrid2,
20072   _swigc__p_char,
20073   _swigc__p_double,
20074   _swigc__p_f_double_double__int,
20075   _swigc__p_f_double_double_p_double_p_double_p_void__void,
20076   _swigc__p_f_int_double_p_char_int_p_void__void,
20077   _swigc__p_f_int_p_double_p_double__void,
20078   _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
20079   _swigc__p_int,
20080   _swigc__p_p_char,
20081   _swigc__p_p_double,
20082   _swigc__p_unsigned_int,
20083 };
20084 
20085 
20086 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20087 
20088 static swig_const_info swig_const_table[] = {
20089 {0, 0, 0, 0.0, 0, 0}};
20090 
20091 #ifdef __cplusplus
20092 }
20093 #endif
20094 /* -----------------------------------------------------------------------------
20095  * Type initialization:
20096  * This problem is tough by the requirement that no dynamic 
20097  * memory is used. Also, since swig_type_info structures store pointers to 
20098  * swig_cast_info structures and swig_cast_info structures store pointers back
20099  * to swig_type_info structures, we need some lookup code at initialization. 
20100  * The idea is that swig generates all the structures that are needed. 
20101  * The runtime then collects these partially filled structures. 
20102  * The SWIG_InitializeModule function takes these initial arrays out of 
20103  * swig_module, and does all the lookup, filling in the swig_module.types
20104  * array with the correct data and linking the correct swig_cast_info
20105  * structures together.
20106  *
20107  * The generated swig_type_info structures are assigned staticly to an initial 
20108  * array. We just loop through that array, and handle each type individually.
20109  * First we lookup if this type has been already loaded, and if so, use the
20110  * loaded structure instead of the generated one. Then we have to fill in the
20111  * cast linked list. The cast data is initially stored in something like a
20112  * two-dimensional array. Each row corresponds to a type (there are the same
20113  * number of rows as there are in the swig_type_initial array). Each entry in
20114  * a column is one of the swig_cast_info structures for that type.
20115  * The cast_initial array is actually an array of arrays, because each row has
20116  * a variable number of columns. So to actually build the cast linked list,
20117  * we find the array of casts associated with the type, and loop through it 
20118  * adding the casts to the list. The one last trick we need to do is making
20119  * sure the type pointer in the swig_cast_info struct is correct.
20120  *
20121  * First off, we lookup the cast->type name to see if it is already loaded. 
20122  * There are three cases to handle:
20123  *  1) If the cast->type has already been loaded AND the type we are adding
20124  *     casting info to has not been loaded (it is in this module), THEN we
20125  *     replace the cast->type pointer with the type pointer that has already
20126  *     been loaded.
20127  *  2) If BOTH types (the one we are adding casting info to, and the 
20128  *     cast->type) are loaded, THEN the cast info has already been loaded by
20129  *     the previous module so we just ignore it.
20130  *  3) Finally, if cast->type has not already been loaded, then we add that
20131  *     swig_cast_info to the linked list (because the cast->type) pointer will
20132  *     be correct.
20133  * ----------------------------------------------------------------------------- */
20134 
20135 #ifdef __cplusplus
20136 extern "C" {
20137 #if 0
20138 } /* c-mode */
20139 #endif
20140 #endif
20141 
20142 #if 0
20143 #define SWIGRUNTIME_DEBUG
20144 #endif
20145 
20146 
20147 SWIGRUNTIME void
20148 SWIG_InitializeModule(void *clientdata) {
20149   size_t i;
20150   swig_module_info *module_head, *iter;
20151   int found, init;
20152   
20153   clientdata = clientdata;
20154   
20155   /* check to see if the circular list has been setup, if not, set it up */
20156   if (swig_module.next==0) {
20157     /* Initialize the swig_module */
20158     swig_module.type_initial = swig_type_initial;
20159     swig_module.cast_initial = swig_cast_initial;
20160     swig_module.next = &swig_module;
20161     init = 1;
20162   } else {
20163     init = 0;
20164   }
20165   
20166   /* Try and load any already created modules */
20167   module_head = SWIG_GetModule(clientdata);
20168   if (!module_head) {
20169     /* This is the first module loaded for this interpreter */
20170     /* so set the swig module into the interpreter */
20171     SWIG_SetModule(clientdata, &swig_module);
20172     module_head = &swig_module;
20173   } else {
20174     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
20175     found=0;
20176     iter=module_head;
20177     do {
20178       if (iter==&swig_module) {
20179         found=1;
20180         break;
20181       }
20182       iter=iter->next;
20183     } while (iter!= module_head);
20184     
20185     /* if the is found in the list, then all is done and we may leave */
20186     if (found) return;
20187     /* otherwise we must add out module into the list */
20188     swig_module.next = module_head->next;
20189     module_head->next = &swig_module;
20190   }
20191   
20192   /* When multiple interpeters are used, a module could have already been initialized in
20193        a different interpreter, but not yet have a pointer in this interpreter.
20194        In this case, we do not want to continue adding types... everything should be
20195        set up already */
20196   if (init == 0) return;
20197   
20198   /* Now work on filling in swig_module.types */
20199 #ifdef SWIGRUNTIME_DEBUG
20200   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20201 #endif
20202   for (i = 0; i < swig_module.size; ++i) {
20203     swig_type_info *type = 0;
20204     swig_type_info *ret;
20205     swig_cast_info *cast;
20206     
20207 #ifdef SWIGRUNTIME_DEBUG
20208     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20209 #endif
20210     
20211     /* if there is another module already loaded */
20212     if (swig_module.next != &swig_module) {
20213       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20214     }
20215     if (type) {
20216       /* Overwrite clientdata field */
20217 #ifdef SWIGRUNTIME_DEBUG
20218       printf("SWIG_InitializeModule: found type %s\n", type->name);
20219 #endif
20220       if (swig_module.type_initial[i]->clientdata) {
20221         type->clientdata = swig_module.type_initial[i]->clientdata;
20222 #ifdef SWIGRUNTIME_DEBUG
20223         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20224 #endif
20225       }
20226     } else {
20227       type = swig_module.type_initial[i];
20228     }
20229     
20230     /* Insert casting types */
20231     cast = swig_module.cast_initial[i];
20232     while (cast->type) {
20233       /* Don't need to add information already in the list */
20234       ret = 0;
20235 #ifdef SWIGRUNTIME_DEBUG
20236       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20237 #endif
20238       if (swig_module.next != &swig_module) {
20239         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20240 #ifdef SWIGRUNTIME_DEBUG
20241         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20242 #endif
20243       }
20244       if (ret) {
20245         if (type == swig_module.type_initial[i]) {
20246 #ifdef SWIGRUNTIME_DEBUG
20247           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20248 #endif
20249           cast->type = ret;
20250           ret = 0;
20251         } else {
20252           /* Check for casting already in the list */
20253           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20254 #ifdef SWIGRUNTIME_DEBUG
20255           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20256 #endif
20257           if (!ocast) ret = 0;
20258         }
20259       }
20260       
20261       if (!ret) {
20262 #ifdef SWIGRUNTIME_DEBUG
20263         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20264 #endif
20265         if (type->cast) {
20266           type->cast->prev = cast;
20267           cast->next = type->cast;
20268         }
20269         type->cast = cast;
20270       }
20271       cast++;
20272     }
20273     /* Set entry in modules->types array equal to the type */
20274     swig_module.types[i] = type;
20275   }
20276   swig_module.types[i] = 0;
20277   
20278 #ifdef SWIGRUNTIME_DEBUG
20279   printf("**** SWIG_InitializeModule: Cast List ******\n");
20280   for (i = 0; i < swig_module.size; ++i) {
20281     int j = 0;
20282     swig_cast_info *cast = swig_module.cast_initial[i];
20283     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20284     while (cast->type) {
20285       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
20286       cast++;
20287       ++j;
20288     }
20289     printf("---- Total casts: %d\n",j);
20290   }
20291   printf("**** SWIG_InitializeModule: Cast List ******\n");
20292 #endif
20293 }
20294 
20295 /* This function will propagate the clientdata field of type to
20296 * any new swig_type_info structures that have been added into the list
20297 * of equivalent types.  It is like calling
20298 * SWIG_TypeClientData(type, clientdata) a second time.
20299 */
20300 SWIGRUNTIME void
20301 SWIG_PropagateClientData(void) {
20302   size_t i;
20303   swig_cast_info *equiv;
20304   static int init_run = 0;
20305   
20306   if (init_run) return;
20307   init_run = 1;
20308   
20309   for (i = 0; i < swig_module.size; i++) {
20310     if (swig_module.types[i]->clientdata) {
20311       equiv = swig_module.types[i]->cast;
20312       while (equiv) {
20313         if (!equiv->converter) {
20314           if (equiv->type && !equiv->type->clientdata)
20315           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
20316         }
20317         equiv = equiv->next;
20318       }
20319     }
20320   }
20321 }
20322 
20323 #ifdef __cplusplus
20324 #if 0
20325 {
20326   /* c-mode */
20327 #endif
20328 }
20329 #endif
20330 
20331 
20332 
20333 #ifdef __cplusplus
20334 extern "C" {
20335 #endif
20336   
20337   /* Python-specific SWIG API */
20338 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
20339 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
20340 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
20341   
20342   /* -----------------------------------------------------------------------------
20343    * global variable support code.
20344    * ----------------------------------------------------------------------------- */
20345   
20346   typedef struct swig_globalvar {
20347     char       *name;                  /* Name of global variable */
20348     PyObject *(*get_attr)(void);       /* Return the current value */
20349     int       (*set_attr)(PyObject *); /* Set the value */
20350     struct swig_globalvar *next;
20351   } swig_globalvar;
20352   
20353   typedef struct swig_varlinkobject {
20354     PyObject_HEAD
20355     swig_globalvar *vars;
20356   } swig_varlinkobject;
20357   
20358   SWIGINTERN PyObject *
20359   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
20360 #if PY_VERSION_HEX >= 0x03000000
20361     return PyUnicode_InternFromString("<Swig global variables>");
20362 #else
20363     return PyString_FromString("<Swig global variables>");
20364 #endif
20365   }
20366   
20367   SWIGINTERN PyObject *
20368   swig_varlink_str(swig_varlinkobject *v) {
20369 #if PY_VERSION_HEX >= 0x03000000
20370     PyObject *str = PyUnicode_InternFromString("(");
20371     PyObject *tail;
20372     PyObject *joined;
20373     swig_globalvar *var;
20374     for (var = v->vars; var; var=var->next) {
20375       tail = PyUnicode_FromString(var->name);
20376       joined = PyUnicode_Concat(str, tail);
20377       Py_DecRef(str);
20378       Py_DecRef(tail);
20379       str = joined;
20380       if (var->next) {
20381         tail = PyUnicode_InternFromString(", ");
20382         joined = PyUnicode_Concat(str, tail);
20383         Py_DecRef(str);
20384         Py_DecRef(tail);
20385         str = joined;
20386       }
20387     }
20388     tail = PyUnicode_InternFromString(")");
20389     joined = PyUnicode_Concat(str, tail);
20390     Py_DecRef(str);
20391     Py_DecRef(tail);
20392     str = joined;
20393 #else
20394     PyObject *str = PyString_FromString("(");
20395     swig_globalvar *var;
20396     for (var = v->vars; var; var=var->next) {
20397       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
20398       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
20399     }
20400     PyString_ConcatAndDel(&str,PyString_FromString(")"));
20401 #endif
20402     return str;
20403   }
20404   
20405   SWIGINTERN int
20406   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
20407     char *tmp;
20408     PyObject *str = swig_varlink_str(v);
20409     fprintf(fp,"Swig global variables ");
20410     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
20411     SWIG_Python_str_DelForPy3(tmp);
20412     Py_DECREF(str);
20413     return 0;
20414   }
20415   
20416   SWIGINTERN void
20417   swig_varlink_dealloc(swig_varlinkobject *v) {
20418     swig_globalvar *var = v->vars;
20419     while (var) {
20420       swig_globalvar *n = var->next;
20421       free(var->name);
20422       free(var);
20423       var = n;
20424     }
20425   }
20426   
20427   SWIGINTERN PyObject *
20428   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
20429     PyObject *res = NULL;
20430     swig_globalvar *var = v->vars;
20431     while (var) {
20432       if (strcmp(var->name,n) == 0) {
20433         res = (*var->get_attr)();
20434         break;
20435       }
20436       var = var->next;
20437     }
20438     if (res == NULL && !PyErr_Occurred()) {
20439       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20440     }
20441     return res;
20442   }
20443   
20444   SWIGINTERN int
20445   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
20446     int res = 1;
20447     swig_globalvar *var = v->vars;
20448     while (var) {
20449       if (strcmp(var->name,n) == 0) {
20450         res = (*var->set_attr)(p);
20451         break;
20452       }
20453       var = var->next;
20454     }
20455     if (res == 1 && !PyErr_Occurred()) {
20456       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20457     }
20458     return res;
20459   }
20460   
20461   SWIGINTERN PyTypeObject*
20462   swig_varlink_type(void) {
20463     static char varlink__doc__[] = "Swig var link object";
20464     static PyTypeObject varlink_type;
20465     static int type_init = 0;  
20466     if (!type_init) {
20467       const PyTypeObject tmp
20468       = {
20469         /* PyObject header changed in Python 3 */
20470 #if PY_VERSION_HEX >= 0x03000000
20471         PyVarObject_HEAD_INIT(&PyType_Type, 0)
20472 #else
20473         PyObject_HEAD_INIT(NULL)
20474         0,                                  /* Number of items in variable part (ob_size) */
20475 #endif
20476         (char *)"swigvarlink",              /* Type name (tp_name) */
20477         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
20478         0,                                  /* Itemsize (tp_itemsize) */
20479         (destructor) swig_varlink_dealloc,  /* Deallocator (tp_dealloc) */ 
20480         (printfunc) swig_varlink_print,     /* Print (tp_print) */
20481         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
20482         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
20483         0,                                  /* tp_compare */
20484         (reprfunc) swig_varlink_repr,       /* tp_repr */
20485         0,                                  /* tp_as_number */
20486         0,                                  /* tp_as_sequence */
20487         0,                                  /* tp_as_mapping */
20488         0,                                  /* tp_hash */
20489         0,                                  /* tp_call */
20490         (reprfunc) swig_varlink_str,        /* tp_str */
20491         0,                                  /* tp_getattro */
20492         0,                                  /* tp_setattro */
20493         0,                                  /* tp_as_buffer */
20494         0,                                  /* tp_flags */
20495         varlink__doc__,                     /* tp_doc */
20496         0,                                  /* tp_traverse */
20497         0,                                  /* tp_clear */
20498         0,                                  /* tp_richcompare */
20499         0,                                  /* tp_weaklistoffset */
20500 #if PY_VERSION_HEX >= 0x02020000
20501         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
20502 #endif
20503 #if PY_VERSION_HEX >= 0x02030000
20504         0,                                  /* tp_del */
20505 #endif
20506 #ifdef COUNT_ALLOCS
20507         0,0,0,0                             /* tp_alloc -> tp_next */
20508 #endif
20509       };
20510       varlink_type = tmp;
20511       /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
20512 #if PY_VERSION_HEX < 0x03000000
20513       varlink_type.ob_type = &PyType_Type;
20514 #endif
20515       type_init = 1;
20516     }
20517     return &varlink_type;
20518   }
20519   
20520   /* Create a variable linking object for use later */
20521   SWIGINTERN PyObject *
20522   SWIG_Python_newvarlink(void) {
20523     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
20524     if (result) {
20525       result->vars = 0;
20526     }
20527     return ((PyObject*) result);
20528   }
20529   
20530   SWIGINTERN void 
20531   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
20532     swig_varlinkobject *v = (swig_varlinkobject *) p;
20533     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
20534     if (gv) {
20535       size_t size = strlen(name)+1;
20536       gv->name = (char *)malloc(size);
20537       if (gv->name) {
20538         strncpy(gv->name,name,size);
20539         gv->get_attr = get_attr;
20540         gv->set_attr = set_attr;
20541         gv->next = v->vars;
20542       }
20543     }
20544     v->vars = gv;
20545   }
20546   
20547   SWIGINTERN PyObject *
20548   SWIG_globals(void) {
20549     static PyObject *_SWIG_globals = 0; 
20550     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
20551     return _SWIG_globals;
20552   }
20553   
20554   /* -----------------------------------------------------------------------------
20555    * constants/methods manipulation
20556    * ----------------------------------------------------------------------------- */
20557   
20558   /* Install Constants */
20559   SWIGINTERN void
20560   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
20561     PyObject *obj = 0;
20562     size_t i;
20563     for (i = 0; constants[i].type; ++i) {
20564       switch(constants[i].type) {
20565       case SWIG_PY_POINTER:
20566         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
20567         break;
20568       case SWIG_PY_BINARY:
20569         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
20570         break;
20571       default:
20572         obj = 0;
20573         break;
20574       }
20575       if (obj) {
20576         PyDict_SetItemString(d, constants[i].name, obj);
20577         Py_DECREF(obj);
20578       }
20579     }
20580   }
20581   
20582   /* -----------------------------------------------------------------------------*/
20583   /* Fix SwigMethods to carry the callback ptrs when needed */
20584   /* -----------------------------------------------------------------------------*/
20585   
20586   SWIGINTERN void
20587   SWIG_Python_FixMethods(PyMethodDef *methods,
20588     swig_const_info *const_table,
20589     swig_type_info **types,
20590     swig_type_info **types_initial) {
20591     size_t i;
20592     for (i = 0; methods[i].ml_name; ++i) {
20593       const char *c = methods[i].ml_doc;
20594       if (c && (c = strstr(c, "swig_ptr: "))) {
20595         int j;
20596         swig_const_info *ci = 0;
20597         const char *name = c + 10;
20598         for (j = 0; const_table[j].type; ++j) {
20599           if (strncmp(const_table[j].name, name, 
20600               strlen(const_table[j].name)) == 0) {
20601             ci = &(const_table[j]);
20602             break;
20603           }
20604         }
20605         if (ci) {
20606           size_t shift = (ci->ptype) - types;
20607           swig_type_info *ty = types_initial[shift];
20608           size_t ldoc = (c - methods[i].ml_doc);
20609           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
20610           char *ndoc = (char*)malloc(ldoc + lptr + 10);
20611           if (ndoc) {
20612             char *buff = ndoc;
20613             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
20614             if (ptr) {
20615               strncpy(buff, methods[i].ml_doc, ldoc);
20616               buff += ldoc;
20617               strncpy(buff, "swig_ptr: ", 10);
20618               buff += 10;
20619               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
20620               methods[i].ml_doc = ndoc;
20621             }
20622           }
20623         }
20624       }
20625     }
20626   } 
20627   
20628 #ifdef __cplusplus
20629 }
20630 #endif
20631 
20632 /* -----------------------------------------------------------------------------*
20633  *  Partial Init method
20634  * -----------------------------------------------------------------------------*/
20635 
20636 #ifdef __cplusplus
20637 extern "C"
20638 #endif
20639 
20640 SWIGEXPORT 
20641 #if PY_VERSION_HEX >= 0x03000000
20642 PyObject*
20643 #else
20644 void
20645 #endif
20646 SWIG_init(void) {
20647   PyObject *m, *d;  
20648 #if PY_VERSION_HEX >= 0x03000000
20649   static struct PyModuleDef SWIG_module = {
20650     PyModuleDef_HEAD_INIT,
20651     (char *) SWIG_name,
20652     NULL,
20653     -1,
20654     SwigMethods,
20655     NULL,
20656     NULL,
20657     NULL,
20658     NULL
20659   };
20660 #endif
20661   
20662   /* Fix SwigMethods to carry the callback ptrs when needed */
20663   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
20664   
20665 #if PY_VERSION_HEX >= 0x03000000
20666   m = PyModule_Create(&SWIG_module);
20667 #else
20668   m = Py_InitModule((char *) SWIG_name, SwigMethods);
20669 #endif
20670   d = PyModule_GetDict(m);
20671   
20672   SWIG_InitializeModule(0);
20673   SWIG_InstallConstants(d,swig_const_table);
20674   
20675   
20676   
20677   import_array();
20678   
20679   SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
20680   SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
20681   SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
20682   SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
20683   SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
20684   SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
20685   SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
20686   SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
20687   SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
20688   SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
20689   SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
20690   SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
20691   SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
20692   SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
20693   SWIG_Python_SetConstant(d, "PLESC_PLFLTBUFFERING",SWIG_From_int((int)(15)));
20694   SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
20695   SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
20696   SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
20697   SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
20698   SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
20699   SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
20700   SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
20701   SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x01)));
20702   SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x02)));
20703   SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x03)));
20704   SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x04)));
20705   SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x08)));
20706   SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x10)));
20707   SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x20)));
20708   SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x40)));
20709   SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x80)));
20710   SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
20711   SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0)));
20712   SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(1)));
20713   SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(2)));
20714   SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(4)));
20715   SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0)));
20716   SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(1)));
20717   SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(2)));
20718   SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(8)));
20719   SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(16)));
20720   SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(1)));
20721   SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(2)));
20722   SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(4)));
20723   SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(8)));
20724   SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(16)));
20725   SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(32)));
20726   SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(64)));
20727   SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(128)));
20728   SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(1)));
20729   SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(2)));
20730   SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(4)));
20731   SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(8)));
20732   SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(16)));
20733   SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(32)));
20734   SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(64)));
20735   SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(128)));
20736   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(1)));
20737   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(2)));
20738   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(4)));
20739   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(8)));
20740   SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(16)));
20741   SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(32)));
20742   SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(64)));
20743   SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(128)));
20744   SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(256)));
20745   SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(512)));
20746   SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
20747   SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
20748   SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
20749   SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
20750   SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
20751   SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
20752   SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
20753   SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
20754   SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
20755   SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
20756   SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
20757   SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
20758   SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
20759   SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
20760   SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
20761   SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
20762   SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
20763   SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
20764   SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
20765   SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
20766   SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
20767   SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
20768   SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
20769   SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
20770   SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
20771   SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
20772   SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
20773   SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
20774   SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
20775   SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
20776   SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
20777   SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
20778   SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
20779   SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
20780   SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
20781   SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
20782   SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
20783   SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
20784   SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
20785   SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
20786   SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
20787   SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
20788   SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
20789   SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
20790   SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
20791   SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_ENABLE",SWIG_From_int((int)(1)));
20792   SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_DISABLE",SWIG_From_int((int)(2)));
20793   SWIG_Python_SetConstant(d, "PLESPLFLTBUFFERING_QUERY",SWIG_From_int((int)(3)));
20794   SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
20795   SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
20796   SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
20797   SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
20798   SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
20799   SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
20800 #if PY_VERSION_HEX >= 0x03000000
20801   return m;
20802 #else
20803   return;
20804 #endif
20805 }
20806 

Generated on Wed Oct 12 2011 20:42:22 for PLplot by  doxygen 1.7.1