vec_irec1r16_i() — Apollo Domain/OS SR10.3.5

VEC_$IREC1R16_I                   Domain/OS                    VEC_$IREC1R16_I


NAME
     vec_$irec1r16_i - function returning first-order linear recurrence of
     16-bit integer vector

SYNOPSIS (C)
     #include <apollo/base.h>
     #include <apollo/vec.h>

     short int vec_$irec1r16_i(
          short int *start_vec,
          long int &start_inc,
          short int *vec_2,
          long int &vec2_inc,
          long int &count,
          short int &init_value)

SYNOPSIS (Pascal)
     %include '/sys/ins/base.ins.pas';
     %include '/sys/ins/vec.ins.pas';

     function vec_$irec1r16_i(
          in start_vec: univ vec_$integer16_vector;
          in start_inc: integer32;
          in vec_2: univ vec_$integer16_vector;
          in vec2_inc: integer32;
          in count: integer32;
          in init_value: integer16):integer16;

SYNOPSIS (FORTRAN)
     %include '/sys/ins/base.ins.ftn'
     %include '/sys/ins/vec.ins.ftn'

           parameter (nvec = 10)

           integer*2 start_vec(nvec), vec_2(nvec), init_value, return_value
           integer*4 count
           integer*4 start_inc, vec2_inc

           return_value = vec_$irec1r16_i(start_vec, start_inc,
          & vec_2, vec2_inc, count, init_value)

DESCRIPTION
     Vec_$irec1r16_i calculates a first-order linear recurrence based on
     start_vec, with coefficients taken from vec_2.  Unlike vec_$rec1_i, it
     does not produce an output vector.  Instead, it calculates the value of
     each entry in a temporary output vector, then returns the value of the
     last entry.  It differs from vec_$rec1r_i in that the vectors being han-
     dled contain 16-bit integers.

     This call, like all vec_$ calls ending in _i, takes a set of extra stride
     arguments, one for every vector argument.  The stride arguments determine
     which elements in the array are actually processed.  For instance, if the
     stride for a particular array is set to 3, every third element in the
     array will be processed by the routine.  The stride arguments need not be
     identical.  If all stride arguments are set to 1, this call behaves
     exactly like the version without the _i in its name.

     This routine sets its return value to init_value; it then performs a
     recurrence calculation as follows:

     Initialize the counter variables J and K to the low indices of the arrays
     start_vec and vec_2.  In Fortran, the low index will be 1;  in C, it will
     be 0; in Pascal, it varies depending on the declaration.
     Execute the following equations count times:
     return_value = start_vec(J) + (vec_2(K) x return_value)
     J = J + start_inc
     K = K + vec2_inc

     start_vec
          An input vector.

     start_inc
          The stride for start_vec.

     vec_2
          An input vector.

     vec2_inc
          The stride for vec2_vec.

     count
          The number of elements to be operated on.

     init_value
          The initial value on which the recurrence calculation is based.

NOTES
     When vec_$irec1r16_i is used to operate on matrixes in C and Pascal,
     start_vec and vec_2  are row vectors; in FORTRAN, they are column vec-
     tors.

     Vec_$irec1r16_i, like all 16-bit integer routines, performs poorly when
     compared to the 32-bit integer routines.  Its use should be avoided wher-
     ever possible, especially on high-performance workstations.

SEE ALSO
     vec_$rec1, vec_$rec1c, vec_$rec1n, vec_$rec1r, vec_$rec1cr, vec_$rec1r_i,
     vec_$drec1r, vec_$drec1r_i, vec_$irec1r, vec_$irec1r_i, vec_$irec1r16.
Museum
