vrsa_powxf: Array single precision power function, constant y

• C Prototype:
  • void vrsa_powxf(int n, float *x, float y, float *z);
  • Inputs:
    • int n - the number of single precision values in both the x input and output arrays.
    • float *x - pointer to the array of single precision input x values.
      
    • float *z - pointer to the array of single precision output values.
    • float y - the constant single precision input y value.
  • Outputs:
    • x raised to the y value for each x array value, 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 - the constant single precision input y value.
  • Outputs:
    • REAL Z(N) - array of real result values.
• Notes:
  • vrsa_powxf() computes x to the y power in single precision for each element in the x input arrays, using a constant y.
    This routine accepts an array of single precision input x values and one single precision input y value, computes x^y for each x input value, and stores the result in the array pointed to by the z pointer input. It is the responsibility of the calling program to allocate/deallocate enough storage for the output array.
    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:
  • 115 cycles per value for valid inputs, n = 24.