vrsa_powf: Array single precision power function

• C Prototype:
  • void vrsa_powf(int n, float *x, float *y, float *z);
  • Inputs:
    • float *x - pointer to the array of single precision input x values.
      float *y - pointer to the array of single precision input y values. float *z - pointer to the array of single precision output values. int n - the number of single precision values in both the input and output arrays.
  • Outputs:
    • x raised to the y value for each array pair, filled into the z array.
• Fortran Subroutine Interface:
  • VRSA_POWF(INTEGER*4 N, REAL*4 X(), REAL*4 Y(), REAL*4 Z())
  • Inputs:
    • INTEGER N - the number of values in both the input and output arrays.
    • REAL X(N) - array of real x input values.
    • REAL Y(N) - array of real y input values.
  • Outputs:
    • REAL Z(N) - array of real result values.
• Notes:
  • vrsa_powf() computes x to the y power in single precision for each pair of elements in the x and y input arrays.
    This routine accepts an array of single precision input x values and an arrayi of single precision input y values, computes x^y for each input value pair, and stores the result in the array pointed to by the z input.
    This is a relaxed version of powf, suitable for use with fastmath compiler flags or applications not requiring full error handling. Denormal inputs may produce unpredictable results. Special case inputs produce C99 return values. The routine is accurate to better than 0.5 ulp over the valid input range.
• Special case return values:

  • Input x	Input y	Output
    +/- 0	y<0, odd integer	+/- infinity
    +/- 0	y<0, not odd integer	+infinity
    +/- 0	y>0, odd integer	+/- 0
    +/- 0	y>0, not odd integer	+0
    -1	+infinity	1
    +1	y (incl. NaN)	1
    x (incl. Nan)	+/- 0	1
    x<0	y, not integer	QNaN
    |x|<1	-infinity	+infinity
    |x|>1	-infinity	+0
    |x|<1	+infinity	+0
    |x|>1	+infinity	+infinity
    -infinity	y<0, odd integer	-0
    -infinity	y<0, not odd integer	+0
    -infinity	y>0, odd integer	-infinity
    -infinity	y>0, not odd integer	+infinity
    +infinity	y<0,	+0
    +infinity	y>0,	+infinity
    NaN	y nonzero,	NaN
    x<>1	NaN,	NaN

• Performance:
  • 107 cycles per value for valid inputs, n = 24.