HP OpenVMS Systems Documentation

The First Order Linear Recurrence --- Multiplication and Addition --- Last Value routine provides a vectorized algorithm for the linear recurrence relation that includes both multiplication and addition operations. Only the last value computed is stored.

Format

MTH$VJFOLRLP_MA_V5 n,a,inca,b,incb,t

MTH$VFFOLRLP_MA_V5 n,a,inca,b,incb,t

MTH$VDFOLRLP_MA_V5 n,a,inca,b,incb,t

MTH$VGFOLRLP_MA_V5 n,a,inca,b,incb,t

MTH$VJFOLRLN_MA_V5 n,a,inca,b,incb,t

MTH$VFFOLRLN_MA_V5 n,a,inca,b,incb,t

MTH$VDFOLRLN_MA_V5 n,a,inca,b,incb,t

MTH$VGFOLRLN_MA_V5 n,a,inca,b,incb,t

To obtain one of the preceding formats, substitute the following for x and y in MTH$VxFOLRLy_MA_V5:

x	=	J for longword integer, F for F-floating, D for D-floating, G for G-floating
y	=	P for a positive recursion element, N for a negative recursion element

RETURNS

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating or G_floating
access:	write only
mechanism:	by value

The function value is the result of the last iteration of the linear recurrence relation. The function value is returned in R0 or R0 and R1.

Arguments

n

OpenVMS usage:	longword_signed
type:	longword integer (signed)
access:	read only
mechanism:	by reference

Length of the linear recurrence. The n argument is the address of a signed longword integer containing the length.

a

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating, or G_floating
access:	read only
mechanism:	by reference, array reference

Array of length at least:

1+(n-1)*inca

where:

n	=	length of the linear recurrence specified in n
inca	=	increment argument for the array a specified in inca

The a argument is the address of a longword integer or floating-point that is this array.

inca

OpenVMS usage:	longword_signed
type:	longword integer (signed)
access:	read only
mechanism:	by reference

Increment argument for the array a. The inca argument is the address of a signed longword integer containing the increment argument. For contiguous elements, specify 1 for inca.

b

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating, or G_floating
access:	read only
mechanism:	by reference, array reference

Array of length at least:

1+(n-1)*incb

where:

n	=	length of the linear recurrence specified in n
incb	=	increment argument for the array b specified in incb

The b argument is the address of a longword integer or floating-point number that is this array.

incb

OpenVMS usage:	longword_signed
type:	longword integer (signed)
access:	read only
mechanism:	by reference

Increment argument for the array b. The incb argument is the address of a signed longword integer containing the increment argument. For contiguous elements, specify 1 for incb.

t

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating, or G_floating
access:	modify
mechanism:	by reference

Variable containing the starting value for the recurrence; overwritten with the value computed by the last iteration of the linear recurrence relation. The t argument is the address of a longword integer or floating-point number that is this value.

Description

MTH$VxFOLRLy_MA_V5 is a group of routines that provide a vectorized algorithm for computing the following linear recurrence relation. (The T on the right side of the equation is the result of the previous iteration of the loop.)

T = +/-T * A(I) + B(I)

Note Save the contents of vector registers V0 through V5 before you call this routine.

Call this routine to utilize vector hardware when computing the recurrence. As an example, the call from Compaq Fortran is as follows:

CALL MTH$VxFOLRy_MA_V5(N,A(K1),INCA,B(K2),INCB,T)

The preceding Fortran call replaces the following loop:

K1 = ... K2 = ... DO I = 1, N T = {+/-}T * A(K1+(I-1)*INCA) + B(K1+(I-1)*INCB) ENDDO

The arrays used in a FOLR expression must be of the same data type in order to be vectorized and user callable. The MTH$ FOLR routines assume that all of the arrays are of the same data type.

This group of routines, MTH$VxFOLRLy_MA_V5 (and also MTH$VxFOLRLy_z_V2) returns only the result of the last iteration of the linear recurrence relation. This is different from the behavior of MTH$VxFOLRy_MA_V15 (and also MTH$VxFOLRy_z_V8), which save the result of each iteration of the linear recurrence relation in an array.

If you specify 0 for the input increment arguments (inca and incb), the input will be treated as a scalar and broadcast to a vector input with all vector elements equal to the scalar value.

Examples

C
C    The following Fortran loop computes
C    a linear recurrence.
C
C    G_FLOAT
     INTEGER N,INCA,INCB,I
     REAL*8 A(30), B(6), T
     N = 6
     INCA = 5
     INCB = 1
     T = 78.9847562
     DO I = 1, N
     T = -T * A(I*INCA) + B(I*INCB)
     ENDDO

C
C    The following call from Fortran to a FOLR
C    routine replaces the preceding loop.
C
C    G_FLOAT
     INTEGER N,INCA,INCB
     DIMENSION A(30), B(6), T
     N = 6
     INCA = 5
     INCB = 1
     T = 78.9847562
     T = MTH$VGFOLRLN_MA_V5(N, A(INCA), INCA, B(INCB), INCB, T)

      

C
C    The following Fortran loop computes
C    a linear recurrence.
C
C    G_FLOAT
     INTEGER N,INCA,INCB,I
     REAL*8 A(30), B(6), T
     N = 6
     INCA = 5
     INCB = 1
     T = 78.9847562
     DO I = 1, N
     T = T * A(I*INCA) + B(I*INCB)
     ENDDO

C
C    The following call from Fortran to a FOLR
C    routine replaces the preceding loop.
C
C    G_FLOAT
     INTEGER N,INCA,INCB
     DIMENSION A(30), B(6), T
     N = 6
     INCA = 5
     INCB = 1
     T = 78.9847562
     T = MTH$VGFOLRLP_MA_V5(N, A(INCA), INCA, B(INCB), INCB, T)

      

The First Order Linear Recurrence --- Multiplication or Addition --- Last Value routine provides a vectorized algorithm for the linear recurrence relation that includes either a multiplication or an addition operation. Only the last value computed is stored.

Format

MTH$VJFOLRLP_M_V2 n,a,inca,t

MTH$VFFOLRLP_M_V2 n,a,inca,t

MTH$VDFOLRLP_M_V2 n,a,inca,t

MTH$VGFOLRLP_M_V2 n,a,inca,t

MTH$VJFOLRLN_M_V2 n,a,inca,t

MTH$VFFOLRLN_M_V2 n,a,inca,t

MTH$VDFOLRLN_M_V2 n,a,inca,t

MTH$VGFOLRLN_M_V2 n,a,inca,t

MTH$VJFOLRLP_A_V2 n,a,inca,t

MTH$VFFOLRLP_A_V2 n,a,inca,t

MTH$VDFOLRLP_A_V2 n,a,inca,t

MTH$VGFOLRLP_A_V2 n,a,inca,t

MTH$VJFOLRLN_A_V2 n,a,inca,t

MTH$VFFOLRLN_A_V2 n,a,inca,t

MTH$VDFOLRLN_A_V2 n,a,inca,t

MTH$VGFOLRLN_A_V2 n,a,inca,t

To obtain one of the preceding formats, substitute the following for x, y, and z in MTH$VxFOLRLy_z_V2:

x	=	J for longword integer, F for F-floating, D for D-floating, G for G-floating
y	=	P for a positive recursion element, N for a negative recursion element
z	=	M for multiplication, A for addition

RETURNS

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating or G_floating
access:	write only
mechanism:	by value

The function value is the result of the last iteration of the linear recurrence relation. The function value is returned in R0 or R0 and R1.

Arguments

n

OpenVMS usage:	longword_signed
type:	longword integer (signed)
access:	read only
mechanism:	by reference

Length of the linear recurrence. The n argument is the address of a signed longword integer containing the length.

a

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating, or G_floating
access:	read only
mechanism:	by reference, array reference

Array of length at least:

n*inca

where:

n	=	length of the linear recurrence specified in n
inca	=	increment argument for the array a specified in inca

The a argument is the address of a longword integer or floating-point that is this array.

inca

OpenVMS usage:	longword_signed
type:	longword integer (signed)
access:	read only
mechanism:	by reference

Increment argument for the array a. The inca argument is the address of a signed longword integer containing the increment argument. For contiguous elements, specify 1 for inca.

t

OpenVMS usage:	longword_signed or floating_point
type:	longword integer (signed), F_floating, D_floating, or G_floating
access:	modify
mechanism:	by reference

Variable containing the starting value for the recurrence; overwritten with the value computed by the last iteration of the linear recurrence relation. The t argument is the address of a longword integer or floating-point number that is this value.

Description

MTH$VxFOLRLy_z_V2 is a group of routines that provide a vectorized algorithm for computing one of the following linear recurrence relations. (The T on the right side of the following equations is the result of the previous iteration of the loop.)

T = +/-T * A(I)

or

T = +/-T + A(I)

For the first relation, specify M for z in the routine name to denote multiplication; for the second relation, specify A for z in the routine name to denote addition.

Note Save the contents of vector registers V0, V1, and V2 before you call this routine.

Call this routine to utilize vector hardware when computing the recurrence. As an example, the call from Compaq Fortran is as follows:

CALL MTH$VxFOLRLy_z_V2(N,A(K1),INCA,T)

The preceding Fortran call replaces the following loop:

K1 = .... DO I = 1, N T = {+/-}T {+/*} A(K1+(I-1)*INCA) ENDDO

The arrays used in a FOLR expression must be of the same data type in order to be vectorized and user callable. The MTH$ FOLR routines assume that all of the arrays are of the same data type.

This group of routines, MTH$VxFOLRLy_z_V2 (and also MTH$VxFOLRLy_MA_V5) return only the result of the last iteration of the linear recurrence relation. This is different from the behavior of MTH$VxFOLRy_MA_V15 (and also MTH$VxFOLRy_z_V8), which save the result of each iteration of the linear recurrence relation in an array.

If you specify 0 for the input increment argument (inca), the input will be treated as a scalar and broadcast to a vector input with all vector elements equal to the scalar value.

Examples

C
C    The following Fortran loop computes
C    a linear recurrence.
C
C    D_FLOAT
     INTEGER I,N
     REAL*8 A(200), T
     T = 78.9847562
     N = 20
     DO I = 4, N
     T = -T * A(I*10)
     ENDDO

C
C    The following call from Fortran to a FOLR
C    routine replaces the preceding loop.
C
C    D_FLOAT
     INTEGER N
     REAL*8 A(200), T
     T = 78.9847562
     N = 20
     T = MTH$VDFOLRLN_M_V2(N-3, A(40), 10, T)

      

C
C    The following Fortran loop computes
C    a linear recurrence.
C
C    D_FLOAT
     INTEGER I,N
     REAL*8 A(200), T
     T = 78.9847562
     N = 20
     DO I = 4, N
     T = T + A(I*10)
     ENDDO

C
C    The following call from Fortran to a FOLR
C    routine replaces the preceding loop.
C
C    D_FLOAT
     INTEGER N
     REAL*8 A(200), T
     T = 78.9847562
     N = 20
     T = MTH$VDFOLRLP_A_V2(N-3, A(40), 10, T)

      

The following supported MTH$ routines are not included with the routines in the Scalar MTH$ Reference Section because they are rarely used. The majority of these routines serve to satisfy external references when intrinsic functions in Fortran and other languages are passed as parameters. Otherwise, the functions are performed by inline code.

Table A-1 lists all of the entry point and argument information for the MTH$ routines not documented in the Scalar MTH$ Reference Section of this manual.