PR_ALTI

The PR_ALTI computes ALTI from ALTM.

USAGE:   PR_ALTI (ALTM)

   Input parameters:
      ALTM          REAL          Altimeter in millibars

   Output parameters: 
      PR_ALTI       REAL          Altimeter in inches


PR_ALTM

The PR_ALTM computes ALTM from ALTI.

USAGE:   PR_ALTM (ALTI)

   Input parameters:
       ALTI            REAL            Altimeter in inches

   Output parameters:
       PR_ALTM         REAL            Altimeter in millibars


PR_DDEP

The PR_DDEP function computes DPDX, the dewpoint depression, 
            from TMPX and DWPX, both of which must be in the same
            units (Celsius, Kelvin, or Fahrenheit).

USAGE:    PR_DDEP(TMPX,DWPX)

   Input parameters:
      TMPX            REAL            Air temperature
      DWPX            REAL            Dewpoint temperature

   Output parameters:
      PR_DDEP         REAL            Dewpoint depression


PR_DRCT

The PR_DRCT function computes DRCT from Ux and Vx, both of which
            must be either meters/sec or knots. 

USAGE:   PR_DRCT(UX,VX)

   Input parameters:
      UX              REAL            U component of velocity
      VX              REAL            V component of velocity

   Output parameters:
      PR_DRCT         REAL            Wind direction in degrees


PR_DWDP

The PR_DWDP function computes DWPX from TMPX and DPDX, both of
            which must be in the same units (Celsius, Kelvin,
            or Fahrenheit).  DWPX will be calculated in these units.

USAGE:   PR_DWDP(TMPX,DPDX)

   Input parameters:
      TMPX            REAL            Temperature
      DPDX            REAL            Dewpoint depression

   Output parameters:
      PR_DWDP         REAL            Dewpoint


PR_HGFM

The PR_HGFM function computes HGHT from HGFT.

USAGE:   PR_HGFM  (HGFT)

   Input parameters:
      HGFT            REAL            Height in feet

   Output parameters:
      PR_HGFM         REAL            Height in meters


PR_HGFS

The PR_HGFS function computes HGML, height in miles, from HGFT.

USAGE:   PR_HGFS(HGFT)

   Input parameters:
      HGFT            REAL            Height in feet

   Output parameters:
      PR_HGFS         REAL            Height in statute miles

PR_HGMF

The PR_HGMF function computes HGFT from HGHT.

USAGE:   PR_HGMF(HGHT)

   Input parameters:
      HGHT            REAL            Height in meters

   Output parameters:
      PR_HGMF         REAL            Height in feet

USAGE:   PR_PR_HGSF(HGML)

   Input parameters:
      HGML            REAL            Height in statute miles  

   Output parameters:
      PR_HGSF         REAL            Height in feet


PR_MMIN

The PR_MMIN function converts inches to millimeters.

USAGE:   PR_PR_MMIN  ( XINCH )

   Input parameters:
      XINCH           REAL            Inches

   Output parameters:
      PR_INMM         REAL            Millimeters


PR_KNMS

The PR_KNMS function computes SPED from SKNT.

USAGE:   PR_KNMS(SKNT)

   Input parameters:
      SKNT            REAL            Speed in knots

   Output parameters:
      PR_KNMS         REAL            Speed in meters/second


PR_MMIN

The PR_MMIN function converts millimeters to inches.

USAGE:   PR_MMIN(XMILM) 

   Input parameters:
      XMILM           REAL            Millimeters

   Output parameters:
      PR_MMIN         REAL            Inches


PR_MSKN

The PR_MSKN function computes SKNT from SPED.

USAGE:   PR_MSKN(SPED)

   Input parameters:
      SPED            REAL            Speed in meters/second

   Output parameters:
      PR_MSKN         REAL            Speed in knots


PR_SPED

The PR_SPED function computes SPED from UWND and VWND.

USAGE:   PR_SPED  ( UWND, VWND )

   Input parameters:
      UWND            REAL            U component of velocity
      VWND            REAL            V component of velocity

   Output parameters:
      PR_SPED         REAL            Wind speed


PR_TMCF

The PR_TMCF function computes TMPF from TMPC.

USAGE:   PR_TMCF(TMPC)

   Input parameters:
      TMPC            REAL            Temperature in Celsius

   Output parameters:
      PR_TMCF         REAL            Temperature in Fahrenheit


PR_TMCK

The PR_TMCK function computes TMPK from TMPC.

USAGE:   PR_TMCK(TMPC)

   Input parameters:
      TMPC            REAL            Temperature in Celsius

   Output parameters:
      PR_TMCK         REAL            Temperature in Kelvin


PR_TMFC

The PR_TMFC function computes TMPC from TMPF.

USAGE:   PR_TMFC(TMPF)

   Input parameters:
      TMPF            REAL            Temperature in Fahrenheit

   Output parameters:
      PR_TMFC         REAL            Temperature in Celsius


PR_TMFK

The PR_TMFK function computes TMPK from TMPF.

USAGE:   PR_TMFK(TMPF)

   Input parameters:
      TMPF            REAL            Temperature in Fahrenheit

   Output parameters:
      PR_TMFK         REAL            Temperature in Kelvin


PR_TMKC

The PR_TMKC function computes TMPC from TMPK.

USAGE:   PR_TMKC(TMPK)

   Input parameters:
      TMPK            REAL            Temperature in Kelvin

   Output parameters:
      PR_TMKC         REAL            Temperature in Celsiu


PR_TMKF

The PR_TMKF function computes TMPF from TMPK.

USAGE:   PR_TMKF  ( TMPK )

   Input parameters:
      TMPK            REAL            Temperature in Kelvin

   Output parameters:
      PR_TMKF         REAL            Temperature in Fahrenheit


PR_UWND

The PR_UWND function computes UWND from SPED and DRCT i
            or UKNT from SKNT and DRCT.

USAGE:   PR_UWND  ( SPED, DRCT )

   Input parameters:
      SPED            REAL            Wind speed
      DRCT            REAL            Wind direc

   Output parameters:
      PR_UWND         REAL            U component


PR_VWND

The PR_VWND function computes VWND from SPED and DRCT
            or VKNT from SKNT and DRCT.

USAGE:   PR_VWND(SPED,DRCT)

   Input parameters:
      SPED            REAL            Wind speed
      DRCT            REAL            Wind direction in degrees

   Output parameters:
      PR_VWND         REAL            V component


PR_WIND

The PR_WIND function computes WIND from DRCT and SPED.  WIND 
            is in the form SSSDDD, where SSS is the speed and DDD
            is the direction.  SPED may be entered in meters/sec 
            or knots; DRCT is in degrees.

USAGE:   PR_WIND(DRCT,SPED)

   Input parameters:
      DRCT            REAL            Wind direction in degrees
      SPED            REAL            Wind speed

   Output parameters:
      PR_WIND         REAL            Packed speed and direction


ST_ALNM

The ST_ALNM routine determines whether a character isi
            a letter, number or non-alphanumeric character.

USAGE:   CALL ST_ALNM(CHRSTR,ITYP,IRET)


   Input parameters:
      CHRSTR          CHAR*1          Character to analyze

   Output parameters:
      ITYP            INTEGER         Character type
                                        0 = non-alphanumeric
                                        1 = number
                                        2 = letter
      IRET            INTEGER         Return code
                                        0 = normal return

ST_CLS2

The ST_CLS2 routine breaks a string containing a list of 
            strings into an array of strings.  The separator for the
            strings is input as SEP.  If the separator is a blank,
            multiple blanks will be changed to single blanks before
            the string is processed.  If null strings are encountered
            or fewer than NEXP strings are found in the string, the
            appropriate CARR locations are set to CDEF.        

USAGE:   CALL ST_CLS2 ( STRING, SEP, CDEF, NEXP, CARR, NUM, IRET )

   Input parameters:
      STRING          CHAR*           String
      SEP             CHAR*1          Separator
      CDEF            CHAR*           Default string
      NEXP            INTEGER         Number of expected values

   Output parameters:
      CARR  (NUM)     CHAR*           Array of strings 
      NUM             INTEGER         Number of strings returned
      IRET            INTEGER         Return code
                                        1 = more than NEXP values
                                        0 = normal return


ST_CLST

The ST_CLST routine breaks a string containing a list of
            strings into an array of strings.  The separator for
            the strings is input as SEP.  If the separator is a
            blank, multiple blanks will be changed to single blanks
            before the string is processed.  If null strings are
            encountered or fewer than NEXP strings are found in the
            string, the appropriate CARR locations are set to CDEF. 

USAGE:   CALL ST_CLST ( STRING, SEP, CDEF, NEXP, CARR, NUM, IRET )

   Input parameters:
      STRING          CHAR*           String
      SEP             CHAR*1          Separator
      CDEF            CHAR*           Default string
      NEXP            INTEGER         Number of expected values

   Output parameters:
      CARR  (NUM)     CHAR*           Array of strings
      NUM             INTEGER         Number of strings returned
      IRET            INTEGER         Return code
                                        1 = more than NEXP values
                                        0 = normal return

ST_CRNM

The ST_CRNM routine converts a character string to a real
            number.  If the conversion fails, RMISSD is returned.

USAGE:   CALL ST_CRNM  ( STRING, VALUE, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      VALUE           REAL            Real number
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -2 = conversion error


ST_ETOA

The ST_ETOA routine converts a character string in EBCDIC 
            to a string in ASCII.

USAGE:   ST_ETOA  ( BARRAY, NCHAR, OUTSTR, IRET )

   Input parameters:
      BARRAY (NCHAR)  CHAR*           EBCDIC characters
      NCHAR           INTEGER         Number of characters

   Output parameters:
      OUTSTR          CHAR*           ASCII string
      IRET            INTEGER         Return code
                                        0 = normal return

ST_FIND

The ST_FIND routine searches for a particular string in a 
            list of strings.  The position in the array is returned
            in IPOS.  If the string is not found, IPOS is set to 0.

USAGE:   ST_FIND  ( STRING, STLIST, NSTR, IPOS, IRET )

   Input parameters:
      STRING          CHAR*           String
      STLIST (NSTR)   CHAR*           List of strings
      NSTR            INTEGER         Number of strings in list

   Output parameters:
      IPOS            INTEGER         Position of string in list
                                        0 = not found
      IRET            INTEGER         Return code
                                        0 = normal return


ST_ILSR

The ST_ILSR routine breaks a string containing a list of integers
            into an array of integers.  The separator for the integers 
            is input as SEP.  If the separator is a blank, multiple blanks
            will be changed to single blanks before the string is processed.
            If null strings are encountered or fewer than NEXP strings are
            found in the string, the appropriate IARR locations are set to
            IDEF.  Range strings (with optional increments) are indicated
            with a hyphen (i.e., 3-9 or 3-12-3) and are processed into the
            IARR array.

USAGE:   CALL  ST_ILSR  ( STRING, SEP, IDEF, NEXP, IARR, NUM, IRET )

   Input parameters:
      STRING          CHAR*           String
      SEP             CHAR*1          Separator
      IDEF            INTEGER         Default value
      NEXP            INTEGER         Number of expected values

   Output parameters:
      IARR  (NUM)     INTEGER         Array of integer values
      NUM             INTEGER         Number of values returned
      IRET            INTEGER         Return code
                                        1 = more than NEXP values
                                        0 = normal return
                                       -3 = invalid substring


ST_ILST

The ST_ILST routine breaks a string containing a list of 
            integers into an array of integers.  The separator for 
            the integers is input as SEP.  If the separator is a blank,
            multiple blanks will be changed to single blanks before the
            string is processed.  If null strings are encountered or 
            fewer than NEXP strings are found in the string, the
            appropriate IARR locations are set to IDEF.

USAGE:   CALL ST_ILST  ( STRING, SEP, IDEF, NEXP, IARR, NUM, IRET )

   Input parameters:
      STRING          CHAR*           String
      SEP             CHAR*1          Separator
      IDEF            INTEGER         Default value
      NEXP            INTEGER         Number of expected values

   Output parameters:
      IARR  (NUM)     INTEGER         Array of integer values
      NUM             INTEGER         Number of values returned
      IRET            INTEGER         Return code
                                        1 = more than NEXP values
                                        0 = normal return
                                       -3 = invalid substring


ST_INCH

The ST_INCH routine encodes an integer in a character string.

USAGE:   CALL ST_INCH  ( INTG, STRING, IRET )

   Input parameters:
      INTG            INTEGER         Integer

   Output parameters:
      STRING          CHAR*           Encoded value
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -2 = error on conversion


ST_INLN

The ST_INLN routine converts an integer to a character string.
            Unlike ST_INCH, the length of the string is returned.

USAGE:   CALL ST_INLN  ( INTG, STRING, LENS, IRET )

   Input parameters:
      INTG            INTEGER         Integer

   Output parameters:
      STRING          CHAR*           String
      LENS            INTEGER         Length of string
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -2 = conversion error


ST_INTG

The ST_INTG routine decodes a character string into an integer.
            If the string cannot be decoded, INTG is set to IMISSD.
            Note that only the substring containing the digits to be
            decoded should be sent to this subroutine, rather than
            a string with trailing blanks.

USAGE:   CALL ST_INTG  ( STRING, INTG, IRET )

   Input parameters:
      STRING          CHAR*           Input string

   Output parameters:
      INTG            INTEGER         Decoded integer
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -2 = conversion error


ST_LCUC

The ST_LCUC routine converts lower-case characters in a 
            string to upper case.  The input and output string
            may be the same variable.

USAGE:   CALL ST_LCUC  ( STRING, OUTSTR, IRET )

  Input parameters:
     STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           String in upper case
      IRET            INTEGER         Return code
                                       0 = normal return


ST_LDSP

The ST_LDSP routine deletes the leading spaces and tabs in ai
            string. The input and output strings may be the same variable.

USAGE:   CALL ST_LDSP  ( STRING, OUTSTR, NCOUT, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           Output string
      NCOUT           INTEGER         Number of characters output
      IRET            INTEGER         Return code
                                        0 = normal return


ST_LSTR

The ST_LSTR routine returns the number of characters in a
            string disregarding trailing null characters, tabs and spaces.

USAGE:   CALL ST_LSTR  ( STRING, LENS, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      LENS            INTEGER         Length of string
      IRET            INTEGER         Return code
                                       0 = normal return


ST_NOCC

The ST_NOCC routine finds the Nth occurrence of a character in a string.

USAGE:   CALL ST_NOCC  ( STRING, CHOCC, NOCC, IPOINT, IRET )

   Input parameters:
      STRING          CHAR*           String
      CHOCC           CHAR*           Search character
      NOCC            INTEGER         Occurrence to find

   Output parameters:
      IPOINT          INTEGER         Pointer to Nth occurrence
      IRET            INTEGER         Return code
                                       0 = normal return
                                      -5 = Nth occurrence not found


ST_NUMB

The ST_NUMB routine converts a string into an integer.

USAGE:   CALL ST_NUMB  ( STRING, IVAL, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      IVAL            INTEGER         Integer value
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -2 = conversion error


ST_NXTS

The ST_NXTS routine returns a pointer to the first occurrence
            of any of a list of substrings within a given string.

USAGE:   CALL ST_NXTS (STRING,IFIRST,ILAST,STLIST,ILENS,NSTR,IPOS,
                       ISTRG,IRET)

   Input parameters:
      STRING          CHAR*           Input string
      IFIRST          INTEGER         First position to check
      ILAST           INTEGER         Last position to check
      STLIST (NSTR)   CHAR*           List of substrings
      ILENS  (NSTR)   INTEGER         Lengths of substrings
      NSTR            INTEGER         Number of substrings

   Output parameters:
      IPOS            INTEGER         Position of first substring
      ISTRG           INTEGER         Array element number of string
      IRET            INTEGER         Return code
                                        0 = normal return
                                       -3 = substring not found


ST_RANG

The ST_RANG routine changes a string range into the beginning,
            end, and increment values. The values must be separated by '-'.

USAGE:   CALL ST_RANG  ( STRING, FIRST, LAST, INC, ITYPE, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      FIRST           CHAR*           First value in range
      LAST            CHAR*           Last value in range
      INC             CHAR*           Range increment
      ITYPE           INTEGER         Range type
                                        0 = no range input
                                        1 = range without increment
                                        2 = range with increment
      IRET            INTEGER         Return code
                                        0 = normal return


ST_RLCH

The ST_RLCH routine encodes a real number in a character
            string.  NP contains the number of decimal places to
            be included in the output string.  RLNUM is rounded
            to NP decimal places.

USAGE:   CALL ST_RLCH ( RLNUM, NP, STRING, IRET )

   Input parameters:
      RLNUM           REAL            Real number
      NP              INTEGER         Number of decimal places

   Output parameters:
      STRING          CHAR*           Output string
      IRET            INTEGER         Return code
                                        0 = normal return


ST_RLST

The ST_RLST routine breaks a string containing a list of 
            reals into an array of real values.  The separator for
            the reals is input as SEP.  If the separator is a blank,
            multiple blanks will be changed to single blanks before
            the string is processed.  If null strings are encountered
            or fewer than NEXP strings are found in the string, the
            appropriate RARR locations are set to RDEF.

USAGE:   CALL ST_RLST  ( STRING, SEP, RDEF, NEXP, RARR, NUM, IRET )

   Input parameters:
      STRING          CHAR*           String
      SEP             CHAR*1          Separator
      RDEF            REAL            Default value
      NEXP            INTEGER         Number of expected values

   Output parameters:
      RARR  (NUM)     REAL            Array of real values
      NUM             INTEGER         Number of values returned
      IRET            INTEGER         Return code
                                        1 = too many values
                                        0 = normal return
                                       -3 = invalid substring


ST_RMBL

The ST_RMBL routine removes spaces and tabs from a string.
            The input and output strings may be the same variable.

USAGE:   CALL ST_RMBL  ( STRING, OUTSTR, LENGTH, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           String without blanks
      LENGTH          INTEGER         Length of output string
      IRET            INTEGER         Return code
                                       0 = normal return

ST_RMNM

The ST_RMNM routine removes numeric characters from a string.

USAGE:   CALL ST_RMNM  ( STRING, OUTSTR, NNCR, LENS, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           Converted string
      NNCR            INTEGER         Number of numeric CHARs removed
      LENS            INTEGER         Length of output string
      IRET            INTEGER         Return code
                                       0 = normal return


ST_RMST

The ST_RMST routine finds a substring within a string and
            returns the position of that substring and the output
            string with the substring removed.  If the substring
            is not found, the position, IPOS, is set to zero.

   Input parameters:
      STRING          CHAR*           String
      SUBSTR          CHAR*           Substring

   Output parameters:
      IPOS            INTEGER         Position of substring
      OUTSTR          CHAR*           Output string less substring
      IRET            INTEGER         Return code
                                       0 = normal return


ST_RNAN

The ST_RNAN routine replaces non-alphanumeric characters
            with spaces and removes the extra spaces from a character
            string.  The characters period (.), plus sign (+), minus
            sign (-) and asterisk (*) are not removed.

USAGE:   CALL ST_RNAN  ( STRING, OUTSTR, LENGTH, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           Converted string
      LENGTH          INTEGER         Length of output string
      IRET            INTEGER         Return code
                                       0 = normal return 


ST_RXBL

The ST_RXBL routine removes extra spaces and tabs from a
            string.  Only single blanks will separate substrings.
            The input and output strings may be the same variable.

USAGE:   CALL ST_RXBL  ( STRING, OUTSTR, LENGTH, IRET )

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           String without blanks
      LENGTH          INTEGER         Length of output string
      IRET            INTEGER         Return code
                                       0 = normal return


ST_UCLC

The ST_UCLC routine converts upper-case characters in a
            string to lower case.  The input and output strings
            may be the same variable.

   Input parameters:
      STRING          CHAR*           String

   Output parameters:
      OUTSTR          CHAR*           String in upper case
      IRET            INTEGER         Return code
                                       0 = normal return


ST_UNPR

The ST_UNPR routine eliminates substrings of unprintable 
            characters. Substrings of control characters, i.e.,
            characters less than a blank, are replaced by a singlei
            blank.  Characters greater than '}' (CHAR (126)) are 
            replaced by '~' (CHAR (127)).  This subroutine can be
            used to replace control characters such as CR and LF with
            a single blank.  Invalid characters in the ASCII character
            set are replaced by '~' so that the lengths of fields in 
            the record will remain unchanged.  The input and output
            strings may be the same variable.


USAGE:   CALL ST_UNPR  ( STRING, LENIN, OUTSTR, LENOUT, IRET )

   Input parameters:
      STRING          CHAR*           Input string
      LENIN           INTEGER         Length of input string

   Output parameters:
      OUTSTR          CHAR*           Output string
      LENOUT          INTEGER         Length of output string
      IRET            INTEGER         Return code
                                        0 = normal return


ST_UTAB

The ST_UTAB routine substitutes spaces for tabs in a string.
            Spaces are added for each tab found so that the character
            after the tab appears at the next tab stop.  Tab stops
            are assumed to be at positions 9, 17, 25, ....  The input
            and output strings may be the same variable.

USAGE:   CALL ST_UTAB  ( STRING, NCHAR, OUTSTR, IRET )

   Input parameters:
      STRING          CHAR*           Input string 
      NCHAR           INTEGER         Number of characters

   Output parameters:
      OUTSTR          CHAR*           Output string
      IRET            INTEGER         Return code
                                       0 = normal return

 
GEMLIB.tar Library contains routines utilities for GEMPAK. (Fortran90)
Date posted: 9/05/2012