basic.h

Go to the documentation of this file.

/* ------------------------------------------------------------
 * This is the file "basic.h" of the H2Lib package.
 * All rights reserved, Steffen Boerm 2009
 * ------------------------------------------------------------ */

#ifndef BASIC_H
#define BASIC_H

typedef struct _stopwatch stopwatch;

typedef stopwatch *pstopwatch;

#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#ifdef USE_CAIRO
#include <cairo/cairo.h>
#endif

#include "settings.h"

#ifdef USE_SIMD
#include "simd.h"
#endif

/* ------------------------------------------------------------
 * Miscellaneous
 * ------------------------------------------------------------ */

#ifndef M_PI
#define M_PI 3.141592653589793238462643383
#endif

#define NORM_STEPS 20

#define NC_DEFLATE_LEVEL 9

extern int max_pardepth;

#define H2_MACH_EPS 1e-13

/* ------------------------------------------------------------
 Set up the library
 ------------------------------------------------------------ */

HEADER_PREFIX void
init_h2lib(int *argc, char ***argv);

HEADER_PREFIX void
uninit_h2lib();

/* ------------------------------------------------------------
 * General utility macros and functions
 * ------------------------------------------------------------ */

#ifdef USE_SIMD
#define h2_malloc(sz) _mm_malloc(sz, VALIGN)
#else
#define h2_malloc(sz) malloc(sz)
#endif

#ifdef USE_SIMD
#define h2_free(p) _mm_free(p)
#else
#define h2_free(p) free(p)
#endif


HEADER_PREFIX size_t
get_current_memory();

#define ROUNDUP(x, N) ((((x) + (N) - 1) / (N)) * (N))

#ifdef ABS
#undef ABS
#endif

#ifdef UINT_MAX
#undef UINT_MAX
#endif

/* Macros for the type "field" */

#ifdef USE_COMPLEX
#ifdef USE_FLOAT
#define REAL(x) crealf(x)
#else
#define REAL(x) creal(x)
#endif
#else
#define REAL(x) (x)
#endif

#ifdef USE_COMPLEX
#ifdef USE_FLOAT
#define IMAG(x) cimagf(x)
#else
#define IMAG(x) cimag(x)
#endif
#else
#define IMAG(x) 0.0
#endif

#ifdef USE_COMPLEX
#ifdef USE_FLOAT
#define CONJ(x) conjf(x)
#else
#define CONJ(x) conj(x)
#endif
#else
#define CONJ(x) (x)
#endif

#define ABSSQR(x) _h2_abssqr(x)

#define ABS(x) REAL_SQRT(ABSSQR(x))

#define SIGN1(x) _h2_sgn1(x)

#define FIELD_RAND() _h2_fieldrand()

/* Macros for the type "real" */

#define REAL_ABS(x) fabs(x)

#define REAL_SQR(x) _h2_real_sqr(x)

#ifdef USE_FLOAT
#define REAL_SIN(x) sinf(x)
#else
#define REAL_SIN(x) sin(x)
#endif

#ifdef USE_FLOAT
#define REAL_COS(x) cosf(x)
#else
#define REAL_COS(x) cos(x)
#endif

#ifdef USE_FLOAT
#define REAL_ASIN(x) asinf(x)
#else
#define REAL_ASIN(x) asin(x)
#endif

#ifdef USE_FLOAT
#define REAL_ACOS(x) acosf(x)
#else
#define REAL_ACOS(x) acos(x)
#endif

#ifdef USE_FLOAT
#define REAL_TAN(x) tanf(x)
#else
#define REAL_TAN(x) tan(x)
#endif

#ifdef USE_FLOAT
#define REAL_SQRT(x) sqrtf(x)
#else
#define REAL_SQRT(x) sqrt(x)
#endif

#define REAL_RSQRT(x) _h2_rsqrt(x)

#ifdef USE_FLOAT
#define REAL_POW(x, y) powf(x, y)
#else
#define REAL_POW(x, y) pow(x, y)
#endif

#ifdef USE_FLOAT
#define REAL_LOG(x) logf(x)
#else
#define REAL_LOG(x) log(x)
#endif

#ifdef USE_FLOAT
#define REAL_EXP(x) expf(x)
#else
#define REAL_EXP(x) exp(x)
#endif

#define REAL_RAND() _h2_realrand()

#define DOT2(x,y) (CONJ((x)[0]) * (y)[0] + CONJ((x)[1]) * (y)[1])

#define DOT3(x,y) (CONJ((x)[0]) * (y)[0] + CONJ((x)[1]) * (y)[1] + CONJ((x)[2]) * (y)[2])

#define NORMSQR2(x,y) (ABSSQR(x) + ABSSQR(y))

#define NORMSQR3(x,y,z) (ABSSQR(x) + ABSSQR(y) + ABSSQR(z))

#define NORM2(x,y) REAL_SQRT(ABSSQR(x) + ABSSQR(y))

#define NORM3(x,y,z) REAL_SQRT(ABSSQR(x) + ABSSQR(y) + ABSSQR(z))

#define REAL_DOT2(x,y) ((x)[0] * (y)[0] + (x)[1] * (y)[1])

#define REAL_DOT3(x,y) ((x)[0] * (y)[0] + (x)[1] * (y)[1] + (x)[2] * (y)[2])

#define REAL_NORMSQR2(x,y) (REAL_SQR(x) + REAL_SQR(y))

#define REAL_NORMSQR3(x,y,z) (REAL_SQR(x) + REAL_SQR(y) + REAL_SQR(z))

#define REAL_NORM2(x,y) REAL_SQRT(REAL_SQR(x) + REAL_SQR(y))

#define REAL_NORM3(x,y,z) REAL_SQRT(REAL_SQR(x) + REAL_SQR(y) + REAL_SQR(z))

#define REAL_MAX(x, y) _h2_realmax(x, y)

#define REAL_MAX3(x, y, z) _h2_realmax3(x, y, z)

#define REAL_MIN(x, y) _h2_realmin(x, y)

#define REAL_MIN3(x, y, z) _h2_realmin3(x, y, z)

/* Macros for the type "uint" */

#define UINT_MAX(x, y) _h2_uintmax(x, y)

#define UINT_MAX3(x, y, z) _h2_uintmax3(x, y, z)

#define UINT_MIN(x, y) _h2_uintmin(x, y)

#define UINT_MIN3(x, y, z) _h2_uintmin3(x, y, z)

#ifdef __GNUC__
INLINE_PREFIX real _h2_rsqrt(real x) __attribute__((unused,const));
INLINE_PREFIX real _h2_abssqr(field x) __attribute__((unused,const));
INLINE_PREFIX field _h2_sgn1(field x) __attribute__((unused,const));
INLINE_PREFIX field _h2_fieldrand() __attribute__((unused,const));
INLINE_PREFIX real _h2_real_sqr(real x) __attribute__((unused,const));
INLINE_PREFIX real _h2_realmax(real a, real b) __attribute__((unused,const));
INLINE_PREFIX real _h2_realmax3(real a, real b, real c) __attribute__((unused,const));
INLINE_PREFIX real _h2_realmin(real a, real b) __attribute__((unused,const));
INLINE_PREFIX real _h2_realmin3(real a, real b, real c) __attribute__((unused,const));
INLINE_PREFIX real _h2_realrand() __attribute__((unused,const));
INLINE_PREFIX uint _h2_uintmax(uint a, uint b) __attribute__((unused,const));
INLINE_PREFIX uint _h2_uintmax3(uint a, uint b, uint c) __attribute__((unused,const));
INLINE_PREFIX uint _h2_uintmin(uint a, uint b) __attribute__((unused,const));
INLINE_PREFIX uint _h2_uintmin3(uint a, uint b, uint c) __attribute__((unused,const));
#else
INLINE_PREFIX real _h2_realrand();
#endif

INLINE_PREFIX real _h2_rsqrt(real x) {
  return r_one / REAL_SQRT(x);
}

#ifdef USE_COMPLEX
INLINE_PREFIX real _h2_abssqr(field x) {
  real rx = REAL(x);
  real ix = IMAG(x);

  return rx * rx + ix * ix;
}
#else
INLINE_PREFIX real _h2_abssqr(field x) {
  return x * x;
}
#endif

#ifdef USE_COMPLEX
INLINE_PREFIX field _h2_sgn1(field x) {
  real norm, rx, ix;

  if (ABSSQR(x) <= H2_ALMOST_ZERO) {
    return 1.0;
  } else {
    rx = REAL(x);
    ix = IMAG(x);
    norm = REAL_RSQRT(rx * rx + ix * ix);
    return rx * norm + ix * norm * I;
  }
}
#else
INLINE_PREFIX field _h2_sgn1(field x) {
  return (x < f_zero ? f_minusone : f_one);
}
#endif

INLINE_PREFIX field _h2_fieldrand() {
  field x;

  x = _h2_realrand();
#ifdef USE_COMPLEX
  x += f_i * _h2_realrand();
#endif

  return x;
}

INLINE_PREFIX real _h2_real_sqr(real x) {
  return x * x;
}

INLINE_PREFIX real _h2_realmax(real x, real y) {
  return (x < y ? y : x);
}

INLINE_PREFIX real _h2_realmax3(real x, real y, real z) {
  return (x < y ? (y < z ? z : y) : (x < z ? z : x));
}

INLINE_PREFIX real _h2_realmin(real a, real b) {
  return (a < b ? a : b);
}

INLINE_PREFIX real _h2_realmin3(real x, real y, real z) {
  return (x < y ? (z < x ? z : x) : (z < y ? z : y));
}

INLINE_PREFIX real _h2_realrand() {
  return 2.0 * rand() / RAND_MAX - 1.0;
}

INLINE_PREFIX uint _h2_uintmax(uint x, uint y) {
  return (x < y ? y : x);
}

INLINE_PREFIX uint _h2_uintmax3(uint x, uint y, uint z) {
  return (x < y ? (y < z ? z : y) : (x < z ? z : x));
}

INLINE_PREFIX uint _h2_uintmin(uint x, uint y) {
  return (x < y ? x : y);
}

INLINE_PREFIX uint _h2_uintmin3(uint x, uint y, uint z) {
  return (x < y ? (z < x ? z : x) : (z < y ? z : y));
}

/* ------------------------------------------------------------
 * Memory management
 * ------------------------------------------------------------ */

#define allocmem(sz) _h2_allocmem(sz,__FILE__,__LINE__)

void *
_h2_allocmem(size_t sz, const char *filename, int line);

#define allocuint(sz) _h2_allocuint(sz,__FILE__,__LINE__)

uint *
_h2_allocuint(size_t sz, const char *filename, int line);

#define allocreal(sz) _h2_allocreal(sz,__FILE__,__LINE__)

real *
_h2_allocreal(size_t sz, const char *filename, int line);

#define allocfield(sz) _h2_allocfield(sz,__FILE__,__LINE__)

field *
_h2_allocfield(size_t sz, const char *filename, int line);

#define allocmatrix(rows,cols) _h2_allocmatrix(rows,cols,__FILE__,__LINE__)

field *
_h2_allocmatrix(size_t rows, size_t cols, const char *filename, int line);

void
freemem(void *ptr);

/* ------------------------------------------------------------
 * Sorting
 * ------------------------------------------------------------ */

#define heapsort(n,leq,swap,data) _h2_heapsort(n,leq,swap,data)

HEADER_PREFIX void
_h2_heapsort(uint n, bool leq(uint, uint, void *),
    void swap(uint, uint, void *), void *data);

/* ------------------------------------------------------------
 * Timing
 * ------------------------------------------------------------ */

HEADER_PREFIX pstopwatch
new_stopwatch();

HEADER_PREFIX void
del_stopwatch(pstopwatch sw);

HEADER_PREFIX void
start_stopwatch(pstopwatch sw);

HEADER_PREFIX real
stop_stopwatch(pstopwatch sw);

/* ------------------------------------------------------------
 *  Drawing
 * ------------------------------------------------------------ */

#ifdef USE_CAIRO

HEADER_PREFIX cairo_t *
new_cairopdf(const char *filename, double width, double height);

HEADER_PREFIX cairo_t *
new_cairopng(uint width, uint height);

HEADER_PREFIX bool
write_cairopng(cairo_t *cr, const char *filename);
#endif

#endif