Home Manual Packages Global Index Keywords Quick Reference | # functions in std.i - p
pc_primitives |
                 pc_primitives, file

         sets FILE primitive data types to be native to IBM PC.

    interpreted function, defined at i0/std.i   line 2035
pi |
                 pi

         roughly 3.14159265358979323846264338327950288

    keyword,  defined at i0/std.i   line 551
poly |
                 poly(x, a0, a1, a2, ..., aN)

         returns the polynomial  A0 + A1*x + A2*x^2 + ... + AN*X^N
         The data type and dimensions of the result, and conformability rules
         for the inputs are identical to those for the expression.

    builtin function, documented at i0/std.i   line 611
popen |
                 f= popen(command, mode)

         opens a pipe to COMMAND, which is executed as with the system
         function.  If MODE is 0, the returned file handle is open for
         reading, and you are reading the stdout produced by COMMAND.
         If MODE is 1, f is opened for writing and you are writing to
         the stdin read by COMMAND.

    builtin function, documented at i0/std.i   line 1194
SEE ALSO: | open, system
pr1 |
                 pr1(x)

         returns text representing expression X, equivalent to print(X)(1).

    interpreted function, defined at i0/std.i   line 434
SEE ALSO: | print, swrite
print |
                 print, object1, object2, object3, ...
              or print(object1, object2, object3, ...)

         prints an ASCII representation of the OBJECTs, in roughly the format
         they could appear in Yorick source code.  When invoked as a subroutine
         (in the first form), output is to the terminal.  When invoked as a
         function (int the second form), the output is stored as a vector of
         strings, one string per line that would have been output.
         Printing a structure definition prints the structure definition;
         printing a function prints its "func" definition; printing files,
         bookmarks, and other objects generally provides some sort of
         useful description of the object.

    builtin function, documented at i0/std.i   line 419
SEE ALSO: | pr1, print_format, write, exit, error, nameof, typeof
print_format |
                 print_format, line_length, char=, short=, int=, float=,
                               double=, complex=, pointer=

         sets the format string the print function will use for each of
         the basic data types.  Yorick format strings are the same as the
         format strings for the printf function defined in the ANSI C standard.
         The default strings may be restored individually by setting the
         associated format string to ""; all defaults are restored if
         print_format is invoked with no arguments.  The default format strings
         are:  "0x%02x", "%d", "%d", "%ld", "%g", "%g", and "%g%+gi".
         Note that char and short values are converted to int before being
         passed to printf, and that float is converted to double.
         If present, an integer positional argument is taken as the line
         length; <=0 restores the default line length of 80 characters.

    builtin function, documented at i0/std.i   line 441
SEE ALSO: | print, write, nameof, typeof
process_argv |
                 remaining= process_argv()

           -or- remaining= process_argv("your startup message")
         Performs standard command line processing.  This function is
         invoked by the default custom.i file (in $Y_HOME/include); you
         can also invoke it from your personal ~/Yorick/custom.i file.
         The process_argv calls get_argv, removes any arguments of
         the form "-ifilename" or "-i filename" (the latter is a pair of
         arguments.  It returns any arguments not of this form as its
         result, after including any filenames it found in the order
         they appeared on the command line.
         The optional string argument may be an array of strings to print
         a multi-line message.
         A Yorick package may define the function get_command_line in
         order to feed process_argv something other than get_argv.

    interpreted function, defined at i0/std.i   line 1603
SEE ALSO: | batch
ptcen |
                 ptcen(zncen)
              or ptcen(zncen, ireg)

         returns point centered version of the 2-D zone centered array ZNCEN.
         The result is imax-by-jmax if ZNCEN is (imax-1)-by-(jmax-1).
         If the region number array IREG is specified, zones with region
         number 0 are not included in the point centering operation.
         Note that IREG should have dimensions imax-by-jmax; the first
         row and column of IREG are ignored.
         Without IREG, ptcen(zncen) is equivalent to zncen(pcen,pcen).

    interpreted function, defined at i0/std.i   line 2727
SEE ALSO: | zncen, uncen