all functions - w

             where(x)  
 
     returns the vector of longs which is the index list of non-zero  
     values in the array x.  Thus, where([[0,1,3],[2,0,4]]) would  
     return [2,3,4,6].  If noneof(x), where(x) is a special range  
     function which will return a nil value if used to index an array;  
     hence, if noneof(x), then x(where(x)) is nil.  
     If x is a non-zero scalar, then where(x) returns a scalar value.  
     The rather recondite behavior for scalars and noneof(x) provides  
     maximum performance when the merge function to be used with the  
     where function.  
builtin function, documented at i0/std.i   line 802  

             where2(x)  
 
     like where(x), but the returned list is decomposed into indices  
     according to the dimensions of x.  The returned list is always  
     2 dimensional, with the second dimension the same as the dimension  
     of where(x).  The first dimension has length corresponding to the  
     number of dimensions of x.  Thus, where2([[0,1,3],[2,0,4]]) would  
     return [[2,1],[3,1],[1,2],[3,2]].  
     If noneof(x), where2 returns [] (i.e.- nil).  
interpreted function, defined at i0/std.i   line 816  

 widget_setup  
 
  
interpreted function, defined at i/demo3.i   line 58  

             window, n, display="host:server.screen", dpi=100/75, wait=0/1,  
                        private=0/1, hcp="hcp_filename", dump=0/1,  
                        legends=1/0, style="style_sheet_filename",  
                        width=wpixels,height=hpixels,rgb=1  
 
     select window N as the current graphics output window.  N may  
     range from 0 to 7, inclusive.  Each graphics window corresponds to  
     an X window, and optionally has its own associated hardcopy file.  
     If N is omitted, it defaults to the current coordinate system.  
     The X window will appear on your default display at 75 dpi, unless  
     you specify the display and/or dpi keywords.  A dpi=100 X window  
     is larger than a dpi=75 X window; both represent the same thing  
     on paper.  Use display="" to create a graphics window which has  
     no associated X window (you should do this if you want to make  
     plots in a non-interactive batch mode).  
     By default, if the X window needs to be created, the graphics area  
     will be 450x450 pixels if dpi=75, or 600x600 pixels if dpi=100,  
     representing a 6x6 inch square on hardcopy paper.  You can override  
     this default initial size using the width and height keywords.  
     These settings remain in force indefinitely; use width=0,height=0  
     to return to the default dpi-dependent behavior.  For a dpi=75,  
     landscape=0 window, width=638,height=825 displays the entire sheet  
     of hardcopy paper.  Supplying these keywords will not change the  
     size of an existing window; only newly created windows.  
     By default, an X window will attempt to use shared colors, which  
     permits several Yorick graphics windows (including windows from  
     multiple instances of Yorick) to use a common palette.  You can  
     force an X window to post its own colormap (set its colormap  
     attribute) with the private=1 keyword.  You will most likely have  
     to fiddle with your window manager to understand how it handles  
     colormap focus if you do this.  Use private=0 to return to shared  
     colors.  
     By default, Yorick will not wait for the X window to become visible;  
     code which creates a new window, then plots a series of frames to  
     that window should use wait=1 to assure that all frames are actually  
     plotted.  
     By default, a graphics window does NOT have a hardcopy file  
     of its own -- any request for hardcopy are directed to the  
     default hardcopy file, so hardcopy output from any window goes  
     to a single file.  By specifying the hcp keyword, however, a  
     hardcopy file unique to this window will be created.  If the  
     "hcp_filename" ends in ".ps", the hardcopy file will be a PostScript  
     file; otherwise, hardcopy files are in binary CGM format.  Use  
     hcp="" to revert to the default hardcopy file (closing the window  
     specific file, if any).  The legends keyword, if present, controls  
     whether the curve legends are (legends=1, the default) or are not  
     (legends=0) dumped to the hardcopy file.  The dump keyword, if  
     present, controls whether all colors are converted to a gray scale,  
     (dump=0), or the current palette is dumped at the beginning of each  
     page of hardcopy output (dump=1, the default).  (The legends keyword  
     applies to all pictures dumped to hardcopy from this graphics  
     window.  The dump keyword applies only to the specific hardcopy  
     file defined using the hcp keyword -- use the dump keyword in the  
     hcp_file command to get the same effect in the default hardcopy  
     file.)  
     Use rgb=1 to set the rgb color model when you are creating a  
     window on an 8-bit display on which you intend to use three  
     component rgb colors (see color).  This installs the 5x9x5  
     colorcube and avoids having to issue the palette command  
     after the first true color object has been drawn.  
     If both display="" and hcp="", the graphics window will be  
     entirely eliminated.  
     The style keyword, if present, specifies the name of a Gist style  
     sheet file; the default is "work.gs".  The style sheet determines  
     the number and location of coordinate systems, tick and label styles,  
     and the like.  Other choices include "axes.gs", "boxed.gs",  
     "work2.gs", and "boxed2.gs".  
     If invoked as a function, window(...) returns the current  
     window number.  
builtin function, documented at i0/graph.i   line 13  

             window3  
          or window3, n  
 
     initialize style="nobox.gs" window for 3D graphics  
interpreted function, defined at i/pl3d.i   line 723  

             winkill  
          or winkill, n  
 
     deletes the current graphics window, or graphics window N (0-7).  
interpreted function, defined at i0/graph.i   line 96  

             n= write(f, format=fstring, linesize=l, obj1, obj2, ...)  
             n= write(format=fstring, linesize=l, obj1, obj2, ...)  
          or strings= swrite(format=fstring, linesize=l, obj1, obj2, ...)  
 
     writes text to I/O stream F (1st form), or to the terminal (2nd  
     form), or to the STRINGS string array (3rd form), representing  
     arrays OBJ1, OBJ2, ..., according to the optional FSTRING.  The  
     optional linesize L defaults to 80 characters, and helps restrict  
     line lengths when FSTRING is not given, or does not contain  
     newline directives.  The write function always appends to the  
     end of a text file; the position for a sequence of reads is  
     not affected by intervening writes.  
     There must be one conversion specifier (see below) in FSTRING for  
     each OBJ to be written; the type of the conversion specifier must  
     generally match the type of the OBJ.  That is, an integer OBJ  
     requires an integer specifier (d, i, o, u, x, or c) in FSTRING,  
     a real OBJ requires a real specifier (e, f, or g), a string OBJ  
     requires the string specifier (s), and a pointer OBJ requires a  
     the pointer specifier (p).  An OBJ may not be complex, a structure  
     instance, or any non-array Yorick object.  If FSTRING is not  
     supplied, or if it has fewer conversion specifiers than the  
     number of OBJ arguments, then Yorick supplies default specifiers  
     (" %8ld" for integers, " %14.6lg" for reals, " %s" for strings, and  
     " %8p" for pointers).  If FSTRING contains more specifiers than  
     there are OBJ arguments, the part of FSTRING beginning with the  
     first specifier with no OBJ is ignored.  
     The OBJ may be scalar or arrays, but the dimensions of the OBJ  
     must be conformable.  If the OBJ are arrays, Yorick behaves as  
     if he write were called in a loop dimsof(OBJ1, OBJ2, ...) times,  
     writing one array element of each of the OBJ according to FSTRING  
     on each pass through the loop.  The swrite function returns a  
     string array with dimensions dimsof(OBJ1, OBJ2, ...).  The write  
     function inserts a newline between passes through the array if  
     the line produced by the previous pass did not end with a  
     newline, and if the total number of characters output since the  
     previous inserted newline, plus the number of characters about  
     to be written on the current pass, would exceed L characters  
     (L defaults to 80).  The write function returns the total  
     number of characters output.  
     The FSTRING is composed of a series of "directives" which are  
     (1) characters other than % -- copied directly to output  
     (2) conversion specifiers beginning with % and ending with a  
         character specifying the type of conversion -- specify  
         how to convert an OBJ into characters for output  
     The conversion specifier is of the form %FW.PSC, where:  
     F is zero or more optional flags:  
       - left justify in field width  
       + signed conversion will begin with either + or -  
         (space) signed conversion  will begin with either space or -  
       # alternate form (see description of each type below)  
       0 pad field width with leading 0s instead of leading spaces  
     W is either a decimal integer specifying the minimum field width  
       (padded as specified by flags), or not present to use the  
       minimum number of characters required.  
     .P is either a decimal integer specifying the precision of the  
       result, or not present to get the default.  For integers, this  
       is the number of digits to be printed (possibly forcing leading  
       zeroes), and defaults to 1.  For reals, this is the number of  
       digits after the decimal point, and defaults to 6.  For strings,  
       this is the maximum number of characters to print, and defaults  
       to infinity.  
     S is either one of the characters 'h', 'l', or 'L', or not  
       present.  Yorick allows this for compatibility with the C  
       library functions, but ignores it.  
     C is a character specifying the type of conversion:  
       d, i  - decimal integer  
       o     - octal integer (# forces leading 0)  
       u     - unsigned decimal integer (same as d for Yorick)  
       x, X            - hex integer (# forces leading 0x)  
       f     - floating point real in fixed point notation  
               (# forces decimal)  
       e, E  - floating point real in scientific notation  
       g, G  - floating point real in fixed or scientific notation  
               depending on the value converted (# forces decimal)  
       s   - string of ASCII characters  
       c   - integer printed as corresponding ASCII character  
       p   - pointer  
       %   - the ordinary % character; complete conversion  
             specification must be "%%"  
     The write function is modeled on the ANSI standard C library  
     fprintf and sprintf functions, but differs in several respects:  
       (1) Yorick's write cannot handle the %n conversion specifier  
           in FSTRING.  
       (2) Yorick's write may insert additional newlines if the OBJ  
           are arrays, to avoid extremely long output lines.  
builtin function, documented at i0/std.i   line 1504  

            NT  
 
      write_config_file(fileconfig,filein,action,filedis,fileneinei,filenode,fileneihop)  
      write the configuration file for Compute_neiKDtree  
      fileconfig is the config file name to be produced  
      filein is the simulation filename  
      action =1 distance  
             =2 neighbors  
             =3 adaptahop  
      the other parameters are explained in compute_neiKDtree.f90  
       
interpreted function, defined at contrib/YRAdapthop.i   line 74  

 write_flat  
 
  
interpreted function, defined at i/testb.i   line 402  

 write_hist  
 
  
interpreted function, defined at i/testb.i   line 317  

 write_ptrs  
 
  
interpreted function, defined at i/testb.i   line 557  

             write_style, file, landscape, systems, legends, clegends  
 
     write a Gist style sheet (.gs file), using the data structures  
     as described in the get_style function.  The FILE can be a  
     filename or a text file stream.  
interpreted function, defined at i/style.i   line 97  

 wryte  
 
  
interpreted function, defined at contrib/htmldoc.i   line 1231