Interface SWIGLALOmega.i

SWIG code which must appear after the LAL headers.

Author

Karl Wette

Specialised wrapping of <tt>gsl_rng</tt>

Wrap the gsl_rng class.

typedef struct {
  %extend {

• Construct a new gsl_rng from another gsl_rng.

  gsl_rng(const gsl_rng* rng) {
    XLAL_CHECK_NULL(rng != NULL, XLAL_EFAULT);
    return gsl_rng_clone(rng);
  }

• Construct a new gsl_rng from a generator name and random seed.

  gsl_rng(const char* name, unsigned long int seed) {
    XLAL_CHECK_NULL(name != NULL, XLAL_EFAULT, "Generator name must be non-NULL");
    gsl_rng_env_setup();
    const gsl_rng_type* T = NULL;
    if (strcmp(name, "default") == 0) {
      T = gsl_rng_default;
    } else {
      const gsl_rng_type **types = gsl_rng_types_setup();
      for (const gsl_rng_type **t = types; *t != NULL; ++t) {
        if (strcmp(name, (*t)->name) == 0) {
          T = *t;
          break;
        }
      }
    }
    XLAL_CHECK_NULL(T != NULL, XLAL_EINVAL, "Could not find generator named '%s'", name);
    gsl_rng* rng = gsl_rng_alloc(T);
    gsl_rng_set(rng, seed);
    return rng;
  }

• Destroy a gsl_rng.

  ~gsl_rng() {
    %swiglal_struct_call_dtor(gsl_rng_free, $self);
  }

• Properties and methods of a gsl_rng, most of which map to gsl_rng_...() functions.

  const char* name();
  double uniform();
  double uniform_pos();
  unsigned long int uniform_int(unsigned long int n);
  void set_seed(unsigned long int seed) {
    gsl_rng_set($self, seed);
  }
  unsigned long int get_value() {
    return gsl_rng_get($self);
  }
  unsigned long int max_value() {
    return gsl_rng_max($self);
  }
  unsigned long int min_value() {
    return gsl_rng_min($self);
  }

  }
} gsl_rng;

Specialised wrapping of <tt>LIGOTimeGPS</tt>

Extend the LIGOTimeGPS class.

%extend tagLIGOTimeGPS {

• Construct a new LIGOTimeGPS from a real number.

  tagLIGOTimeGPS(REAL8 t) {
    return XLALGPSSetREAL8(%swiglal_new_instance(LIGOTimeGPS), t);
  }

• Construct a new LIGOTimeGPS from integer seconds and nanoseconds.

  tagLIGOTimeGPS(INT4 gpssec) {
    return XLALGPSSet(%swiglal_new_instance(LIGOTimeGPS), gpssec, 0);
  }
  tagLIGOTimeGPS(INT4 gpssec, INT8 gpsnan) {
    return XLALGPSSet(%swiglal_new_instance(LIGOTimeGPS), gpssec, gpsnan);
  }

• Construct a new LIGOTimeGPS from a string

  tagLIGOTimeGPS(const char *str) {
    XLAL_CHECK_NULL(str != NULL, XLAL_EFAULT);
    LIGOTimeGPS *gps = %swiglal_new_instance(LIGOTimeGPS);
    char *end = NULL;
    if (XLALStrToGPS(gps, str, &end) < 0 || *end != '\0') {
      XLALFree(gps);
      XLAL_ERROR_NULL(XLAL_EINVAL, "'%s' is not a valid LIGOTimeGPS", str);
    }
    return gps;
  }

• Operators are implemented by defining Python-style operator methods (since LAL is C99, we don't have C++ operators available). Many SWIG language modules will automatically map these functions to scripting-language operations in their runtime code. In some cases (ironically, Python itself when using -builtin!) additional directives are needed in the scripting-language-specific interface. Note that although C LIGOTimeGPS objects are naturally mutable, the SWIG version is exported as an immutable type to emulate other numeric types like floats and ints (we do not implement .__iadd__() and other in-place operators). In Python this allows LIGOTimeGPS objects to be used as dictionary keys, just as other numbers can be.

• Return new LIGOTimeGPS which are the positive and negative values of $self.

  LIGOTimeGPS* __pos__() {
    return XLALINT8NSToGPS(%swiglal_new_instance(LIGOTimeGPS), +XLALGPSToINT8NS($self));
  }
  LIGOTimeGPS* __neg__() {
    return XLALINT8NSToGPS(%swiglal_new_instance(LIGOTimeGPS), -XLALGPSToINT8NS($self));
  }

• Return a new LIGOTimeGPS which is the absolute value of $self.

  LIGOTimeGPS* __abs__() {
    return XLALINT8NSToGPS(%swiglal_new_instance(LIGOTimeGPS), llabs(XLALGPSToINT8NS($self)));
  }

• Return whether a LIGOTimeGPS is non-zero.

  bool __nonzero__() {
    return $self->gpsSeconds || $self->gpsNanoSeconds;
  }

• Return integer representations of the LIGOTimeGPS seconds.

  int __int__() {
    return $self->gpsSeconds;
  }
  long __long__() {
    return $self->gpsSeconds;
  }

• Return a floating-point representation of a LIGOTimeGPS.

  double __float__() {
    return XLALGPSGetREAL8($self);
  }

• Return a string representation of a LIGOTimeGPS. Because XLALGPSToStr() allocates a new string using LAL memory, %newobject is used to make SWIG use a 'newfree' typemap, where the string is freed; SWIG will have already copied it to a native scripting-language string to return as output.

  %newobject __str__;
  %typemap(newfree) char* __str__ "XLALFree($1);";
  char* __str__() {
    return XLALGPSToStr(NULL, $self);
  }
  %newobject __repr__;
  %typemap(newfree) char* __repr__ "XLALFree($1);";
  char* __repr__() {
    return XLALStringAppendFmt(NULL, "LIGOTimeGPS(%d, %d)", $self->gpsSeconds, $self->gpsNanoSeconds);
  }
  %newobject asutcstr;
  %typemap(newfree) char* asutcstr "XLALFree($1);";
  char* asutcstr() {
    LIGOTimeGPS gps;
    /* use XLALGPSSet() to normalize the nanoseconds */
    XLALGPSSet(&gps, $self->gpsSeconds, $self->gpsNanoSeconds);
    if (gps.gpsNanoSeconds < 0) {
      gps.gpsSeconds -= 1;
      gps.gpsNanoSeconds += XLAL_BILLION_INT4;
    }
    struct tm utc;
    XLAL_CHECK_NULL(XLALGPSToUTC(&utc, gps.gpsSeconds) != NULL, XLAL_EFUNC);
    char datebuf[256] = {0};
    const size_t datelen = strftime(datebuf, sizeof(datebuf), "%a, %d %b %Y %H:%M:%S", &utc);
    XLAL_CHECK_NULL(datelen > 0, XLAL_ESYS);
    XLAL_CHECK_NULL(datelen < sizeof(datebuf), XLAL_ESYS);
    char nsbuf[256] = {0};
    if (gps.gpsNanoSeconds != 0) {
      const int nslen = snprintf(nsbuf, sizeof(nsbuf), ".%09ld", (long) gps.gpsNanoSeconds);
      XLAL_CHECK_NULL(nslen > 0, XLAL_ESYS);
      XLAL_CHECK_NULL(nslen < (int)sizeof(nsbuf), XLAL_ESYS);
      char *end = nsbuf + nslen;
      while (*(--end) == '0') {
        *end = 0;
      }
    }
    return XLALStringAppendFmt(NULL, "%s%s +0000", datebuf, nsbuf);
  }

• Return the hash value of a LIGOTimeGPS.

  long __hash__() {
    long hash = (long)$self->gpsSeconds ^ (long)$self->gpsNanoSeconds;
    return hash == -1 ? -2 : hash;
  }

• Binary operators need only be implemented for two LIGOTimeGPS arguments; the specialised input typemaps defined above will then allow other suitable types to be substituted as arguments. In some cases, however, we do implement special cases for some types to avoid loss of precision.

• Return the addition of two LIGOTimeGPS.

  LIGOTimeGPS* __add__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSAddGPS(retn, gps);
  }
  LIGOTimeGPS* __radd__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*gps, LIGOTimeGPS);
    return XLALGPSAddGPS(retn, $self);
  }

• Return the subtraction of two LIGOTimeGPS.

  LIGOTimeGPS* __sub__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSSubGPS(retn, gps);
  }
  LIGOTimeGPS* __rsub__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*gps, LIGOTimeGPS);
    return XLALGPSSubGPS(retn, $self);
  }

• Return the multiplication of a LIGOTimeGPS by a number or another LIGOTimeGPS. A special typemap is needed for Python: since built-in types call the same function for both normal and reverse operators, so the function must support (LIGOTimeGPS, LIGOTimeGPS), (LIGOTimeGPS, double), and (double, LIGOTimeGPS) as inputs.

  %typemap(in, noblock=1, fragment=SWIG_AsVal_frag(double)) struct tagLIGOTimeGPS* self (LIGOTimeGPS tmp, void *argp = 0, int res = 0, int self_set = 0, int factor_set = 0) {
    res = SWIG_ConvertPtr($input, &argp, $descriptor, $disown | %convertptr_flags);
    if (SWIG_IsOK(res)) {
      arg1 = %reinterpret_cast(argp, $ltype);
      self_set = 1;
    } else {
      res = SWIG_AsVal(double)($input, &arg2);
      if (SWIG_IsOK(res)) {
        factor_set = 1;
      } else {
        res = swiglal_specialised_tagLIGOTimeGPS($input, &tmp);
        if (SWIG_IsOK(res)) {
          arg1 = &tmp;
          self_set = 1;
        } else {
          %argument_fail(res, "$type", $symname, $argnum);
        }
      }
    }
  }
  %typemap(in, noblock=1, fragment=SWIG_AsVal_frag(double)) double factor (LIGOTimeGPS tmp, void *argp = 0, int res = 0) {
    if (!self_set1) {
      res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_tagLIGOTimeGPS, $disown | %convertptr_flags);
      if (SWIG_IsOK(res)) {
        arg1 = %reinterpret_cast(argp, LIGOTimeGPS*);
        self_set1 = 1;
      }
    }
    if (!factor_set1) {
      res = SWIG_AsVal(double)($input, &arg2);
      if (SWIG_IsOK(res)) {
        factor_set1 = 1;
      } else {
        res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_tagLIGOTimeGPS, $disown | %convertptr_flags);
        if (SWIG_IsOK(res)) {
          arg2 = XLALGPSGetREAL8(%reinterpret_cast(argp, LIGOTimeGPS*));
          factor_set1 = 1;
        } else {
          res = swiglal_specialised_tagLIGOTimeGPS($input, &tmp);
          if (SWIG_IsOK(res)) {
            arg2 = XLALGPSGetREAL8(&tmp);
            factor_set1 = 1;
          }
        }
      }
    }
    if (!self_set1 || !factor_set1) {
      %argument_fail(res, "$type", $symname, $argnum);
    }
  }
  LIGOTimeGPS* __mul__(double factor) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSMultiply(retn, factor);
  }
  LIGOTimeGPS* __rmul__(double factor) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSMultiply(retn, factor);
  }
  %clear struct tagLIGOTimeGPS* self;
  %clear double factor;

• Return the floating-point division of a LIGOTimeGPS by a number.

  LIGOTimeGPS* __div__(double divisor) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSDivide(retn, divisor);
  }
  LIGOTimeGPS* __div__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSDivide(retn, XLALGPSGetREAL8(gps));
  }
  LIGOTimeGPS* __rdiv__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*gps, LIGOTimeGPS);
    return XLALGPSDivide(retn, XLALGPSGetREAL8($self));
  }

• Return the integer division of two LIGOTimeGPS.

  LIGOTimeGPS* __floordiv__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSSetREAL8(retn, floor(XLALGPSGetREAL8(XLALGPSDivide(retn, XLALGPSGetREAL8(gps)))));
  }
  LIGOTimeGPS* __rfloordiv__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*gps, LIGOTimeGPS);
    return XLALGPSSetREAL8(retn, floor(XLALGPSGetREAL8(XLALGPSDivide(retn, XLALGPSGetREAL8($self)))));
  }

• Return the modulus of two LIGOTimeGPS.

  LIGOTimeGPS* __mod__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*$self, LIGOTimeGPS);
    return XLALGPSSetREAL8(retn, fmod(XLALGPSGetREAL8(retn), XLALGPSGetREAL8(gps)));
  }
  LIGOTimeGPS* __rmod__(LIGOTimeGPS* gps) {
    LIGOTimeGPS* retn = %swiglal_new_copy(*gps, LIGOTimeGPS);
    return XLALGPSSetREAL8(retn, fmod(XLALGPSGetREAL8(retn), XLALGPSGetREAL8($self)));
  }

• Comparison operators between two LIGOTimeGPS are generated by the following SWIG macro. NAME is the name of the Python operator and OP is the C operator. The correct comparison NAME is obtained by comparing the result of XLALGPSCmp() against zero using OP.

  %define %swiglal_LIGOTimeGPS_comparison_operator(NAME, OP)
    bool __##NAME##__(LIGOTimeGPS *gps, int SWIGLAL_CMP_OP_RETN_HACK) {
      return XLALGPSCmp($self, gps) OP 0;
    }
  %enddef
  %swiglal_LIGOTimeGPS_comparison_operator(lt, < );
  %swiglal_LIGOTimeGPS_comparison_operator(le, <=);
  %swiglal_LIGOTimeGPS_comparison_operator(eq, ==);
  %swiglal_LIGOTimeGPS_comparison_operator(ne, !=);
  %swiglal_LIGOTimeGPS_comparison_operator(gt, > );
  %swiglal_LIGOTimeGPS_comparison_operator(ge, >=);

• Return the number of nanoseconds in a LIGOTimeGPS.

  INT8 ns() {
    return XLALGPSToINT8NS($self);
  }

}

Specialised wrapping of <tt>LALUnit</tt>

Extend the LALUnit class.

%extend tagLALUnit {

• Construct a new LALUnit class from a string.

  tagLALUnit(const char* str) {
    LALUnit* unit = %swiglal_new_instance(LALUnit);
    if (XLALParseUnitString(unit, str) == NULL) {
      XLALFree(unit);
      XLALSetErrno(XLAL_EFUNC); /* Silently signal an error to wrapper function */
      return NULL;
    }
    return unit;
  }

• Return whether a LALUnit is non-zero, i.e. dimensionless.

  bool __nonzero__() {
    return !XLALUnitIsDimensionless($self);
  }

• Return integer representations of a LALUnit.

  int __int__() {
    return (int)XLALUnitPrefactor($self);
  }
  long __long__() {
    return (long)XLALUnitPrefactor($self);
  }

• Return a floating-point representation of a LALUnit.

  double __float__() {
    return XLALUnitPrefactor($self);
  }

• Return a string representation of a LALUnit. Because XLALUnitToString() allocates a new string using LAL memory, %newobject is used to make SWIG use a 'newfree' typemap, where the string is freed; SWIG will have already copied it to a native scripting-language string to return as output.

  %newobject __str__;
  %typemap(newfree) char* __str__ "XLALFree($1);";
  char* __str__() {
    LALUnit norm = *$self;
    assert(XLALUnitNormalize(&norm) == XLAL_SUCCESS);
    return XLALUnitToString(&norm);
  }
  %newobject __repr__;
  %typemap(newfree) char* __repr__ "XLALFree($1);";
  char* __repr__() {
    LALUnit norm = *$self;
    assert(XLALUnitNormalize(&norm) == XLAL_SUCCESS);
    return XLALUnitToString(&norm);
  }

• Return the hash value of a LALUnit.

  long __hash__() {
    long hash = (long)$self->powerOfTen;
    for (size_t i = 0; i < LALNumUnits; ++i) {
      hash ^= (long)$self->unitNumerator;
      hash ^= (long)$self->unitDenominatorMinusOne;
    }
    return hash == -1 ? -2 : hash;
  }

• Return the integer exponentiation of a LALUnit.

  LALUnit* __pow__(INT2 n, void* SWIGLAL_OP_POW_3RDARG) {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitRaiseINT2(retn, $self, n);
  }

• Return the rational exponentiation of a LALUnit.

  LALUnit* __pow__(INT2 r[2], void* SWIGLAL_OP_POW_3RDARG) {
    if (r[1] == 0) {
      XLALSetErrno(XLAL_EDOM); /* Silently signal an error to wrapper function */
      return NULL;
    }
    RAT4 rat;
    rat.numerator = (r[1] < 0) ? -r[0] : r[0];
    rat.denominatorMinusOne = abs(r[1]) - 1;
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitRaiseRAT4(retn, $self, &rat);
  }

• Return the multiplication of two LALUnit.

  LALUnit* __mul__(LALUnit* unit) {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitMultiply(retn, $self, unit);
  }
  LALUnit* __rmul__(LALUnit* unit) {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitMultiply(retn, unit, $self);
  }

• Return the division of two LALUnit.

  LALUnit* __div__(LALUnit* unit) {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitDivide(retn, $self, unit);
  }
  LALUnit* __rdiv__(LALUnit* unit) {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    return XLALUnitDivide(retn, unit, $self);
  }

• Comparison operators between two LALUnit.

  bool __eq__(LALUnit* unit, int SWIGLAL_CMP_OP_RETN_HACK) {
    return XLALUnitCompare($self, unit) == 0;
  }
  bool __ne__(LALUnit* unit, int SWIGLAL_CMP_OP_RETN_HACK) {
    return XLALUnitCompare($self, unit) != 0;
  }

• Return a normalised LALUnit.

  %newobject norm;
  LALUnit* norm() {
    LALUnit* retn = %swiglal_new_instance(LALUnit);
    *retn = *$self;
    assert(XLALUnitNormalize(retn) == XLAL_SUCCESS);
    return retn;
  }

}