Home Manual Packages Global Index Keywords Quick Reference | # all functions - d
data_align |
                 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 2498
SEE ALSO: | save, add_variable
dawson |
                 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
SEE ALSO: | erf, erfc
day2000 |
     day2000

    interpreted function, defined at i/kepler.i   line 421
dbauto |
     dbauto

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbcont |
     dbcont

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbdis |
     dbdis

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbexit |
                 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 2844
dbinfo |
     dbinfo

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbret |
     dbret

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbskip |
     dbskip

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbup |
     dbup

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dec_primitives |
                 dec_primitives, file

         sets FILE primitive data types to be native to DEC (MIPS) workstations.

    interpreted function, defined at i0/std.i   line 1979
default_gate |
                 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
SEE ALSO: | gauss_gate, drat_gate
default_integrate |
                 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
SEE ALSO: | streak
default_ocompute |
                 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 |
                 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
SEE ALSO: | sound, shock, evolve
demo2 |
                 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 |
                 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 |
                 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 |
                 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
SEE ALSO: | plwf, light3, rot3, orient3, spin3, mesh3, slice3, slice2, pl3tree, pl3surf
demo5_light |
     demo5_light

    interpreted function, defined at i/demo5.i   line 159
deriv |
     deriv

    interpreted function, defined at i/test1.i   line 395
digit2 |
                 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
SEE ALSO: | digitize, interp2, mesh_loc, plm
digitize |
                 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 933
SEE ALSO: | histogram, interp, integ, sort, where, where2
dimsof |
                 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
SEE ALSO: | typeof, structof, numberof, sizeof, orgsof
dirt_rays |
                 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
SEE ALSO: | form_rays, best_rays, internal_rays, get_s0, picture_rays
disassemble |
                 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 |
     display
display_pl3 |
     display_pl3

    interpreted function, defined at i/demo2.i   line 144
display_plf |
     display_plf

    interpreted function, defined at i/demo2.i   line 108
display_plm |
     display_plm

    interpreted function, defined at i/demo2.i   line 130
distill_interp |
     distill_interp

    interpreted function, defined at i/ylmdec.i   line 347
dmxpy |
     dmxpy

    interpreted function, defined at i/testlp.i   line 133
dn_ |
                 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
SEE ALSO: | elliptic, ell_am
do_batch |
     do_batch

    interpreted function, defined at i/ylmdec.i   line 208
do_filled |
     do_filled

    interpreted function, defined at i/testg.i   line 105
do_hollow |
     do_hollow

    interpreted function, defined at i/testg.i   line 63
double_neq |
     double_neq

    interpreted function, defined at i/testb.i   line 879
draw3 |
                 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 |
     draw3_trigger

    interpreted function, defined at i/pl3d.i   line 701
draw_frame |
     draw_frame

    interpreted function, defined at i/demo3.i   line 51
dump_clog |
                 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 1892
SEE ALSO: | openb
dump_palette |
                 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
SEE ALSO: | brighten, palette, palette_directory