Home

Manual

Packages

Global Index

Keywords

Quick Reference

# all functions - g

 gadget_merge ``` 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 ``` SEE ALSO:

 gadget_read ``` 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 ```

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

 gadgetcenter ``` recenters a given gadget snapshot on a given coordinate interpreted function, defined at contrib/gadget.i line 509 ``` SEE ALSO:

 gammp ``` 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 ``` SEE ALSO: gammq,   betai,   ln_gamma

 gammq ``` 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 ``` SEE ALSO: gammp,   betai,   ln_gamma

 gauss_gate ``` 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 ``` SEE ALSO: gaussian_gate,   drat_gate

 gauss_int ``` 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 ``` 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 ``` SEE ALSO: snap,   drat_gate

 gcd ``` 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 ``` SEE ALSO: lcm,   is_prime,   factorize

 genRt ``` 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 ``` SEE ALSO:

 genRt2D ``` 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 ``` SEE ALSO:

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

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

 genrandfield1D ``` 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 ``` SEE ALSO,   fft_indgen,,   fft.

 genrandfield2D ``` 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 ``` SEE ALSO,   fft_indgen,,   fft.

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

 get3_centroid ``` 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 ``` SEE ALSO: get3_normal,   get3_light

 get3_light ``` 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 ``` SEE ALSO: light3,   set3_object,   get3_normal,   get3_centroid

 get3_normal ``` 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 ``` SEE ALSO: get3_centroid,   get3_light

 get3_xy ``` 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 ``` SEE ALSO: sort3d,   get3_light,   rot3,   setz3,   set3_object

 get_addrs ``` 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 ``` SEE ALSO: openb,   updateb,   restore,   jt,   jc,   has_records,   get_vars

 get_argv ``` 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 ``` SEE ALSO: process_argv,   cd,   get_cwd,   get_home,   get_env,   batch

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

 get_cwd ``` 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 ``` SEE ALSO: cd,   lsdir,   get_env,   get_argv

 get_env ``` 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 ``` SEE ALSO: cd,   get_cwd,   get_home,   get_env,   get_argv

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

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

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

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

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

 get_member ``` 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 ``` SEE ALSO: openb

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

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

 get_primitives ``` 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 ``` SEE ALSO: set_primitives,   __xdr,   __i86

 get_ray_path ``` 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 ``` SEE ALSO: track_rays

 get_s0 ``` 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 ``` SEE ALSO: best_rays,   dirt_rays,   internal_rays

 get_std_limits ``` 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 ``` 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 ``` SEE ALSO: set_style,   read_style,   write_style

 get_times ``` 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 ``` SEE ALSO: collect,   openb,   updateb,   restore,   jt,   jc,   edit_times

 get_vars ``` 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 ``` SEE ALSO: openb,   updateb,   restore,   jt,   jc,   has_records,   get_addrs,   set_vars

 get_ylm ``` 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 ``` 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 ``` SEE ALSO: slice3,   mesh3,   getv3,   xyz3

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

 getdate ``` 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 ``` SEE ALSO: gettime,   parsedate,   timestamp

 gettime ``` 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 ``` SEE ALSO: getdate,   parsedate,   timestamp

 getv3 ``` 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 ``` SEE ALSO: slice3,   mesh3,   getc3,   xyz3

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

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

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

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

 gg_draw_3d_rect ``` 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 ``` SEE ALSO: gg_get_relief

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

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

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

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

 gg_find ``` 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 ``` SEE ALSO: mouse,   gg_find_clicked

 gg_find_clicked ``` 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 ``` SEE ALSO: mouse,   gg_find

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

 gg_forget ``` 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 ``` SEE ALSO: gg_manage

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

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

 gg_get_axis_flags ``` 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 ``` SEE ALSO,   gg_window.

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

 gg_get_font ``` 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 ``` SEE ALSO,   font,,   gg_get_color,,   gg_window.

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

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

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

 gg_is_ndx ``` 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 ``` SEE ALSO,   gg_get_color.

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

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

 gg_manage ``` 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 ``` SEE ALSO: gg_finalize,   gg_forget

 gg_map ``` 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 ``` gg_no_op interpreted function, defined at contrib/yeti_gist_gui.i line 344 ```

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

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

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

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

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

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

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

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

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

 gg_viewport ``` gg_viewport, left, right, bottom, top; -or- gg_viewport, vp; interpreted function, defined at contrib/yeti_gist_gui.i line 769 ``` SEE ALSO: window,   viewport,   set_style

 gg_window ``` 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 ``` SEE ALSO,   gg_get_axis_flags,,   gg_get_color,,   gg_get_font,,   window.

 gg_zoom ``` 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 ``` SEE ALSO: gg_window,   limits,   mouse,   unzoom

 gnomon ``` 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 ``` grid_read(fname) return a grid structure interpreted function, defined at contrib/gadget.i line 192 ```

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

 gridxy ``` 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 ``` SEE ALSO: window,   plsys,   limits,   range,   logxy,   viewport

 grow ``` 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 ``` SEE ALSO: _cat,   array

 grtest ``` 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 ``` SEE ALSO: testg,   lissajous

 guess_symmetry ``` 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 ``` gw interpreted function, defined at i/testg.i line 239 ```