MASS C/C++ function prototypes for Blue Gene

MASS C/C++ function prototypes for Blue Gene/Q

For information on the MASS C/C++ function prototypes for Blue Gene®/Q, click on the following links:
Using the scalar library
Using the SIMD library
Using the vector library


MASS C/C++ function prototypes for Blue Gene/L and Blue Gene/P

/*************************************************************/
/* C/C++ prototypes for the scalar MASS functions.           */
/* Prototypes not already in math.h are available in mass.h. */
/*************************************************************/

/********************************************************/
/* C/C++ prototypes for the float scalar MASS functions */
/********************************************************/

float acosf (float x);
/* Returns the arccosine of x. */

float acoshf (float x);
 /* Returns the arc hyperbolic cosine of x. */

float asinf (float x);  
 /* Returns the arcsine of x. */

float asinhf (float x);
 /* Returns the arc hyperbolic sine of x. */

float atan2f (float x, float y);
/* Returns the arctangent of x/y. */

float atanf (float x);
/* Returns the arctangent of x. */

float atanhf (float x);
/* Returns the arc hyperbolic tangent of x. */

float cbrtf  (float x);
 /* Returns the cube root of x. */

float copysignf (float x, float y);
 /* Returns a value with the magnitude of x and the sign of y. */

float cosf (float x);
/* Returns the cosine of x. */

float coshf (float x);
/* Returns the hyperbolic cosine of x. */

float erff (float x);
 /* Returns the error function of x. */

float erfcf (float x);
 /* Returns 1.0 - the error function of x. */

float expf (float x);
/* Returns the exponential function of x. */

float expm1f (float x);
/* Returns (the exponential function of x)-1. */

float hypotf (float x, float y);
 /* Returns the square root of x²+ y²   . */

float lgammaf (float x);
 /* Returns the natural logarithm of the absolute value of the gamma function of x. */

float logf (float x);
/* Returns the natural logarithm of x. */

float log10f (float x);
/* Returns the base-10 logarithm of x. */

float log1pf (float x);
/* Returns the natural logarithm of (x-1). */

float powf (float x, float y);
 /* Returns the value of x raised to the power y. */

float anint (float x);
 /* Rounds x to an integer value according to the current rounding mode.  The default rounding mode is to round to the nearest integer. */

float sinf (float x);
 /* Returns the sine of x. */

float sinhf  float x);
/* Returns the hyperbolic sine of x. */

float tanf  (float x);
/* Returns the tangent of x. */

float tanhf (float x);
 /* Returns the hyperbolic tangent of x. */

/*********************************************************/
/* C/C++ prototypes for the double scalar MASS functions */
/*********************************************************/

double acos (double x);
/* Returns the arccosine of x. */

double acosh (double x);
 /* Returns the arc hyperbolic cosine of x. */

double asin (double x);  
 /* Returns the arcsine of x. */

double asinh (double x);
 /* Returns the arc hyperbolic sine of x. */

double atan (double x);
 /* Returns the arctangent of x. */

double atan2 (double x, double y);
 /* Returns the arctangent of x/y. */

double atanh (double x);
/* Returns the arc hyperbolic tangent of x. */

double cbrt (double x);
 /* Returns the cube root of x. */

double copysign (double x, double y);
 /* Returns a value with the magnitude of x and the sign of y. */

double cos (double x);
 /* Returns the cosine of x. */

double _Complex cosisin (double x);
 /* Returns a complex number with real part the sine of x and
    imaginary part the cosine of x. */

double cosh (double x);
 /* Returns the hyperbolic cosine of x. */

double dnint (double x);
 /* Returns the nearest integer to x (as a double). */

double erf (double x);
 /* Returns the error function of x. */

double erfc (double x);
 /* Returns 1.0 - the error function of x. */

double exp (double x);
 /* Returns the exponential function of x. */

double expm1 (double x);
 /* Returns (the exponential function of x)-1. */

double hypot (double x, double y);
 /* Returns the square root of x*x + y*y. */

double lgamma (double x);
 /* Returns the natural logarithm of the absolute value of the gamma function of x. */

double log (double x);
 /* Returns the natural logarithm of x. */

double log10 (double x);
/* Returns the base-10 logarithm of x. */

double log1p (double x);
 /* Returns the natural logarithm of (x+1). */

double pow (double x, double y);
 /* Returns x raised to the power y. */

double rint (double x);
 /* Rounds x to the nearest integer. */

double rsqrt (double x);
 /* Returns the reciprocal of the square root of x. */

double sin (double x);
 /* Returns the sine of x. */

void sincos (double x, double *s, double *c);
 /* Sets *s to the sine of x and *c to the cosine of x. */

double sinh (double x);
 /* Returns the hyperbolic sine of x. */

double sqrt (double x);
 /* Returns the square root of x. */

double tan (double x);
 /* Returns the tangent of x. */

double tanh (double x);
 /* Returns the hyperbolic tangent of x. */


/***************************************************/
/* C/C++ prototypes for the vector MASS functions. */
/* These prototypes are also available in massv.h. */
/***************************************************/

/*********************************************************/
/* C/C++ prototypes for the double vector MASS functions */
/*********************************************************/

void vacos    (double y[], double x[], int *n);
 /* Sets y[i] to the arccosine of x[i], for i=0,..,n-1. */

void vacosh   (double y[], double x[], int *n);
 /* Sets y[i] to the arc hyperbolic cosine of x[i],
    for i=0,..,n-1. */

void vasin    (double y[], double x[], int *n);
 /* Sets y[i] to the arcsine of x[i], for i=0,..,n-1. */

void vasinh   (double y[], double x[], int *n);
 /* Sets y[i] to the arc hyperbolic sine of x[i],
    for i=0,..,n-1. */

void vatan2   (double z[], double x[], double y[], int *n);
 /* Sets z[i] to the arc tangent of x[i]/y[i], for i=0,..,n-1. */

void vatanh   (double y[], double x[], int *n);
 /* Sets y[i] to the arc hyperbolic tangent of x[i],
    for i=0,..,n-1. */

void vcbrt    (double y[], double x[], int *n);
 /* Sets y[i] to the cube root of x[i], for i=0,..,n-1. */

void vcos     (double y[], double x[], int *n);
 /* Sets y[i] to the cosine of x[i], for i=0,..,n-1. */

void vcosh    (double y[], double x[], int *n);
 /* Sets y[i] to the hyperbolic cosine of x[i],
    for i=0,..,n-1. */

void vcosisin (double _Complex y[], double x[], int *n);
 /* Sets the real part of y[i] to the cosine of x[i] and the
    imaginary part of y[i] to the sine of x[i], for i=1,..,n. */

void vdint    (double y[], double x[], int *n);
 /* Sets y[i] to the integer truncation of x[i],
    for i=0,..,n-1. */

void vdiv     (double z[], double x[], double y[], int *n);
 /* Sets z[i] to the x[i]/y[i], for i=0,..,n-1. */

void vdnint   (double y[], double x[], int *n);
 /* Sets y[i] to the nearest integer to x[i], for i=0,..,n-1. */

void vexp     (double y[], double x[], int *n);
 /* Sets y[i] to the exponential function of x[i],
    for i=0,..,n-1. */

void vexpm1   (double y[], double x[], int *n);
 /* Sets y[i] to (the exponential function of x[i])-1,
    for i=0,..,n-1. */

void vlog     (double y[], double x[], int *n);
 /* Sets y[i] to the natural logarithm of x[i],
    for i=0,..,n-1. */

void vlog10   (double y[], double x[], int *n);
 /* Sets y[i] to the base-10 logarithm of x[i],
    for i=0,..,n-1. */

void vlog1p   (double y[], double x[], int *n);
 /* Sets y[i] to the natural logarithm of (x[i]-1),
    for i=0,..,n-1. */

void vpow     (double z[], double x[], double y[], int *n);
 /* Sets z[i] to x[i] raised to the power y[i],
    for i=0,..,n-1. */

void vqdrt    (double y[], double x[], int *n);
 /* Sets y[i] to the quad root of x[i], for i=0,..,n-1. */

void vrcbrt   (double y[], double x[], int *n);
 /* Sets y[i] to the reciprocal of the cube root of x[i],
    for i=0,..,n-1. */

void vrec     (double y[], double x[], int *n);
 /* Sets y[i] to the reciprocal of x[i], for i=0,..,n-1. */

void vrqdrt   (double y[], double x[], int *n);
 /* Sets y[i] to the reciprocal of the quad root of x[i],
    for i=0,..,n-1. */

void vrsqrt   (double y[], double x[], int *n);
 /* Sets y[i] to the reciprocal of the square root of x[i],
    for i=0,..,n-1. */

void vsin     (double y[], double x[], int *n);
 /* Sets y[i] to the sine of x[i], for i=0,..,n-1. */

void vsincos  (double s[], double c[], double x[], int *n);
 /* Sets s[i] to the sine of x[i] and c[i] to the cosine of x[i],
    for i=0,..,n-1. */

void vsinh    (double y[], double x[], int *n);
 /* Sets y[i] to the hyperbolic sine of x[i], for i=0,..,n-1. */

void vsqrt    (double y[], double x[], int *n);
 /* Sets y[i] to the square root of x[i], for i=0,..,n-1. */

void vtan     (double y[], double x[], int *n);
 /* Sets y[i] to the tangent of x[i], for i=0,..,n-1. */

void vtanh    (double y[], double x[], int *n);
 /* Sets y[i] to the hyperbolic tangent of x[i],
    for i=0,..,n-1. */

/**********************************************************/
/* C/C++ prototypes for the float vector MASS functions   */
/**********************************************************/

void vsacos    (float y[], float x[], int *n);
 /* Sets y[i] to the arccosine of x[i], for i=0,..,n-1. */

void vsacosh   (float y[], float x[], int *n);
 /* Sets y[i] to the arc hyperbolic cosine of x[i],
    for i=0,..,n-1. */

void vsasin    (float y[], float x[], int *n);
 /* Sets y[i] to the arcsine of x[i], for i=0,..,n-1. */

void vsasinh   (float y[], float x[], int *n);
 /* Sets y[i] to the arc hyperbolic sine of x[i],
    for i=0,..,n-1. */

void vsatan2   (float z[], float x[], float y[], int *n);
 /* Sets z[i] to the arc tangent of x[i]/y[i], for i=0,..,n-1. */

void vsatanh   (float y[], float x[], int *n);
 /* Sets y[i] to the arc hyperbolic tangent of x[i],
    for i=0,..,n-1. */

void vscbrt    (float y[], float x[], int *n);
 /* Sets y[i] to the cube root of x[i], for i=0,..,n-1. */

void vscos     (float y[], float x[], int *n);
 /* Sets y[i] to the cosine of x[i], for i=0,..,n-1. */

void vscosisin (float _Complex y[], float x[], int *n);
 /* Sets the real part of y[i] to the cosine of x[i] and the
    imaginary part of y[i] to the sine of x[i], for i=1,..,n. */

void vscosh    (float y[], float x[], int *n);
 /* Sets y[i] to the hyperbolic cosine of x[i],
    for i=0,..,n-1. */

void vsdint    (float y[], float x[], int *n);
 /* Sets y[i] to the integer truncation of x[i],
    for i=0,..,n-1. */

void vsdiv     (float z[], float x[], float y[], int *n);
 /* Sets z[i] to the x[i]/y[i], for i=0,..,n-1. */

void vsdnint   (float y[], float x[], int *n);
 /* Sets y[i] to the nearest integer to x[i], for i=0,..,n-1. */

void vsexp     (float y[], float x[], int *n);
 /* Sets y[i] to the exponential function of x[i],
    for i=0,..,n-1. */

void vsexpm1   (float y[], float x[], int *n);
 /* Sets y[i] to (the exponential function of x[i])-1,
    for i=0,..,n-1. */

void vslog     (float y[], float x[], int *n);
 /* Sets y[i] to the natural logarithm of x[i],
    for i=0,..,n-1. */

void vslog10   (float y[], float x[], int *n);
 /* Sets y[i] to the base-10 logarithm of x[i],
    for i=0,..,n-1. */

void vslog1p   (float y[], float x[], int *n);
 /* Sets y[i] to the natural logarithm of (x[i]-1),
    for i=0,..,n-1. */

void vspow     (float z[], float x[], float y[], int *n);
 /* Sets z[i] to x[i] raised to the power y[i],
    for i=0,..,n-1. */

void vsqdrt    (float y[], float x[], int *n);
 /* Sets y[i] to the quad root of x[i], for i=0,..,n-1. */

void vsrcbrt   (float y[], float x[], int *n);
 /* Sets y[i] to the reciprocal of the cube root of x[i],
    for i=0,..,n-1. */

void vsrec     (float y[], float x[], int *n);
 /* Sets y[i] to the reciprocal of x[i], for i=0,..,n-1. */

void vsrqdrt   (float y[], float x[], int *n);
 /* Sets y[i] to the reciprocal of the quad root of x[i],
    for i=0,..,n-1. */

void vsrsqrt   (float y[], float x[], int *n);
 /* Sets y[i] to the reciprocal of the square root of x[i],
    for i=0,..,n-1. */

void vssin     (float y[], float x[], int *n);
 /* Sets y[i] to the sine of x[i], for i=0,..,n-1. */

void vssincos  (float s[], float c[], float x[], int *n);
 /* Sets s[i] to the sine of x[i] and c[i] to the cosine of x[i],
    for i=0,..,n-1. */

void vssinh    (float y[], float x[], int *n);
 /* Sets y[i] to the hyperbolic sine of x[i], for i=0,..,n-1. */

void vssqrt    (float y[], float x[], int *n);
 /* Sets y[i] to the square root of x[i], for i=0,..,n-1. */

void vstan     (float y[], float x[], int *n);
 /* Sets y[i] to the tangent of x[i], for i=0,..,n-1. */

void vstanh    (float y[], float x[], int *n);
 /* Sets y[i] to the hyperbolic tangent of x[i],
    for i=0,..,n-1. */

/************************************************************/
/* C/C++ prototypes for the integer vector MASS functions   */
/************************************************************/

unsigned int vpopcnt4 (void *x, int *n);
 /* Returns the total number of 1 bits in the concatenation of
    the binary representation of x[i], for i=0,...,n-1. x is
    treated as a vector of 4-byte integers. */

unsigned int vpopcnt8 (void *x, int *n);
 /* Returns the total number of 1 bits in the concatenation of
    the binary representation of x[i], for i=0,...,n-1. x is
    treated as a vector of 8-byte integers. */