src/limn/qn.c File Reference

#include "limn.h"

Include dependency graph for qn.c:


Defines

#define _EVEN_CHECK_QtoV(HNB, TT, vec, qn)
#define _EVEN_CHECK_VtoQ(HNB, vec)
#define _EVEN_OCTA_QtoV(HNB, TT, vec, qn)
#define _EVEN_OCTA_VtoQ(HNB, vec)
#define _16_CHECK_QtoV(vec, qn)
#define _16_CHECK_VtoQ(vec)
#define _ODD_OCTA_QtoV(HNB, TT, vec, qn)
#define _ODD_OCTA_VtoQ(HNB, vec)

Functions

void _limnQN16simple_QNtoV_f (float *vec, int qn)
int _limnQN16simple_VtoQN_f (float *vec)
void _limnQN16border1_QNtoV_f (float *vec, int qn)
int _limnQN16border1_VtoQN_f (float *vec)
void _limnQN16checker_QNtoV_f (float *vec, int qn)
void _limnQN16checker_QNtoV_d (double *vec, int qn)
int _limnQN16checker_VtoQN_f (float *vec)
int _limnQN16checker_VtoQN_d (double *vec)
void _limnQN16octa_QNtoV_f (float *vec, int qn)
void _limnQN16octa_QNtoV_d (double *vec, int qn)
int _limnQN16octa_VtoQN_f (float *vec)
int _limnQN16octa_VtoQN_d (double *vec)
void _limnQN15octa_QNtoV_f (float *vec, int qn)
void _limnQN15octa_QNtoV_d (double *vec, int qn)
int _limnQN15octa_VtoQN_f (float *vec)
int _limnQN15octa_VtoQN_d (double *vec)
void _limnQN14checker_QNtoV_f (float *vec, int qn)
void _limnQN14checker_QNtoV_d (double *vec, int qn)
int _limnQN14checker_VtoQN_f (float *vec)
int _limnQN14checker_VtoQN_d (double *vec)
void _limnQN14octa_QNtoV_f (float *vec, int qn)
void _limnQN14octa_QNtoV_d (double *vec, int qn)
int _limnQN14octa_VtoQN_f (float *vec)
int _limnQN14octa_VtoQN_d (double *vec)
void _limnQN13octa_QNtoV_f (float *vec, int qn)
void _limnQN13octa_QNtoV_d (double *vec, int qn)
int _limnQN13octa_VtoQN_f (float *vec)
int _limnQN13octa_VtoQN_d (double *vec)
void _limnQN12checker_QNtoV_f (float *vec, int qn)
void _limnQN12checker_QNtoV_d (double *vec, int qn)
int _limnQN12checker_VtoQN_f (float *vec)
int _limnQN12checker_VtoQN_d (double *vec)
void _limnQN12octa_QNtoV_f (float *vec, int qn)
void _limnQN12octa_QNtoV_d (double *vec, int qn)
int _limnQN12octa_VtoQN_f (float *vec)
int _limnQN12octa_VtoQN_d (double *vec)
void _limnQN11octa_QNtoV_f (float *vec, int qn)
void _limnQN11octa_QNtoV_d (double *vec, int qn)
int _limnQN11octa_VtoQN_f (float *vec)
int _limnQN11octa_VtoQN_d (double *vec)
void _limnQN10checker_QNtoV_f (float *vec, int qn)
void _limnQN10checker_QNtoV_d (double *vec, int qn)
int _limnQN10checker_VtoQN_f (float *vec)
int _limnQN10checker_VtoQN_d (double *vec)
void _limnQN10octa_QNtoV_f (float *vec, int qn)
void _limnQN10octa_QNtoV_d (double *vec, int qn)
int _limnQN10octa_VtoQN_f (float *vec)
int _limnQN10octa_VtoQN_d (double *vec)
void _limnQN9octa_QNtoV_f (float *vec, int qn)
void _limnQN9octa_QNtoV_d (double *vec, int qn)
int _limnQN9octa_VtoQN_f (float *vec)
int _limnQN9octa_VtoQN_d (double *vec)
void _limnQN8checker_QNtoV_f (float *vec, int qn)
void _limnQN8checker_QNtoV_d (double *vec, int qn)
int _limnQN8checker_VtoQN_f (float *vec)
int _limnQN8checker_VtoQN_d (double *vec)
void _limnQN8octa_QNtoV_f (float *vec, int qn)
void _limnQN8octa_QNtoV_d (double *vec, int qn)
int _limnQN8octa_VtoQN_f (float *vec)
int _limnQN8octa_VtoQN_d (double *vec)

Variables

void(* limnQNtoV_f [LIMN_QN_MAX+1])(float *, int)
void(* limnQNtoV_d [LIMN_QN_MAX+1])(double *, int)
int(* limnVtoQN_f [LIMN_QN_MAX+1])(float *vec)
int(* limnVtoQN_d [LIMN_QN_MAX+1])(double *vec)
int limnQNBins [LIMN_QN_MAX+1]

Define Documentation

#define _16_CHECK_QtoV ( vec,
qn   ) 

Value:

ui = (qn) & 0xFF; \
  vi = ((qn) >> 8) & 0xFF; \
  u = AIR_AFFINE(0, ui, 255, -0.5, 0.5); \
  v = AIR_AFFINE(0, vi, 255, -0.5, 0.5); \
  x =  u + v; \
  y =  u - v; \
  z = 1 - AIR_ABS(x) - AIR_ABS(y); \
  /* would this be better served by a branch? */ \
  z *= (((ui ^ vi) & 0x01) << 1) - 1; \
  n = 1.0/sqrt(x*x + y*y + z*z); \
  (vec)[0] = x*n; \
  (vec)[1] = y*n; \
  (vec)[2] = z*n

#define _16_CHECK_VtoQ ( vec   ) 

Value:

x = (vec)[0]; \
  y = (vec)[1]; \
  z = (vec)[2]; \
  L = AIR_ABS(x) + AIR_ABS(y) + AIR_ABS(z); \
  if (!L) { \
    return 0; \
  } \
  x /= L; \
  y /= L; \
  if (z > 0) { \
    xi = airIndex(-1.0, x, 1.0, 255); \
    yi = airIndex(-1.0 - 1.0/255, y, 1.0 + 1.0/255, 256); \
    ui = xi + yi - 127; \
    vi = xi - yi + 128; \
  } \
  else { \
    xi = airIndex(-1.0 - 1.0/255, x, 1.0 + 1.0/255, 256); \
    yi = airIndex(-1, y, 1, 255); \
    ui = xi + yi - 127; \
    vi = xi - yi + 127; \
  }

#define _EVEN_CHECK_QtoV ( HNB,
TT,
vec,
qn   ) 

Value:

ui = (qn) & ((1<<HNB)-1); \
  vi = ((qn) >> HNB) & ((1<<HNB)-1); \
  u = AIR_AFFINE(0, ui, ((1<<HNB)-1), -0.5, 0.5); \
  v = AIR_AFFINE(0, vi, ((1<<HNB)-1), -0.5, 0.5); \
  x =  u + v; \
  y =  u - v; \
  z = 1 - AIR_ABS(x) - AIR_ABS(y); \
  /* would this be better served by a branch? */ \
  z *= (((ui ^ vi) & 0x01) << 1) - 1; \
  n = 1.0/sqrt(x*x + y*y + z*z); \
  (vec)[0] = AIR_CAST(TT, x*n); \
  (vec)[1] = AIR_CAST(TT, y*n); \
  (vec)[2] = AIR_CAST(TT, z*n)

#define _EVEN_CHECK_VtoQ ( HNB,
vec   ) 

Value:

x = (vec)[0]; \
  y = (vec)[1]; \
  z = (vec)[2]; \
  L = AIR_ABS(x) + AIR_ABS(y) + AIR_ABS(z); \
  if (!L) { \
    return 0; \
  } \
  x /= L; \
  y /= L; \
  if (z > 0) { \
    xi = airIndex(-1.0, x, 1.0, ((1<<HNB)-1)); \
    yi = airIndex(-1.0 - 1.0/((1<<HNB)-1), y, 1.0 + 1.0/((1<<HNB)-1), \
                  (1<<HNB)); \
    ui = xi + yi - ((1<<(HNB-1))-1); \
    vi = xi - yi + (1<<(HNB-1)); \
  } \
  else { \
    xi = airIndex(-1.0 - 1.0/((1<<HNB)-1), x, 1.0 + 1.0/((1<<HNB)-1), \
                  (1<<HNB)); \
    yi = airIndex(-1, y, 1, ((1<<HNB)-1)); \
    ui = xi + yi - ((1<<(HNB-1))-1); \
    vi = xi - yi + ((1<<(HNB-1))-1); \
  } \
  return (vi << HNB) | ui

#define _EVEN_OCTA_QtoV ( HNB,
TT,
vec,
qn   ) 

Value:

xi = (qn) & ((1<<HNB)-1); \
  yi = ((qn) >> HNB) & ((1<<HNB)-1); \
  x = AIR_AFFINE(-0.5, xi, ((1<<HNB)-1)+0.5, -1, 1); \
  y = AIR_AFFINE(-0.5, yi, ((1<<HNB)-1)+0.5, -1, 1); \
  z = 1 - AIR_ABS(x) - AIR_ABS(y); \
  if (z < 0) { \
    if (x > 0) { \
      x += z; \
    } else { \
      x -= z; \
    } \
    if (y > 0) { \
      y += z; \
    } else { \
      y -= z; \
    } \
  } \
  n = 1.0/sqrt(x*x + y*y + z*z); \
  (vec)[0] = AIR_CAST(TT, x*n); \
  (vec)[1] = AIR_CAST(TT, y*n); \
  (vec)[2] = AIR_CAST(TT, z*n)

#define _EVEN_OCTA_VtoQ ( HNB,
vec   ) 

Value:

x = (vec)[0]; \
  y = (vec)[1]; \
  z = (vec)[2]; \
  L = AIR_ABS(x) + AIR_ABS(y) + AIR_ABS(z); \
  if (!L) { \
    return 0; \
  } \
  x /= L; \
  y /= L; \
  z /= L; \
  if (z < 0) { \
    if (x > 0) { \
      x -= z; \
    } else { \
      x += z; \
    } \
    if (y > 0) { \
      y -= z; \
    } else { \
      y += z; \
    } \
  } \
  xi = airIndex(-1, x, 1, (1<<HNB)); \
  yi = airIndex(-1, y, 1, (1<<HNB)); \
  return (yi << HNB) | xi

#define _ODD_OCTA_QtoV ( HNB,
TT,
vec,
qn   ) 

Value:

ui = qn & ((1<<HNB)-1); \
  vi = (qn >> HNB) & ((1<<HNB)-1); \
  zi = (qn >> (2*HNB)) & 0x01; \
  u = AIR_CAST(TT, AIR_AFFINE(-0.5, ui, ((1<<HNB)-1)+0.5, -0.5, 0.5)); \
  v = AIR_CAST(TT, AIR_AFFINE(-0.5, vi, ((1<<HNB)-1)+0.5, -0.5, 0.5)); \
  x =  u + v; \
  y =  u - v; \
  z = 1 - AIR_ABS(x) - AIR_ABS(y); \
  z *= (zi << 1) - 1; \
  n = AIR_CAST(TT, 1.0/sqrt(x*x + y*y + z*z)); \
  vec[0] = AIR_CAST(TT, x*n); \
  vec[1] = AIR_CAST(TT, y*n); \
  vec[2] = AIR_CAST(TT, z*n)

#define _ODD_OCTA_VtoQ ( HNB,
vec   ) 

Value:

x = vec[0]; \
  y = vec[1]; \
  z = vec[2]; \
  L = AIR_ABS(x) + AIR_ABS(y) + AIR_ABS(z); \
  if (!L) { \
    return 0; \
  } \
  x /= L; \
  y /= L; \
  u = x + y; \
  v = x - y; \
  ui = airIndex(-1, u, 1, (1<<HNB)); \
  vi = airIndex(-1, v, 1, (1<<HNB)); \
  zi = (z > 0); \
  return (zi << (2*HNB)) | (vi << HNB) | ui


Function Documentation

void _limnQN10checker_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN10checker_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN10checker_VtoQN_d ( double *  vec  ) 

int _limnQN10checker_VtoQN_f ( float *  vec  ) 

void _limnQN10octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN10octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN10octa_VtoQN_d ( double *  vec  ) 

int _limnQN10octa_VtoQN_f ( float *  vec  ) 

void _limnQN11octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN11octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN11octa_VtoQN_d ( double *  vec  ) 

int _limnQN11octa_VtoQN_f ( float *  vec  ) 

void _limnQN12checker_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN12checker_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN12checker_VtoQN_d ( double *  vec  ) 

int _limnQN12checker_VtoQN_f ( float *  vec  ) 

void _limnQN12octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN12octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN12octa_VtoQN_d ( double *  vec  ) 

int _limnQN12octa_VtoQN_f ( float *  vec  ) 

void _limnQN13octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN13octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN13octa_VtoQN_d ( double *  vec  ) 

int _limnQN13octa_VtoQN_f ( float *  vec  ) 

void _limnQN14checker_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN14checker_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN14checker_VtoQN_d ( double *  vec  ) 

int _limnQN14checker_VtoQN_f ( float *  vec  ) 

void _limnQN14octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN14octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN14octa_VtoQN_d ( double *  vec  ) 

int _limnQN14octa_VtoQN_f ( float *  vec  ) 

void _limnQN15octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN15octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN15octa_VtoQN_d ( double *  vec  ) 

int _limnQN15octa_VtoQN_f ( float *  vec  ) 

void _limnQN16border1_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN16border1_VtoQN_f ( float *  vec  ) 

void _limnQN16checker_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN16checker_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN16checker_VtoQN_d ( double *  vec  ) 

int _limnQN16checker_VtoQN_f ( float *  vec  ) 

void _limnQN16octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN16octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN16octa_VtoQN_d ( double *  vec  ) 

int _limnQN16octa_VtoQN_f ( float *  vec  ) 

void _limnQN16simple_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN16simple_VtoQN_f ( float *  vec  ) 

void _limnQN8checker_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN8checker_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN8checker_VtoQN_d ( double *  vec  ) 

int _limnQN8checker_VtoQN_f ( float *  vec  ) 

void _limnQN8octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN8octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN8octa_VtoQN_d ( double *  vec  ) 

int _limnQN8octa_VtoQN_f ( float *  vec  ) 

void _limnQN9octa_QNtoV_d ( double *  vec,
int  qn 
)

void _limnQN9octa_QNtoV_f ( float *  vec,
int  qn 
)

int _limnQN9octa_VtoQN_d ( double *  vec  ) 

int _limnQN9octa_VtoQN_f ( float *  vec  ) 


Variable Documentation

int limnQNBins[LIMN_QN_MAX+1]

Initial value:

 {
  -1,
  (1 << 16),
  (1 << 16),
  (1 << 16),
  (1 << 16),
  (1 << 15),
  (1 << 14),
  (1 << 14),
  (1 << 13),
  (1 << 12),
  (1 << 12),
  (1 << 11),
  (1 << 10),
  (1 << 10),
  (1 << 9),
  (1 << 8),
  (1 << 8)
}

void(* limnQNtoV_d[LIMN_QN_MAX+1])(double *, int)

void(* limnQNtoV_f[LIMN_QN_MAX+1])(float *, int)

int(* limnVtoQN_d[LIMN_QN_MAX+1])(double *vec)

int(* limnVtoQN_f[LIMN_QN_MAX+1])(float *vec)


Generated on Sat May 9 03:55:24 2009 for Teem by  doxygen 1.5.9