vec_irec1cr16_i() — Apollo Domain/OS SR10.3.5

VEC_$IREC1CR16_I                  Domain/OS                   VEC_$IREC1CR16_I


NAME
     vec_$irec1cr16_i - function returning first-order linear recurrence of
     16-bit integer vector with constant coefficient

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

     short int vec_$irec1cr16_i(
          short int *start_vec,
          long int &start_inc,
          long int &count,
          short int &mult_constant,
          short int &init_value)

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

     function vec_$irec1cr16_i(
          in start_vec: univ vec_$integer16_vector;
          in start_inc: integer32;
          in count: integer32;
          in mult_constant: integer16;
          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), init_value, mult_constant, return_value
           integer*4 count
           integer*4 start_inc

           return_value = vec_$irec1cr16_i(start_vec, start_inc,
          & count, mult_constant, init_value)

DESCRIPTION
     Vec_$irec1cr16_i calculates a first-order linear recurrence with constant
     coefficient based on start_vec.  Unlike vec_$rec1c_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_$rec1cr_i in that the vectors being handled 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 variable J to the low index of the array
     start_vec.  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) + (mult_constant x return_value)
     J = J + start_inc

     start_vec
          An input vector.

     start_inc
          The stride for start_vec.

     mult_constant
          A scalar multiplier.

     count
          The number of elements to be operated on.

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

NOTES
     When vec_$irec1cr16_i is used to operate on matrixes in C and Pascal,
     start_vec is a row vector; in FORTRAN, it is a column vector.

     vec_$irec1cr16_i may be used to evaluate a polynomial by passing the
     highest-order polynomial coefficient as init_value, the remainder of the
     polynomial coefficients as start_vec, the degree as count, and the value
     for which you want the polynomial evaluated as mult_constant.

     Vec_$irec1cr16_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_$rec1cr, vec_$rec1n, vec_$rec1r,
     vec_$rec1cr_i, vec_$drec1cr, vec_$drec1cr_i, vec_$irec1cr,
     vec_$irec1cr_i, vec_$irec1cr16.
Museum
