all functions - d

             coordinate transformation : decimal degree  
 
   to sexadecimal hour angle for x(,1) and decimal  
   to sexadecimal for x(,2)   
  see also : ad2d */  
interpreted function, defined at contrib/astools.i   line 30  

             data_align, file, alignment  
 
     in binary file FILE, align new variables to begin at a byte address  
     which is a multiple of ALIGNMENT.  (This affects placement of data  
     declared using save and add_variable.  For add_variable, data_align  
     has an effect only if the address is not specified.)  If ALIGNMENT  
     is <=0, new variables will be aligned as they would be if they were  
     data structure members.  The default value is 0.  
builtin function, documented at i0/std.i   line 2631  

             dawson(x)  
 
    return Dawson's integral, exp(-x^2)*integral[0 to x](exp(t^2)*dt)  
    maximum is dawson(0.9241388730) = 0.5410442246  
    inflection point is dawson(1.5019752682) = 0.4276866160  
interpreted function, defined at i/dawson.i   line 6  

 day2000  
 
  
interpreted function, defined at i/kepler.i   line 421  

 db_get_member  
 
  
interpreted function, defined at contrib/yeti_hash_test.i   line 5  

 db_rehash  
 
  
interpreted function, defined at contrib/yeti_hash_test.i   line 1  

 dbauto  
 
builtin function, documented at i0/std.i   line 2977  

 dbcont  
 
builtin function, documented at i0/std.i   line 2977  

 dbdis  
 
builtin function, documented at i0/std.i   line 2977  

             Debug mode.  
 
   Yorick errors fall into two general categories: Syntax errors discovered  
   during parsing, and runtime errors discovered when a Yorick program is  
   actually running.  When a runtime error occurs, Yorick offers the  
   choice of entering "debug mode", which you can do by typing the   
   key immediately after the error occurs.  Typing a non-blank line exits  
   debug mode automatically by default.  In debug mode, the Yorick prompt  
   becomes "dbug>" instead of the usual ">".  When you see this prompt,  
   Yorick has halted "in the middle of" the function in which the error  
   occurred, and you can print, plot, modify, or save the local variables  
   in that function by means of ordinary Yorick commands.  Debug mode is  
   recursive; that is, you can debug an error which occurred during  
   debugging to any number of levels.  
   You can exit from debug mode in several ways:  
      dbexit            -- exit current debug level, discarding all  
                           active functions and their local variables  
      dbexit, 0         -- exit all debug levels  
      dbexit, n         -- exit (at most) N debug levels  
      dbcont            -- continue execution of the current function  
         Continuing is useful if you have managed to repair the  
         problem which caused the error.  The expression in which the  
         error occurred will be evaluated a second time, so beware of  
         side effects.  
      dbret, value      -- continue execution by returning VALUE (which  
                           may be nil or omitted) to the caller of the  
                           function in which the error occurred.  
         This is useful if the function in which the error occurred is  
         hopelessly confounded, but you know the value it should return.  
   Yorick does not allow "single stepping" directly, although you can  
   execute the statements in a function by copying them, then tell  
   Yorick to skip those statements you have executed "by hand".  There  
   are two functions for skipping execution:  
      dbskip            -- skip the next logical line (This will be only  
                           a portion of a source line if several statements  
                           are stacked on the source line.)  
      dbskip, n         -- skip next N (positive or negative) logical lines  
      dbup              -- discard the current function, so that you are  
                           debugging its caller -- there is no way to go  
                           back "down", so be careful  
   There are two functions which print information (like other print  
   functions, if called as functions instead of subroutines, their  
   result is returned as a string array with one line per string):  
      dbinfo            -- returns current function and source line  
      dbdis             -- returns disassembled virtual machine code  
                           for the next line (use the disassemble function  
                           to get the entire function)  
         This allows you to see exactly where in a line the error occurred.  
   Finally,  
      dbauto            -- toggles whether debug mode will be entered  
                           automatically when a runtime error occurs  
      dbauto, 1         -- enter debug mode automatically after an error  
      dbauto, 0         -- type  after error to enter debug mode  
builtin function, documented at i0/std.i   line 2977  

 dbinfo  
 
builtin function, documented at i0/std.i   line 2977  

 dbret  
 
builtin function, documented at i0/std.i   line 2977  

 dbskip  
 
builtin function, documented at i0/std.i   line 2977  

 dbup  
 
builtin function, documented at i0/std.i   line 2977  

             dec_primitives, file  
 
     sets FILE primitive data types to be native to DEC (MIPS) workstations.  
interpreted function, defined at i0/std.i   line 2112  

             default_gate(times)  
 
     initial value of drat_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 772  

             atten_emit= default_integrate(f, mesh, time, irays, slimits)  
 
     is the default drat_integrate routine.  
     On entry, file F is positioned at TIME, from which MESH has already  
     been read.  IRAYS and SLIMITS are the rays coordinates (in internal  
     format) and integration limits.  
     The result should be ngroup-by-2-by-raydims, where the second index  
     is 1 for the attenuation factor, 2 for the self-emission (specific  
     intensity due to emission along the ray).  
   OPTIONS: drat_linear, drat_ocompute, drat_oadjust,  
            drat_emult, drat_amult, drat_omult, drat_nomilne,  
            drat_ekap, drat_akap, drat_glist  
interpreted function, defined at i0/drat.i   line 167  

             default_ocompute(f, time)  
 
     initial value of drat_ocompute.  Extracts drat_akap and drat_ekap  
     from file F, possibly using the subset drat_glist.  TIME is unused.  
interpreted function, defined at i0/drat.i   line 717  

             demo1  
 
     run the 1-D hydrocode demonstration.  An X window should pop up  
     in which a movie of a wave propagating down a shock tube appears.  
     Use the 'sound' and 'shock' commands to set two different interesting  
     initial conditions; the default is 'sound'.  
interpreted function, defined at i/demo1.i   line 277  

             demo2  
 
     Exhibit quadrilateral mesh plots in 3 movies of a drumhead.  
     The drumhead is initially stationary, but has a bump near one  
     edge.  Yorick is solving a 2D wave equation to compute the  
     evolution of this bump.  
     The first movie is a filled mesh plot with color "proportional"  
     to the height of the surface of the drum.  A few well chosen  
     contour levels (here 3) add a lot to a filled mesh plot.  
     The second movie is a "3D" perspective plot of the height of the  
     drumhead.  In this movie, the mesh lines are drawn, which is  
     slightly confusing since the cells are not all the same shape.  
     The second movie is a "3D" shaded plot of the height of the  
     drumhead.  Yorick computes surface shading based on the angle  
     of each cell from a light source.  
     As you watch this, you might reflect on the two dimensionality  
     of your retina.  What Yorick lacks by way of 3D graphics is  
     really just fancy hidden surface algorithms; the simple  
     painter's algorithm used here and in plwf.i is easy to  
     implement.  
     There are two optional arguments to demo2: the first is the  
     number fo the movie (1, 2, or 3) you want to watch; the second  
     is a time limit on the duration of each movie in seconds (default  
     is 60 seconds each).  
interpreted function, defined at i/demo2.i   line 10  

             demo3  
 
     Solve Lagrange's equations for a famous chaotic pendulum (as on  
     exhibit at the San Francisco Exploratorium).  Run a movie of the  
     result.  By default, the movie runs for 60 seconds, but if you  
     supply an argument to the demo3 function, it will run for that  
     many seconds.  
     The kick= keyword may be used to adjsut the initial amplitude;  
     kick= 1.2 is the default.  
     You may also wish to supply a damp_time= keyword to see the effect  
     of an ad hoc damping term.  damp_time=100 is nice.  
interpreted function, defined at i/demo3.i   line 10  

             demo4  
          or demo4, mono=1  
 
     solves for the flow past a 2D airfoil using Kutta-Jakowski theory.  
     The colors represent static pressure (darker is lower pressure),  
     red lines are streamlines.  
     Solutions for various angles of attack are shown by animation.  
     With the mono=1 keyword, only the streamlines are shown.  (On a  
     monochrome terminal, the pressure makes the streamlines invisible.)  
interpreted function, defined at i/demo4.i   line 10  

             demo5  
          or demo5, i  
 
     Run examples of use of pl3d.i, plwf.i, and slice3.i.  With  
     argument I = 1, 2, or 3, run that particular demonstration.  
     Read the source code to understand the details of how the  
     various effects are obtained.  
     demo5,1  demonstrates the various effects which can be obtained  
     with the plwf (plot wire frame) function.  
     demo5,2  demonstrates shading effects controlled by the light3  
     function  
     demo5,3  demonstrates the slice3, slice2, and pl3tree functions,  
     as well as changing the orientation of the 3D object  
interpreted function, defined at i/demo5.i   line 18  

 demo5_light  
 
  
interpreted function, defined at i/demo5.i   line 159  

             1D  non parametric  histogram X  is the  vector defining the bins  
 
SEE ALSO histo  
interpreted function, defined at contrib/histon.i   line 246  

             2D non parametric histogram X,Y are the  vector defining the bins  
 
SEE ALSO histo2d  
interpreted function, defined at contrib/histon.i   line 259  

             3D non parametric histogram X,Y,Z are the  vector defining the bins  
 
SEE ALSO histo3d  
interpreted function, defined at contrib/histon.i   line 279  

 deriv  
 
  
interpreted function, defined at i/test1.i   line 395  

                df3_read(fname)  return a df3 structure  
 
    q= df3_read("./snapshot_000")  
    modified to be df3 1.1 compatible  
interpreted function, defined at contrib/df3.i   line 2  

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

             digit2(y0,x0, y,x)  
 
       -or- digit2(y0,x0, y,x,reg)  
     return the index of the zone of the point or points (X0,Y0)  
     in the quadrilateral mesh (X,Y) with the optional region  
     array REG.  The result has the same dimensions as the input  
     X0 and Y0 arrays.  The result is <=0 at points outside the mesh.  
     By default, the zone index is an index into an (M-1)-by-(N-1)  
     array, if X and Y are M-by-N.  However, if the keyword pt= is  
     non-nil and non-zero, the return value is the index into an  
     M-by-N array in which the first row and column are non-existent  
     (like the optional REG array).  
interpreted function, defined at i/digit2.i   line 10  

             digitize(x, bins)  
 
     returns an array of longs with dimsof(X), and values i such that  
     BINS(i-1) <= X < BINS(i) if BINS is monotonically increasing, or  
     BINS(i-1) > X >= BINS(i) if BINS is monotonically decreasing.  
     Beyond the bounds of BINS, returns either i=1 or i=numberof(BINS)+1  
     as appropriate.  
builtin function, documented at i0/std.i   line 1064  

             dimsof(object)  
          or dimsof(object1, object2, ...)  
 
     returns a vector of integers describing the dimensions of OBJECT.  
     The format of the vector is [number of dims, length1, length2, ...].  
     The orgsof function returns the origin of each dimension (normally 1).  
     If more than one argument is given, dimsof returns the dimension  
     list of the result of binary operations between all the objects,  
     or nil if the objects are not conformable.  
builtin function, documented at i0/std.i   line 336  

             dirt_rays(rays)  
 
     returns 3-element (x,y,theta) representation of RAYS.  
     The first dimension of RAYS may be length 3, 5, or 6 to represent  
     the ray(s) in TDG/DIRT coordinates (x,y,theta), "best" coordinates  
     (x,y,z,theta,phi), or internal coordinates (cos,sin,y,z,x,r),  
     respectively.  The first dimension of the result always has length 3.  
     The TDG/DIRT coordinate system is based on the coordinates (x,y)  
     in a plane normal to the ray.  Unfortunately, the old TDG and DIRT  
     codes used an angle theta which has the opposite sense from the  
     "best" and internal coordinates.  Therefore, conversion from  
     TDG/DIRT coordinates to internal coordinates will reverse the  
     sign of theta.  Conversion from TDG/DIRT coordinates to "best"  
     coordinates always results in positive theta, but the angle phi  
     will be pi for positive input theta.  
     The slimits parameter -- used to specify the points along  
     a ray where the transport integration starts and stops -- is  
     measured from the point of closest approach of the ray described  
     by (x,y,theta) to the origin x=y=z=0.  Therefore, slimits is  
     independent of the TDG/DIRT ray coordinate representation.  
interpreted function, defined at i/rays.i   line 97  

             disassemble(function)  
          or disassemble, function  
 
     Disassembles the specified function.  If called as a function, the  
     result is returned as a vector of strings; if called as a subroutine,  
     the disassembly is printed at the terminal.  If the function is nil,  
     the current *main* program is disassembled -- you must include the  
     call to disassemble in the main program, of course, NOT on its own  
     line as a separate main program.  
builtin function, documented at i0/std.i   line 253  

 display  
 
  

 display  
 
  

 display_pl3  
 
  
interpreted function, defined at i/demo2.i   line 144  

 display_plf  
 
  
interpreted function, defined at i/demo2.i   line 108  

 display_plm  
 
  
interpreted function, defined at i/demo2.i   line 130  

 distill_interp  
 
  
interpreted function, defined at i/ylmdec.i   line 347  

 dmxpy  
 
  
interpreted function, defined at i/testlp.i   line 133  

             dn_(ell_am(u,m))  
 
     return the Jacobian elliptic function dn(u|m).  The external  
     variable ell_m must be set properly before calling dn_.  
interpreted function, defined at i/elliptic.i   line 166  

 do_batch  
 
  
interpreted function, defined at i/ylmdec.i   line 208  

 do_filled  
 
  
interpreted function, defined at i/testg.i   line 105  

 do_hollow  
 
  
interpreted function, defined at i/testg.i   line 63  

 double_neq  
 
  
interpreted function, defined at i/testb.i   line 879  

             draw3  
 
     Draw the current 3D display list.  
     (Ordinarily triggered automatically when the drawing changes.)  
interpreted function, defined at i/pl3d.i   line 667  

 draw3_trigger  
 
  
interpreted function, defined at i/pl3d.i   line 701  

 draw_frame  
 
  
interpreted function, defined at i/demo3.i   line 51  

             dump_clog, file, clog_name  
 
     dumps a Contents Log of the binary file FILE into the text file  
     CLOG_NAME.  Any previous file named CLOG_NAME is overwritten.  
builtin function, documented at i0/std.i   line 2025  

             dump_palette, name  
 
     dump the current palette under the NAME.  If NAME contains no  
     slash characters, the palette_directory will be prepended to the  
     name.  The name can be fed back to the palette command in order  
     to reload the cumped palette.  
interpreted function, defined at i/color.i   line 19