all functions - g

               
 
   returns the merge gadget snapshot with  
   a possible rotation  rot=[anglexy,[angleyz],[anglezx]]  
   translation trans=[ , ,]  
   velocity translation vtrans=[ , ,]  
   velocity flip = 1/0 or void  
interpreted function, defined at contrib/gadget.i   line 1003  

                gadget_read(fname)  return a gadget structure  
 
    q= gadget_read("./snapshot_000")  
    for instance  *q.pos holds the  positions;  
    modified to be gadget 1.1 compatible  
interpreted function, defined at contrib/gadget.i   line 296  

            T  
 
        writes a gadget structure into the file  
        er= gadget_write(s,"test.dat");  
interpreted function, defined at contrib/gadget.i   line 425  

              
 
   recenters a given gadget snapshot on a given coordinate  
interpreted function, defined at contrib/gadget.i   line 509  

             gammp(a, x)  
         or gammp(a, x, q, lg)  
 
    return P(a,x) = int[0 to x]{ du * u^(a-1)*exp(-u) } / gamma(a)  
    optionally return Q(a,x) = 1-P(a,x) and ln(gamma(a))  
    
    Note that erf(x)=gammp(0.5,x^2) and erfc(x)=gammq(0.5,x^2)  
    Also P(chi2|nu)=gammp(0.5*nu,0.5*chi2)  
     and Q(chi2|nu)=gammq(0.5*nu,0.5*chi2)  
    are the probabilities that an observed chi-square be less than  
    or greater than (P or Q) chi2 when there are nu degrees of freedom  
    (terms in the chi-square sum).  
    
interpreted function, defined at i/gammp.i   line 14  

             gammq(a, x)  
         or gammq(a, x, p, lg)  
 
    return Q(a,x) = 1 - int[0 to x]{ du * u^(a-1)*exp(-u) } / gamma(a)  
    optionally return P(a,x) = 1-Q(a,x) and ln(gamma(a))  
    
    Note that erf(x)=gammp(0.5,x^2) and erfc(x)=gammq(0.5,x^2)  
    Also P(chi2|nu)=gammp(0.5*nu,0.5*chi2)  
     and Q(chi2|nu)=gammq(0.5*nu,0.5*chi2)  
    are the probabilities that an observed chi-square be less than  
    or greater than (P or Q) chi2 when there are nu degrees of freedom  
    (terms in the chi-square sum).  
    
interpreted function, defined at i/gammp.i   line 50  

             gauss_gate(times)  
 
     gate function used by gaussian_gate.  Refer to the source code  
     to learn how to write your own gate function, making proper use  
     of drat_start and drat_stop options in addition to the input times.  
interpreted function, defined at i0/drat.i   line 795  

             gauss_int(t)  
 
     returns time integral of Gaussian specified in call to gaussian_gate.  
interpreted function, defined at i0/drat.i   line 820  

             gaussian_gate(t0, tsigma, max_trans)  
 
     sets the drat_gate for the snap function to be a Gaussian  
     centered at time T0, with sigma TSIGMA, and maximum transmission  
     fraction MAX_TRANS.  
interpreted function, defined at i0/drat.i   line 839  

             gcd(a,b)  
 
     returns the GCD (greatest common divisor) of A and B, which must  
     be one of the integer data types.  A and B may be conformable  
     arrays; the semantics of the gcd call are the same as any other  
     binary operation.  Uses Euclid's celebrated algorithm.  
     The absolute values of A and B are taken before the operation  
     commences; if either A or B is 0, the return value will be 0.  
interpreted function, defined at i/gcd.i   line 10  

             for a given 6d hypercube of 3 pts corelations  
 
   compute the residual 3 pt cor versus R and theta  
   EXAMPLE   
     //==== this can't work !!! n1 is not defined ????  
interpreted function, defined at contrib/correl.i   line 602  

             for a given 4d hypercube of 3 pts corelations  
 
   compute the residual 3 pt cor versus R and theta  
   EXAMPLE   
       
interpreted function, defined at contrib/correl.i   line 642  

            NT  
 
   generates Ylm tables for latter use  
   (dimensions nn*nn).  
interpreted function, defined at contrib/harmonic.i   line 56  

 generays  
 
  
interpreted function, defined at i/ylmdec.i   line 120  

            UMENT genrandfield(n);  
 
        generates Gaussian Random Field of dims [1,n]  
        which obeys the power spectrum given by fun (default k^-5/3)  
          
        EXAMPLE compute correlation function in 1D  
        include, "Eric/histo.i";  
        nm=512; ns=512;  
        z=genrandfield1D(ns,fun=PS); zr=float(fft(z,-1));  
        z2=float(fft(z*conj(z),-1));  
        zc=array(0.,ns); for(i=1;i<=nm;i++){z=genrandfield1D(ns,fun=PS); z2=z*conj(z);zc+=z2/float(nm);};  
        logxy,1,1;   
        kk=2*pi*(indgen(ns)-1)/float(ns);  
        plg,float(zc),kk; plg, PS(kk),kk,color="blue",width=4;  
        write, " power spectrum slope",(log(float(zc)(5:125))(dif)/log(indgen(ns)(5:125))(dif))(avg)  
interpreted function, defined at contrib/randfield.i   line 193  

            UMENT genrandfield(n);  
 
        generates Gaussian Random Field of dims [2,n,n]  
        which obeys the power spectrum given by fun (default k^-5/3)  
        EXAMPLE  
        include, "Eric/histo.i";   
        ns=128;  
        z=genrandfield2D(ns); zr=float(fft(z,[-1,-1])); //pli,zr;   
        z2=float(fft(z*conj(z),[-1,-1])); // pli,z2;  
        zc=array(0.,ns,ns); for(i=1;i<=50;i++){z=genrandfield2D(ns); z2=z*conj(z);zc+=float(z2)/50.;}; //fft_pli,zc;  
        x1=(indgen(ns)-1)*2*pi/float(ns);   
        y1=(indgen(ns)-1)*2*pi/float(ns);   
        r1= abs(x1, y1(-,));   
        py= histo2(r1, px, weight=zc, average=1, interp=1,binsize=r1(dif)(min));   
        plg, py(2:), px(2:), color="red"; //azimuthal average  
        plg, PS(px(2:)),px(2:),color="blue",width=4; logxy,1,1;  
        write," power spectrum slope",(log(py(5:25))(dif)/log(px(5:25))(dif))(2:12:10)(avg)  
interpreted function, defined at contrib/randfield.i   line 140  

 geocentric  
 
  
interpreted function, defined at i/kepler.i   line 209  

             get3_centroid(xyz, nxyz)  
          or get3_centroid(xyz)  
 
     return 3D centroids for polygons with vertices XYZ.  If NXYZ is  
     specified, XYZ should be 3-by-sum(nxyz), with NXYZ being the  
     list of numbers of vertices for each polygon (as for the plfp  
     function).  If NXYZ is not specified, XYZ should be a quadrilateral  
     mesh, 3-by-ni-by-nj (as for the plf function).  In the first case,  
     the return value is 3-by-numberof(NXYZ); in the second case, the  
     return value is 3-by-(ni-1)-by-(nj-1).  
     The centroids are constructed as the mean value of all vertices  
     of each polygon.  
interpreted function, defined at i/pl3d.i   line 480  

             get3_light(xyz, nxyz)  
          or get3_light(xyz)  
 
     return 3D lighting for polygons with vertices XYZ.  If NXYZ is  
     specified, XYZ should be 3-by-sum(nxyz), with NXYZ being the  
     list of numbers of vertices for each polygon (as for the plfp  
     function).  If NXYZ is not specified, XYZ should be a quadrilateral  
     mesh, 3-by-ni-by-nj (as for the plf function).  In the first case,  
     the return value is numberof(NXYZ); in the second case, the  
     return value is (ni-1)-by-(nj-1).  
     The parameters of the lighting calculation are set by the  
     light3 function.  
interpreted function, defined at i/pl3d.i   line 363  

             get3_normal(xyz, nxyz)  
          or get3_normal(xyz)  
 
     return 3D normals for polygons with vertices XYZ.  If NXYZ is  
     specified, XYZ should be 3-by-sum(nxyz), with NXYZ being the  
     list of numbers of vertices for each polygon (as for the plfp  
     function).  If NXYZ is not specified, XYZ should be a quadrilateral  
     mesh, 3-by-ni-by-nj (as for the plf function).  In the first case,  
     the return value is 3-by-numberof(NXYZ); in the second case, the  
     return value is 3-by-(ni-1)-by-(nj-1).  
     The normals are constructed from the cross product of the lines  
     joining the midpoints of two edges which as nearly quarter the  
     polygon as possible (the medians for a quadrilateral).  No check  
     is made that these not be parallel; the returned "normal" is  
     [0,0,0] in that case.  Also, if the polygon vertices are not  
     coplanar, the "normal" has no precisely definable meaning.  
interpreted function, defined at i/pl3d.i   line 421  

             get3_xy, xyz, x, y  
          or get3_xy, xyz, x, y, z, 1  
 
     Given 3-by-anything coordinates XYZ, return X and Y in viewer's  
     coordinate system (set by rot3, mov3, orient3, etc.).  If the  
     fifth argument is present and non-zero, also return Z (for use  
     in sort3d or get3_light, for example).  If the camera position  
     has been set to a finite distance with setz3, the returned  
     coordinates will be tangents of angles for a perspective  
     drawing (and Z will be scaled by 1/zc).  
interpreted function, defined at i/pl3d.i   line 520  

             addr_lists= get_addrs(file)  
 
     returns the byte addresses of the non-record and record variables  
     in the binary file FILE, and lists of the record addresses, file  
     indices, and filenames for file families with history records.  
          *addr_lists(1)   absolute addresses of non-record variables  
          *addr_lists(2)   relative addresses of record variables  
                           (add record address to get absolute address)  
             The order of these two address lists matches the  
             corresponding lists of names returned by get_vars.  
          *addr_lists(3)   absolute addresses of records  
          *addr_lists(4)   list of file indices corresponding to  
                           addr_lists(3); indices are into addr_lists(5)  
          *addr_lists(5)   list of filenames in the family  
builtin function, documented at i0/std.i   line 2508  

             get_argv()  
 
     returns string array containing the argv from the command line.  
     The -batch and batch_include.i arguments are removed (not returned).  
builtin function, documented at i0/std.i   line 1728  

 get_command_line  
 
  
interpreted function, defined at i0/mpy.i   line 652  

             get_cwd()  
          or get_home()  
 
     returns the pathname of the current working directory or of your  
     home directory.  
builtin function, documented at i0/std.i   line 1712  

             get_env(environment_variable_name)  
 
     returns the environment variable (a string) associated with  
     ENVIRONMENT_VARIABLE_NAME (calls ANSI getenv routine).  
builtin function, documented at i0/std.i   line 1721  

 get_home  
 
builtin function, documented at i0/std.i   line 1712  

 get_instructions  
 
  
interpreted function, defined at i/make.i   line 544  

 get_kaps  
 
  
interpreted function, defined at i0/drat.i   line 1039  

 get_keys  
 
  
interpreted function, defined at i/make.i   line 483  

 get_list  
 
  
interpreted function, defined at i/make.i   line 496  

             get_member(f_or_s, member_name)  
 
     returns F_OR_S member MEMBER_NAME, like F_OR_S.MEMBER_NAME syntax,  
     but MEMBER_NAME can be a computed string.  The F_OR_S may be a  
     binary file or a structure instance.  
builtin function, documented at i0/std.i   line 1872  

 get_mesh  
 
  
interpreted function, defined at i/demo4.i   line 66  

 get_ncycs  
 
builtin function, documented at i0/std.i   line 2533  

             prims = get_primitives(file)  
 
     Return the primitive data types for FILE as an array of 32  
     integers.  The format is described under set_primitives.  
builtin function, documented at i0/std.i   line 2200  

             ray_info= get_ray_path(path, rt, zt)  
 
     where PATH is one element of an array returned by track_rays,  
     returns the points where the ray cut the edges of the mesh (ZT, RT).  
     The returned RAY_INFO has two components: RAY_INFO(,1) is the z  
     coordinates and RAY_INFO(,2) is the r coordinates.  
interpreted function, defined at i0/drat.i   line 1253  

             get_s0(rays)  
 
     returns the s-coordinate of the point of closest approach of  
     the RAYS to the origin x=y=z=0.  The length of the first dimension  
     of RAYS may be either 3, 5, or 6; this first dimension will not  
     be present in the result.  
     The s-coordinate represents distance along the ray, increasing in  
     the direction the ray moves.  The 5 and 6 component ray coordinates  
     include a reference point (x,y,z) on the ray; s=0 at that point.  
     For the 3 component ray coordinate, get_s0 always returns 0.  
interpreted function, defined at i/rays.i   line 223  

             get_std_limits(rays, slimits)  
 
     returns slimits suitable for internal routines: 2-by-nrays,  
     with s=0 at point of closest approach to origin  
interpreted function, defined at i0/drat.i   line 911  

             get_style, landscape, systems, legends, clegends  
 
     get the detailed style of the current drawing.  The arguments  
     are all outputs:  
     landscape: 1 if drawing is landscape orientation, 0 if portrait  
     system:    an array of GfakeSystem struct instances, one per  
                coordinate system in this drawing (ordinarily just one).  
     legends:   a GeLegendBox structure instance describing the layout  
                of the plot legends  
     clegends:  a GeLegendBox structure instance describing the layout  
                of the contour legends  
     See the help for the GeLegendBox and GpTextAttribs structs for  
     the details of the legends and clegends arguments.  Basically,  
     you can adjust the location of the legends on the page, the  
     font and height of the characters used to render legends, and  
     whether the legends are split into two columns.  
     The coordinate systems are the systems accessible via the  
     plsys command.  The index of the system in the system array is  
     the index you use to switch to it in the plsys command.  Simple  
     styles have only one coordinate system, and you should carefully  
     consider whether you should design a graphic style with multiple  
     coordinate systems -- most likely, you can do a better job by  
     combining several separate Yorick pictures with some sort of  
     page layout program, rather than trying to do this work within  
     Yorick itself.  
     See the help for the GfakeSystem struct for complete details of  
     what you can adjust.  The most interesting features you can  
     control are the location and aspect ratio of the viewport, and  
     the details of the axis ticks and labels.  The gridxy function  
     provides a simpler interface for fiddling with ticks and labels  
     if that is all you need.  The system.viewport member is the  
     [xmin,xmax,ymin,ymax] of the rectangle on the page where your  
     plots will appear, expressed in NDC coordinates (0.0013 NDC units  
     equals one point, and there are 72.27 points per inch, and 2.54  
     cm per inch; the NDC origin is always at the lower left hand  
     corner of the paper, with x increasing leftward and y increasing  
     upward).  If you change the size of the viewport, you will also  
     need to change the parameters of the tick-generating model; like  
     other problems in typography and page layout, this is harder  
     than you might think.  
interpreted function, defined at i/style.i   line 10  

             times= get_times(file)  
             ncycs= get_ncycs(file)  
 
     returns the list of time or ncyc values associated with the records  
     if FILE, or nil if there are none.  The time values are not guaranteed  
     to be precise (but they should be good to at least 6 digits or so);  
     the precise time associated with each record may be stored as a record  
     variable.  
builtin function, documented at i0/std.i   line 2533  

             name_lists= get_vars(file)  
 
     returns the lists of non-record and record variable names in the  
     binary FILE.  The return value is an array of two pointers to  
     arrays of type string; *name_lists(1) is the array of non-record  
     variable names (or nil if there are none), *name_lists(2) is the  
     array of record variable names.  
     The get_addrs function returns corresponding lists of disk  
     addresses; the get_member function can be used in conjunction  
     with the dimsof, structof, and typeof functions to determine  
     the other properties of a variable.  
builtin function, documented at i0/std.i   line 2481  

             get_ylm(pts, lmax, list)  
 
     returns values of Ylm at the 3-by-anything array of unit vectors  
     PTS, for all l and m up to LMAX.  The return value is  
     (lmax+1)*(lmax+2)/2-by-anything.  The LIST is also returned; its  
     value is [1, 2,2, 3,3,3, 4,4,4,4, ..., LMAX+1,LMAX+1,...,LMAX+1]  
     -- i copies of each integer i up to LMAX+1.  This can be useful  
     in conjunction with the histogram function; its values are l+1  
     for each element of the returned array's first index.  The m  
     values are [0, 0,1, 0,1,2, 0,1,2,3, 0,1,2,3,4, ...].  Negative m  
     values are omitted, since they would be the conjugates of m>0.  
       llist= list-1;  
       mlist= (!list(dif))(cum)-(list-2)*(list-1)/2;  
interpreted function, defined at i/ylmdec.i   line 34  

             getc3(i, m3, chunk)  
          or getc3(i, m3, clist, l, u, fsl, fsu, cells)  
 
     return cell values of the Ith function attached to 3D mesh M3  
     for cells in the specified CHUNK.  The CHUNK may be a list of  
     cell indices, in which case getc3 returns a (dimsof(CHUNK))  
     list of vertex coordinates.  CHUNK may also be a mesh-specific data  
     structure used in the slice3 routine, in which case getc3 may  
     return a (ni)x(nj)x(nk) array of vertex values.  There is no  
     savings in the amount of data for such a CHUNK, but the gather  
     operation is cheaper than a general list of cell indices.  
     Use getc3 when writing colorng functions for slice3.  
     If CHUNK is a CLIST, the additional arguments L, U, FSL, and FSU  
     are vertex index lists which override the CLIST if the Ith attached  
     function is defined on mesh vertices.  L and U are index lists into  
     the 2x2x2x(dimsof(CLIST)) vertex value array, say vva, and FSL  
     and FSU are corresponding interpolation coefficients; the zone  
     centered value is computed as a weighted average of involving these  
     coefficients.  The CELLS argument is required by histogram to do  
     the averaging.  See the source code for details.  
     By default, this conversion (if necessary) is done by averaging  
     the eight vertex-centered values.  
interpreted function, defined at i/slice3.i   line 725  

 getc3_rect  
 
  
interpreted function, defined at i/slice3.i   line 756  

             getdate -- get date of the day in the form "DD/MM/YY"  
 
    
  SYNOPSIS: date= getdate();  
            getdate, date;  
    
  HISTORY: October 30, 1995 by Eric THIEBAUT.  
    
interpreted function, defined at i/string.i   line 34  

             gettime -- get current time in the form "HH:MM:SS"  
 
    
  SYNOPSIS: time= gettime();  
            gettime, time;  
    
  HISTORY: October 30, 1995 by Eric THIEBAUT.  
    
interpreted function, defined at i/string.i   line 22  

             getv3(i, m3, chunk)  
 
     return vertex values of the Ith function attached to 3D mesh M3  
     for cells in the specified CHUNK.  The CHUNK may be a list of  
     cell indices, in which case getv3 returns a 2x2x2x(dimsof(CHUNK))  
     list of vertex coordinates.  CHUNK may also be a mesh-specific data  
     structure used in the slice3 routine, in which case getv3 may  
     return a (ni)x(nj)x(nk) array of vertex values.  For meshes which  
     are logically rectangular or consist of several rectangular  
     patches, this is up to 8 times less data, with a concomitant  
     performance advantage.  Use getv3 when writing slicing functions  
     for slice3.  
interpreted function, defined at i/slice3.i   line 688  

 getv3_rect  
 
  
interpreted function, defined at i/slice3.i   line 708  

 gg_button  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 717  

 gg_default  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1756  

 gg_dialog  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 48  

             gg_draw_3d_rect, x0, y0, x1, y1, one_pixel,  
                              bd, relief, bg, fg, hi, lo;  
 
     Draw 3D rectangle onto current coordinate system.  (X0,Y0,X1,Y1) is  
     the bounding box of rectangle (included) in units of current plotting  
     system (NDC if plotting system is 0).  ONE_PIXEL is the pixel size in  
     units of current plotting system.  BD is the border width in pixels.  
     RELIEF is the type of relief (see gg_get_relief) FG is the foreground  
     color (used for "solid" border).  BG is the background color (no  
     background get drawn if set to GG_EXTRA) HI and LO are the colors used  
     to draw bright/dark parts of the 3D border.  All colors (BG, FG, HI  
     and LO) must be given as scalar integer.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1534  

 gg_draw_box  
 
  
interpreted function, defined at contrib/yeti_fit_2d_spike.i   line 10  

 gg_draw_roi  
 
  
interpreted function, defined at contrib/yeti_fit_2d_spike.i   line 28  

 gg_draw_target  
 
  
interpreted function, defined at contrib/yeti_fit_2d_spike.i   line 16  

 gg_finalize  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 513  

             gg_find(widget, xndc, yndc)  
 
       -or- gg_find(widget, xndc, yndc, match)  
     Get topmost widget under NDC coordinates (XNDC,YNDC) starting at  
     WIDGET.  Optional argument MATCH is the returned value if no  
     descendant of WIDGET, nor WIDGET itself, is found under (XNDC,YNDC).  
     If MATCH is the same as WIDGET, it is assumed that WIDGET is under  
     (XNDC,YNDC) regardless its actual bounding box (i.e. no check is done  
     for WIDGET itself in this case).  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1638  

             gg_find_clicked(top, ms)  
 
     Get widget managed by container TOP which received click event as  
     defined by MS.  MS has the same contents/meaning as the result of the  
     builtin mouse() function.  A widget is eligible as the receiver of the  
     click event if the button press and release events have occured over  
     this widget.  The return value may be nil if no children of TOP is  
     eligible for the click event.  If several widgets are eligible the  
     topmost one is returned.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1619  

 gg_fit_2d_spike  
 
  
interpreted function, defined at contrib/yeti_fit_2d_spike.i   line 46  

             gg_forget, container, widget;  
 
     Remove WIDGET from the descendant list of CONTAINER, WIDGET will  
     no longer be displayed for subsquent repaints of CONTAINER.  If  
     WIDGET is not a descendant of CONTAINER, nothing is done.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 490  

 gg_frame  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 359  

 gg_get_anchor  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1380  

             gg_get_axis_flags(value, name, defvalue);  
 
     Parse axis specification VALUE which can be an integer or a string  
     where each bits/character toggle an option (see table below). If VALUE  
     is nil, the value of keyword DEFVALUE is returned.  Keyword NAME can  
     be used to set the name of the parameter for error message.  
     char  bit    option  
     ----  -----  ----------------------------------------------------  
     t     0x001  Draw ticks on bottom or left edge of viewport  
     T     0x002  Draw ticks on top or right edge of viewport  
     c     0x004  Draw ticks centered on origin in middle of viewport  
     i     0x008  Ticks project inward into viewport  
     o     0x010  Ticks project outward away from viewport (0x18 for both)  
     l     0x020  Draw tick label numbers on bottom or left edge of viewport  
     L     0x040  Draw tick label numbers on top or right edge of viewport  
     g     0x080  Draw all grid lines down to gridLevel  
     z     0x100  Draw single grid line at origin  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1326  

 gg_get_color  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

             gg_get_font(value);  
 
     Parse font VALUE which can have any value recognized by Yorick  
     for the "font" keyword in builtin plotting functions and return the  
     corresponding integer value. If VALUE is nil, the value of keyword  
     DEFVALUE is returned. Keyword NAME can be used to set the name of the  
     parameter for error message.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1297  

 gg_get_integer  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1161  

 gg_get_real  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1176  

 gg_get_string  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1192  

             gg_is_ndx(colors)  -- true where COLORS is indexed  
 
       -or- gg_is_rgb(colors)  -- true where COLORS is RGB  
       -or- gg_rgb(r,g,b)      -- convert to RGB color  
       -or- gg_rgb_r(colors)   -- red intensity of RGB COLORS  
       -or- gg_rgb_g(colors)   -- green intensity of RGB COLORS  
       -or- gg_rgb_b(colors)   -- blue intensity of RGB COLORS  
     These routines are useful to deal with color values (as integers).  
     R, G, and B are the components of RGB colors (0=black, 255=maximum).  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_is_rgb  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_label  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 674  

             gg_manage, container, col, row, widget;  
 
     Make WIDGET a children of widget CONTAINER that will be displayed into  
     cell (COL,ROW) of CONTAINER grid.  
     Keyword ANCHOR can be used to indicates how WIDGET should be anchored  
     in its cell if there is remaining space (see gg_get_anchor).  The  
     default anchoring is centered.  
     Keywords COLSPAN and ROWSPAN indicates how many colmuns/rows the widget  
     will occupy.  The default is COLSPAN=1 and ROWSPAN=1.  
     Keywords PADX and PADY indicates how many pixels shoulkd be left around  
     the widget in its cell.  
     If keyword INSERT is true, WIDGET will be the first children of the  
     list and therefore displayed below all other children; otherwise,  
     WIDGET will be the topmost one (if children of CONTAINER do not  
     overlap, this dictinction is irrelevant).  
interpreted function, defined at contrib/yeti_gist_gui.i   line 430  

             gg_map(op, arg);  
 
       -or- gg_map(op, arg, defvalue);  
     Map scalar function OP onto array argument ARG to mimics element-wise  
     unary operation.  If ARG is NIL, DEFVALUE is returned.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1738  

 gg_no_op  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 344  

 gg_on_click  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 728  

 gg_paint  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 336  

 gg_pli_tool  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 114  

 gg_rgb  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_rgb_b  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_rgb_g  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_rgb_r  
 
interpreted function, defined at contrib/yeti_gist_gui.i   line 1201  

 gg_test  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 257  

 gg_toplevel  
 
  
interpreted function, defined at contrib/yeti_gist_gui.i   line 384  

             gg_viewport, left, right, bottom, top;  
 
       -or- gg_viewport, vp;  
       
interpreted function, defined at contrib/yeti_gist_gui.i   line 769  

             gg_window, win;  
 
       -or- gg_window;  
       -or- gg_window(...);  
     Create/switch to graphic window WIN.  This routine allows one to  
     create a window of given size with viewport(s) different from the  
     default one.  Otherwise its behaviour should mimics that of the  
     "window" builtin routine.  If called as a function, the return  
     value is an array of 6 double values:  
       [WIN, ONE_PIXEL, XMIN, XMAX, YMIN, YMAX]  
     where WIN is the window number, ONE_PIXEL is the pixel size in NDC  
     units and [XMIN,XMAX,YMIN,YMAX] is the bounding box in NDC units.  
   KEYWORDS  
     DPI, DISPLAY, PRIVATE, DUMP, HCP - Same options as for the  
                 window builtin routine.  
     WIDTH, HEIGHT - Window width/height in pixels; default: 450 at 75dpi  
                 and 600 at 100dpi.  
     LANDSCAPE - Orientation.  
     VIEWPORT  - Viewport coordinates: [XMIN, XMAX, YMIN, YMAX].  Several  
                 viewports can be specified at the same time, in this  
                 case, first dimension of VIEWPORT must be a 4 and  
                 XMIN is VIEWPORT(1,..), XMAX is VIEWPORT(2,..) and so on.  
     UNITS     - Units for the viewport keyword: 0 for NDC (default),  
                 1 for relative, and 2 for pixels.  
     FONT      - Font to use to label axes (see gg_get_font); default is  
                 Helvetica.  
     SIZE      - Text size for axis labels in points; default is 12.  
     COLOR     - Axis color (see gg_get_color); default is foreground.  
     KEEP      - Keep WIN if it already exists? Otherwise the window is  
                 forced to be recreated (this is the default behaviour).  
     XOPT      - Options for X-axis of viewport (see gg_get_axis_flags).  
     YOPT      - Options for Y-axis of viewport (see gg_get_axis_flags).  
     XMARGIN, YMARGIN -  
     Note: If you specify multiple viewports, FONT, SIZE, COLOR, XOPT  
           and YOPT can by different for each viewport.  
interpreted function, defined at contrib/yeti_gist_gui.i   line 949  

             gg_zoom, ms;  
 
       -or- gg_zoom, ms, zoom_factor;  
     Mimics the "zooming with the mouse" feature of Gist interactive windows.  
     Argument MS is identical to the return value of the mouse() function:  
       MS = [x_pressed,    y_pressed,    x_released,    y_released,  
             xndc_pressed, yndc_pressed, xndc_released, yndc_released,  
             system, button, modifiers];  
     Optional second argument can be used to set the zoom factor to a  
     real >=1.0.  With ZOOM_FACTOR=1.0, you can still drag the viewing  
     region.  
     For instance, the following statements will interactively  
     zoom in/out forever:  
       for (;;) {  
         ms = mouse(-1,2,"");  
         if (is_void(ms)) break;  
         gg_zoom, ms;  
       }  
interpreted function, defined at contrib/yeti_gist_gui.i   line 1665  

             gnomon  
          or gnomon, onoff  
 
     Toggle the gnomon display.  If ONOFF is non-nil and non-zero,  
     turn on the gnomon.  If ONOFF is zero, turn off the gnomon.  
     The gnomon shows the X, Y, and Z axis directions in the  
     object coordinate system.  The directions are labeled.  
     The gnomon is always infinitely far behind the object  
     (away from the camera).  
     There is a mirror-through-the-screen-plane ambiguity in the  
     display which is resolved in two ways: (1) The (X,Y,Z)  
     coordinate system is right-handed, and (2) If the tip of an  
     axis projects into the screen, it's label is drawn in opposite  
     polarity to the other text on the screen.  
interpreted function, defined at i/pl3d.i   line 734  

                grid_read(fname)  return a grid structure  
 
interpreted function, defined at contrib/gadget.i   line 192  

                grid_write(tab,fname)  
 
interpreted function, defined at contrib/gadget.i   line 216  

             gridxy, flag  
          or gridxy, xflag, yflag  
 
     Turns on or off grid lines according to FLAG.  In the first form, both  
     the x and y axes are affected.  In the second form, XFLAG and YFLAG  
     may differ to have different grid options for the two axes.  In either  
     case, a FLAG value of 0 means no grid lines (the default), a value of  
     1 means grid lines at all major ticks (the level of ticks which get  
     grid lines can be set in the style sheet), and a FLAG value of 2 means  
     that the coordinate origin only will get a grid line.  In styles with  
     multiple coordinate systems, only the current coordinate system is  
     affected.  
     The keywords can be used to affect the style of the grid lines.  
     You can also turn the ticks off entirely.  (You might want to do this  
     to plot your own custom set of tick marks when the automatic tick  
     generating machinery will never give the ticks you want.  For example  
     a latitude axis in degrees might reasonably be labeled "0, 30, 60,  
     90", but the automatic machinery considers 3 an "ugly" number - only  
     1, 2, and 5 are "pretty" - and cannot make the required scale.  In  
     this case, you can turn off the automatic ticks and labels, and use  
     plsys, pldj, and plt to generate your own.)  
     To fiddle with the tick flags in this general manner, set the  
     0x200 bit of FLAG (or XFLAG or YFLAG), and "or-in" the 0x1ff bits  
     however you wish.  The meaning of the various flags is described  
     in the file Y_SITE/gist/work.gs.  Additionally, you can use the  
     0x400 bit to turn on or off the frame drawn around the viewport.  
     Here are some examples:  
        gridxy,0x233        work.gs default setting  
        gridxy,,0x200       like work.gs, but no y-axis ticks or labels  
        gridxy,,0x231       like work.gs, but no y-axis ticks on right  
        gridxy,0x62b        boxed.gs default setting  
     The three keywords base60=, degrees=, and hhmm= can be used to get  
     alternative tick intervals for base 60 systems instead of the  
     usual base 10 systems.  The keyword values are 0 to restore the  
     default behavior, 1 to set the feature for the x axis, 2 to set it  
     for the y axis, and 3 to set it for both axes.  The base60 feature  
     allows ticks and labels at multiples of 30 (up to +-3600).  The  
     degrees feature causes labels to be printed modulo 360 (so that a  
     scale which runs from, say, 90 to 270 will be printed as 90 to 180  
     then -180 to -90, mostly for longitude scales).  The hhmm feature  
     causes labels to be printed in the form hh:mm (so that, for example,  
     150 will be printed as 02:30, mostly for time of day scales).  
   KEYWORDS: color, type, width, base60, degrees, hhmm  
builtin function, documented at i0/graph.i   line 794  

             grow, x, xnext1, xnext2, ...  
          or grow(x, xnext1, xnext2, ...)  
          or    _(x, xnext1, xnext2, ...)  
 
     lengthens the array X by appending XNEXT1, XNEXT2, etc. to its  
     final dimension.  If X is nil, X is first redefined to the first  
     non-nil XNEXT, and the remainder of the XNEXT list is processed  
     normally.  Each XNEXT is considered to have the same number of  
     dimensions as X, by appending unit-length dimensions if necessary.  
     All but this final dimension of each XNEXT must be right-conformable  
     (that is, conformable in the sense of the right hand side of an  
     assignment statement) with all but the final dimension of X.  
     The result has a final dimension which is the sum of the final  
     dimension of X and all the final dimensions of the XNEXT.  Nil  
     XNEXT are ignored.  The value of the result is obtained by  
     concatenating all the XNEXT to X, after any required broadcasts.  
     If invoked as a function, grow returns the new value of X; in  
     this case, X may be an expression.  X must be a simple variable  
     reference for the subroutine form of grow; otherwise there is  
     nowhere to return the result.  The subroutine form is slightly  
     more efficient than the function form for the common usage:  
          x= grow(x, xnext1, xnext2)           is the same as  
          grow, x, xnext1, xnext2              the preferred form  
     The _ function is a synonym for grow, for people who want this  
     operator to look like punctuation in their source code, on analogy  
     with the array building operator [a, b, c, ...].  
     The _cat function is sometimes more appropriate than grow.  
builtin function, documented at i0/std.i   line 988  

             grtest  
          or grtest, nstart  
 
     Perform a comprehensive test of Yorick's graphics package.  
     Pauses after each frame to let you check the result.  Each  
     picture attempts to describe itself (of course, if text  
     plotting is broken, this doesn't do any good).  
     With NSTART, start with test number NSTART.  
interpreted function, defined at i/testg.i   line 249  

             guess_symmetry, f  
          or guess_symmetry(f)  
 
     guesses the symmetry of the problem in the dump file F based on  
     the variables f.isymz, f.rt, and f.zt.  
     If called as a subroutine, prints one of:  
     "no symmetry", "z=0 reflection symmetry", or "spherical symmetry"  
     If called as a function, returns 0, 1, or 2, respectively.  
interpreted function, defined at i0/drat.i   line 929  

 gw  
 
  
interpreted function, defined at i/testg.i   line 239