SAY /FORMAT

        [SIC\]SAY Arg1 Arg2 [... ArgN] /FORMAT fmt1 fmt2 [...fmtn]

    where fmt1 applies to Arg1, and so on. The format used is a Fortran for-
    mat (so it may be slightly machine-dependent). Use formats like a10, i2,
    f5.2, and so on. For example:
        SIC> say '2*pi' /format F4.2
        6.28
    Be careful that each argument must be separated by blanks (see "Multiple
    arguments" vs "Concatenated arguments" in the main HELP SAY).

    Formatting a scalar variable:
        Note also that the /FORMAT context, SAY is able to format a variable
        without a pre-evaluation by Sic. For example:
            SIC> say pi
            pi
            SIC> say 'pi'
            3.1415926535898
            SIC> say pi /format F4.2
            3.14
            SIC> say 'pi' /format F4.2
            3.14
        1)  In  the  first  case, SAY considers unquoted arguments as simple
           strings to be displayed "as is".
        2) In the second case, using single-quotes, Sic translates the vari-
           able contents to a text representation which is then given to SAY
           (SAY is not aware that a  floating  point  variable  is  involved
           here).
        3)  In the third case, a floating point format is requested: this is
           an indication to SAY that the argument must be a numeric variable
           which has to be converted in a specific way. Here SAY knows it is
           dealing with a variable.
        4) And finally, the last form should be avoided!  The  single-quotes
           are  a request to Sic to translate the variable to a string using
           its best format (same as second case). Then this string is passed
           to  SAY.  As the /FORMAT option is present, SAY re-interprets the
           ASCII string into a floating-point value, and then this value  is
           finally  formatted  to  its final representation. In other words,
           the following sequence occured: read variable  name  ->  get  its
           floating-point  value -> format as ASCII string -> read as float-
           ing-point value -> format as ASCII string. There are two  useless
           steps, even if the result is correct as Sic avoids precision loss
           when representing numeric values.

    Formatting an array variable:
        If the argument is an array variable, the associated format  is  ap-
        plied repeatedly to all its individual values:
            SIC> define real a[4]
            SIC> let a 1.2 3.4 5.6 7.8
            SIC> say a /format f6.2
              1.20  3.40  5.60  7.80
            SIC> say a /format 4(f6.2)  ! Equivalent
              1.20  3.40  5.60  7.80
        Note  however  that  the  format can be used to display array values
        grouped per line, e.g.
            SIC> say a /format 2(f6.2)  ! Group 2 values per line
              1.20  3.40
              5.60  7.80

    Mixture of explicit values, evaluated  expressions,  scalar,  and  array
    variables:
            SIC> define integer n
            SIC> let n 4
            SIC> define integer id[n]
            SIC> let id[i] i
            SIC> say "My interferometer has " n " antennas numbered" -
            SIC-? id " providing " 'n*(n-1)/2' " baselines." -
            SIC-? /format a i0 a i3 a i0 a
            My interferometer has 4 antennas numbered  1  2  3  4 providing 6 ba