HP Fortran for OpenVMS
Language Reference Manual
Previous Contents Index

9.4.76 ISHFTC (I, SHIFT [,SIZE])
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.

9.4.77 ISHL (I, SHIFT)

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

9.4.78 ISNAN (X)

Description: Tests whether IEEE real (S_floating and T_floating) numbers are Not-a-Number (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..

9.4.79 KIND (X)

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.

9.4.80 LBOUND (ARRAY [,DIM] [,KIND])

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 rank-one 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.

9.4.81 LEADZ (I)

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

9.4.82 LEN (STRING [,KIND])

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.

9.4.83 LEN_TRIM (STRING [,KIND])

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 ( ' ---C--D--- ' ) has the value 7.

LEN_TRIM ( ' ----- ' ) has the value 0.

9.4.84 LGE (STRING_A, STRING_B)

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)
1This specific function cannot be passed as an actual argument.

Examples

LGE ( ' ONE ' , ' SIX ' ) has the value false.

LGE ( ' TWO ' , ' THREE ' ) has the value true.

9.4.85 LGT (STRING_A, STRING_B)

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)
1This specific function cannot be passed as an actual argument.

Examples

LGT ( ' TWO ' , ' THREE ' ) has the value true.

LGT ( ' ONE ' , ' FOUR ' ) has the value true.

9.4.86 LLE (STRING_A, STRING_B)

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)
1This specific function cannot be passed as an actual argument.

Examples

LLE ( ' TWO ' , ' THREE ' ) has the value false.

LLE ( ' ONE ' , ' FOUR ' ) has the value false.

9.4.87 LLT (STRING_A, STRING_B)

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)
1This specific function cannot be passed as an actual argument.

Examples

LLT ( ' ONE ' , ' SIX ' ) has the value true.

LLT ( ' ONE ' , ' FOUR ' ) has the value false.

Previous Next Contents Index