# GREG High-Level Subroutines

These routines essentially format the command line to pass it later to the GR_EXEC subroutine, and are thus the less efficient routines of the GREG library. They are provided essentially for user convenience because the formatting needed to use GR_EXEC might be tedious. Note all GREG commands have the high level equivalent, but all can be used with GR_EXEC.

Each subroutine corresponds to a command, and each entry corresponds to an option of that command. The subroutine and entry names are built from the 4 first characters of the corresponding command and option names. The entries must be called before the subroutine, since it is this one which effectively transmit the command to GR_EXEC.

The conventional type of arguments are

            NAME            Character
            ARG,ARG1,...    Real*8
            IARG,IARG1,...  Integer*4
            NARG            Integer*4

When NARG is present, all arguments need not be passed : trailing arguments may be omitted. NARG is used to give the actual number of arguments passed after NARG itself and it must be set precisely. All arguments before NARG, usually the character string NAME, and the argument NARG must always be present (even if NAME=' '). Note that if ARG1 is missing, ARG2 cannot be present. Note also that the double quotes should not be passed for character strings. For instance, the interactive command LABEL “A little toy” should be replaced by CALL GR_LABE('A little toy').

Example : CALL GR_DRAW ('MARKER', 2, 0.3D0, 0.8D0)

Note that the ARG1 and ARG2 arguments are here expressed as constants, and the D exponent is required as they must be Real*8 values.

The high level routines are not yet fully guaranteed as up to date. In the following description, each high level subroutine is preceeded by the assumed syntax for the equivalent command. If this syntax differs from the current internal help description, using the discrepant parts of the high level routine will cause a fatal error, but common parts of the syntax can be used safely.

For the GTVL language, the following routines are available

    CLEAR [Argument]
            SUBROUTINE GR_CLEA(NAME)

    DEVICE [Type [Descriptor]] [/OUTPUT Logical_Name]
            SUBROUTINE GR_DEVI(NAME)
            All arguments of command DEVICE being character strings, it is
            easy to concatenate them into NAME.

For the GREG1 language, the routines are

    AXIS Name [A1 A2] [/LOCATION X Y] [/TICK Orientation [BIG SMALL]]
            [/LABEL Position] [/[NO]LOG] [/ABSOLUTE]
            SUBROUTINE GR_AXIS(NAME,NARG,ARG1,ARG2)         ! 28-Sep-1986
            ENTRY GR_AXIS_LOCA(NARG,ARG1,ARG2)
            ENTRY GR_AXIS_TICK(NAME,NARG,ARG1,ARG2)
            ENTRY GR_AXIS_LABE(NAME)
            ENTRY GR_AXIS_LOG
            ENTRY GR_AXIS_NOLO
            ENTRY GR_AXIS_ABSO

    BOX [Arguments]
            SUBROUTINE GR_BOX(NAME)                         ! 28-Sep-1986
            ENTRY GR_BOX_ABSO

    COLUMN [X Nx] [Y Ny] [E Ne] [/FILE File] [/LINES Lmin [Lmax]]
            [/TABLE TableName]
            SUBROUTINE GR_COLU(NAME)                        ! 28-Sep-1986
            As this routine is normally of no use in the library version,
            it requires you to code explicitly the remaining part of the
            command line. Hence, it should be equivalent to use
            either GR_EXEC('GREG1\COLUMN '//NAME)
            or GR_EXEC1('COLUMN '//NAME)

    CONNECT [/BLANKING Bval Eval]                           ! 28-Sep-1986
            SUBROUTINE GR_CONN
            ENTRY GR_CONN_BLAN(NARG,ARG1,ARG2)

    DRAW [Action [X Y]] [/USER] [/BOX N] [/CHARACTER N] [/CLIP]
            SUBROUTINE GR_DRAW(NAME,NARG,ARG1,ARG2)
            ENTRY GR_DRAW_CHAR(NARG,IARG)
            ENTRY GR_DRAW_USER
            ENTRY GR_DRAW_BOX(NARG,IARG)
            ENTRY GR_DRAW_CLIP

            Note that no support is given for DRAW TEXT and DRAW FILL_AREA,
            unless you specify in NAME all the arguments and set NARG to 0.
            DRAW TEXT can easily be replaced by GR_DRAW('RELOCATE'...)
            followed by a call to GR_LABE.

    ERRORBAR NAME
            SUBROUTINE GR_ERRO(NAME)                        ! 28-Sep-1986

    HISTOGRAM [/BASE [Ybase]] [/BLANKING Bval Eval]
            SUBROUTINE GR_HIST                              ! 28-Sep-1986
            ENTRY GR_HIST_BASE(ARG)
            ENTRY GR_HIST_BLAN(NARG,ARG1,ARG2)

    LABEL "String" [/X] [/Y] [CENTERING N] [/APPEND]
            SUBROUTINE GR_LABE(NAME)                        ! 28-Sep-1986
            ENTRY GR_LABE_X
            ENTRY GR_LABE_Y
            ENTRY GR_LABE_CENT(IARG)
            ENTRY GR_LABE_APPE

    LIMITS [Xmin Xmax Ymin Ymax] [/XLOG] [/YLOG] [/RGDATA] [/REVERSE [X] [Y]]
            [/BLANKING Bval Eval]
            SUBROUTINE GR_LIMI(NARG,ARG1,ARG2,ARG3,ARG4)    ! 28-Sep-1986
            ENTRY GR_LIMI_XLOG
            ENTRY GR_LIMI_YLOG
            ENTRY GR_LIMI_RGDA
            ENTRY GR_LIMI_REVE(NAME)
            ENTRY GR_LIMI_BLAN(NARG,ARG1,ARG2)
            Arguments of GR_LIMI can be omitted with the standard VAX
            convention to indicate that automatic limit must be computed
            for this one. For example
                    CALL GR_LIMI_XLOG
                    CALL GR_LIMI(4,0.d0, ,-10.d0,10.d0)
            is equivalent to
                    CALL GR_EXEC1('LIMITS 0 * -10 10/XLOG')
            Presently, there is no support for the fifth argument (Angular
            unit or Absolute coordinates) and for the =, < and > possibilities
            of command LIMITS in this High Level routine. To use these
            possibilities, you should use directly GR_EXEC1('LIMITS ...').

    PENCIL [N] [/COLOUR C] [/DASHED D] [/WEIGHT W]
            SUBROUTINE GR_PEN(IPEN,ICOLOUR,COLOUR,IDASH,IWEIGHT,ERROR)

    POINTS [Size] [/BLANKING Bval Eval]
            SUBROUTINE GR_POIN(NARG,ARG1)
            SUBROUTINE GR_POIN_BLAN(NARG,ARG1,ARG2)

    RULE [X] [Y] [/MAJOR [/MINOR]
            SUBROUTINE GR_RULE(NAME)                        ! 28-Sep-1986
            ENTRY GR_RULE_MAJO
            ENTRY GR_RULE_MINO

    SET Something [Value1 [Value2]...]]]
            SUBROUTINE GR_SET(NAME,NARG,ARG1,ARG2,ARG3,ARG4) ! 28-Sep-1986

    SHOW
            SUBROUTINE GR_SHOW(NAME)                        ! 28-Sep-1986

    TICKSPACE SmallX BigX SmallY BigY                       ! 28-Sep-1986
            SUBROUTINE GR_TICK(NARG,ARG1,ARG2,ARG3,ARG4)

The following commands correspond to the GREG2 Language.

    EXTREMA [/BLANKING Bval Eval] [/PLOT]
            SUBROUTINE GR_EXTR                              ! 28-Sep-1986
            ENTRY GR_EXTR_BLAN(NARG,ARG1,ARG2)
            ENTRY GR_EXTR_PLOT

    LEVELS List
            SUBROUTINE GR_LEVE(NAME)
            Coding the list in the required format may be funny.
            Use GR4_LEVELS or GR8_LEVELS instead, they are more convenient.

    RGDATA File_Name [/SUBSET IX1 IY1 IX2 IY2]
            SUBROUTINE GR_RGDA(NAME)                        ! 28-Sep-1986
            ENTRY GR_RGDA_SUBS(NARG,IARG1,IARG2,IARG3,IARG4)

    RGMAP [/ABSOLUTE Value] [/PERCENT Value] [/KEEP] [/BLANKING Bval Eval]
            [/GREY Colour Ntry] [/PENS Pos Neg]
            SUBROUTINE GR_RGMA                              ! 28-Sep-1986
            ENTRY GR_RGMA_ABSO(ARG)
            ENTRY GR_RGMA_PERC(ARG)
            ENTRY GR_RGMA_BLAN(NARG,ARG1,ARG2)
            ENTRY GR_RGMA_KEEP
            ENTRY GR_RGMA_PENS(NARG,IARG1,IARG2)
            No support is yet given for option /GREY because it is still
            rather experimental.

Remember that if anything available in interactive seems to be missing in the previous list, you can always use GR_EXEC to access it.