HP OpenVMS Systems Documentation 
HP Fortran for OpenVMS

Previous  Contents  Index 
Description:  Performs a circular shift of the rightmost bits.  
Class:  Elemental function; Generic  
Arguments:  I  Must be of type integer.  
SHIFT  Must be of type integer. The absolute value for SHIFT must be less than or equal to SIZE.  
SIZE (opt)  Must be of type integer. The value of SIZE must be positive and must not exceed BIT_SIZE (I). If SIZE is omitted, it is assumed to have the value of BIT_SIZE (I).  
Results: 
The result type is the same as I. The result value is obtained by
circular shifting the SIZE rightmost bits of I by SHIFT positions. If
SHIFT is positive, the shift is to the left; if SHIFT is negative, the
shift is to the right. If SHIFT is zero, no shift is performed.
No bits are lost. Bits in I beyond the value specified by SIZE are unaffected. The model for the interpretation of an integer value as a sequence of bits is shown in Section D.3. For more information on bit functions, see Section 9.3.3. 
Specific Name  Argument Type  Result Type 

IISHFTC  INTEGER(2)  INTEGER(2) 
JISHFTC  INTEGER(4)  INTEGER(4) 
KISHFTC  INTEGER(8)  INTEGER(8) 
Examples
ISHFTC (4, 2, 4) has the value 1.
ISHFTC (3, 1, 3) has the value 6.
Description:  Logically shifts an integer left or right by the specified bits. Zeros are shifted in from the opposite end.  
Class:  Elemental function; Generic  
Arguments:  I  Must be of type integer. This argument is the value to be shifted.  
SHIFT 
Must be of type integer. This argument is the direction and distance of
shift.
If positive, I is shifted left (toward the most significant bit). If negative, I is shifted right (toward the least significant bit). 

Results: 
The result type is the same as I. The result is equal to I logically
shifted by SHIFT bits. Zeros are shifted in from the opposite end.
Unlike circular or arithmetic shifts, which can shift ones into the number being shifted, logical shifts shift in zeros only, regardless of the direction or size of the shift. The integer kind, however, still determines the end that bits are shifted out of, which can make a difference in the result (see the following example). 
Examples
Consider the following:
INTEGER(1) i, res1 INTEGER(2) j, res2 i = 10 ! equal to 00001010 j = 10 ! equal to 00000000 00001010 res1 = ISHL (i, 5) ! returns 01000000 = 64 res2 = ISHL (j, 5) ! returns 00000001 01000000 = 320 
Description:  Tests whether IEEE real (S_floating and T_floating) numbers are NotaNumber (NaN) values. The compiler option /FLOAT=IEEE_FLOAT must be set.  
Class:  Elemental function; Generic  
Arguments:  X must be of type real.  
Results:  The result is of type default logical. The result is .TRUE. if X is an IEEE NaN; otherwise, the result is .FALSE.. 
Examples
Consider the following:
LOGICAL A DOUBLE PRECISION B ... A = ISNAN(B) 
A is assigned the value .TRUE. if B is an IEEE NaN; otherwise, the value assigned is .FALSE..
Description:  Returns the value of the kind type parameter of the argument. For more information on kind type parameters, see Section 3.2.  
Class:  Inquiry function; Generic  
Arguments:  X can be of any intrinsic type.  
Results:  The result is a scalar of type default integer. The result has a value equal to the kind type parameter value of X. 
Examples
KIND (0.0) has the kind value of default real type.
KIND (12) has the kind value of default integer type.
Description:  Returns the lower bounds for all dimensions of an array, or the lower bound for a specified dimension.  
Class:  Inquiry function; Generic  
Arguments:  ARRAY  Must be an array (of any data type). It must not be an allocatable array that is not allocated, or a disassociated pointer.  
DIM (opt)  Must be a scalar integer with a value in the range 1 to n, where n is the rank of ARRAY.  
KIND (opt)  Must be a scalar integer initialization expression.  
Results: 
The result is of type integer.
If KIND is present, the kind parameter of the result
is that specified by KIND; otherwise, the kind parameter of the result
is that of default integer. If the processor cannot represent the
result value in the kind of the result, the result is undefined.
If DIM is present, the result is a scalar. Otherwise, the result is a rankone array with one element for each dimension of ARRAY. Each element in the result corresponds to a dimension of ARRAY. If ARRAY is an array section or an array expression that is not a whole array or array structure component, each element of the result has the value 1. If ARRAY is a whole array or array structure component, LBOUND (ARRAY, DIM) has a value equal to the lower bound for subscript DIM of ARRAY (if ARRAY(DIM) is nonzero). If ARRAY(DIM) has size zero, the corresponding element of the result has the value 1. The setting of compiler options that specify integer size can affect the result of this function. 
Examples
Consider the following:
REAL ARRAY_A (1:3, 5:8) REAL ARRAY_B (2:8, 3:20) 
LBOUND (ARRAY_A) is (1, 5). LBOUND (ARRAY_A, DIM=2) is 5.
LBOUND (ARRAY_B) is (2, 3). LBOUND (ARRAY_B (5:8, :)) is (1,1) because the arguments are array sections.
Description:  Returns the number of leading zero bits in an integer.  
Class:  Elemental function; Generic  
Arguments:  I must be of type integer.  
Results: 
The result type is the same as I. The result value is the number of
leading zeros in the binary representation of the integer I.
The model for the interpretation of an integer value as a sequence of bits is shown in Section D.3. 
Examples
Consider the following:
INTEGER*8 J, TWO PARAMETER (TWO=2) DO J= 1, 40 TYPE *, LEADZ(TWO**J) ! Prints 64 down to 23 (leading zeros) ENDDO END 
Description:  Returns the length of a character expression.  
Class:  Inquiry function; Generic  
Arguments:  STRING  Must be of type character; it can be scalar or array valued.  
KIND (opt)  Must be a scalar integer initialization expression.  
Results: 
The result is a scalar of type integer.
If KIND is present, the kind parameter of the result
is that specified by KIND; otherwise, the kind parameter of the result
is that of default integer. If the processor cannot represent the
result value in the kind of the result, the result is undefined.
The result has a value equal to the number of characters in STRING (if it is scalar) or in an element of STRING (if it is array valued). The setting of compiler options that specify integer size can affect the result of this function. 
Specific Name  Argument Type  Result Type 

LEN  CHARACTER  INTEGER(4) 
CHARACTER  INTEGER(8) 
Examples
Consider the following example:
CHARACTER (15) C (50) CHARACTER (25) D 
LEN (C) has the value 15, and LEN (D) has the value 25.
Description:  Returns the length of the character argument without counting trailing blank characters.  
Class:  Elemental function; Generic  
Arguments:  STRING  Must be of type character.  
KIND (opt)  Must be a scalar integer initialization expression.  
Results: 
The result is a scalar of type integer.
If KIND is present, the kind parameter of the result
is that specified by KIND; otherwise, the kind parameter of the result
is that of default integer. If the processor cannot represent the
result value in the kind of the result, the result is undefined.
The result has a value equal to the number of characters remaining after any trailing blanks in STRING are removed. If the argument contains only blank characters, the result is zero. 
Examples
LEN_TRIM ( ' CD ' ) has the value 7.
LEN_TRIM ( '  ' ) has the value 0.
Description:  Determines if a string is lexically greater than or equal to another string, based on the ASCII collating sequence, even if the processor's default collating sequence is different. In HP Fortran, LGE is equivalent to the >= operator.  
Class:  Elemental function; Generic  
Arguments:  STRING_A  Must be of type character.  
STRING_B  Must be of type character.  
Results: 
The result is of type default logical. If the strings are of unequal
length, the comparison is made as if the shorter string were extended
on the right with blanks, to the length of the longer string.
The result is true if the strings are equal, both strings are of zero length, or if STRING_A follows STRING_B in the ASCII collating sequence; otherwise, the result is false. 
Specific Name  Argument Type  Result Type 

LGE ^{1}  CHARACTER  LOGICAL(4) 
Examples
LGE ( ' ONE ' , ' SIX ' ) has the value false.
LGE ( ' TWO ' , ' THREE ' ) has the value true.
Description:  Determines whether a string is lexically greater than another string, based on the ASCII collating sequence, even if the processor's default collating sequence is different. In HP Fortran, LGT is equivalent to the > operator.  
Class:  Elemental function; Generic  
Arguments:  STRING_A  Must be of type character.  
STRING_B  Must be of type character.  
Results: 
The result is of type default logical. If the strings are of unequal
length, the comparison is made as if the shorter string were extended
on the right with blanks, to the length of the longer string.
The result is true if STRING_A follows STRING_B in the ASCII collating sequence; otherwise, the result is false. If both strings are of zero length, the result is also false. 
Specific Name  Argument Type  Result Type 

LGT ^{1}  CHARACTER  LOGICAL(4) 
Examples
LGT ( ' TWO ' , ' THREE ' ) has the value true.
LGT ( ' ONE ' , ' FOUR ' ) has the value true.
Description:  Determines whether a string is lexically less than or equal to another string, based on the ASCII collating sequence, even if the processor's default collating sequence is different. In HP Fortran, LLE is equivalent to the <= operator.  
Class:  Elemental function; Generic  
Arguments:  STRING_A  Must be of type character.  
STRING_B  Must be of type character.  
Results: 
The result is of type default logical. If the strings are of unequal
length, the comparison is made as if the shorter string were extended
on the right with blanks, to the length of the longer string.
The result is true if the strings are equal, both strings are of zero length, or if STRING_A precedes STRING_B in the ASCII collating sequence; otherwise, the result is false. 
Specific Name  Argument Type  Result Type 

LLE ^{1}  CHARACTER  LOGICAL(4) 
Examples
LLE ( ' TWO ' , ' THREE ' ) has the value false.
LLE ( ' ONE ' , ' FOUR ' ) has the value false.
Description:  Determines whether a string is lexically less than another string, based on the ASCII collating sequence, even if the processor's default collating sequence is different. In HP Fortran, LLT is equivalent to the < operator.  
Class:  Elemental function; Generic  
Arguments:  STRING_A  Must be of type character.  
STRING_B  Must be of type character.  
Results: 
The result is of type default logical. If the strings are of unequal
length, the comparison is made as if the shorter string were extended
on the right with blanks, to the length of the longer string.
The result is true if STRING_A precedes STRING_B in the ASCII collating sequence; otherwise, the result is false. If both strings are of zero length, the result is also false. 
Specific Name  Argument Type  Result Type 

LLT ^{1}  CHARACTER  LOGICAL(4) 
Examples
LLT ( ' ONE ' , ' SIX ' ) has the value true.
LLT ( ' ONE ' , ' FOUR ' ) has the value false.
Previous  Next  Contents  Index 