all functions - t

            NT    
             tags = tagscan, filename  
 
    scan file filename for function declarations/definitions.         
    Returns a (6, nfunc) string array containing, for each function,  
    the function name, then the directory name, file name, and line  
    where it appears, its DOCUMENT comment and type. As with the mkdoc   
    function, if subsequent extern lines precede the DOCUMENT   
interpreted function, defined at contrib/htmldoc.i   line 286  

 tan  
 
builtin function, documented at i0/std.i   line 518  

 tanh  
 
builtin function, documented at i0/std.i   line 557  

             test1  
          or test1, npass  
 
     Track a mock "ablation front" as it propagates through a mesh.  
     If NPASS is given, the calculation is repeated that many  
     times.  The zoning, densities, temperatures, pressures, and  
     velocities are all computed arbitrarily, but the number of zones  
     and groups are taken to be representative of a typical 1-D  
     ablation calculation.  */  
interpreted function, defined at i/test1.i   line 12  

             test2  
          or test2, npass  
 
     Given a slab divided into zones by parallel planes, and given a  
     set of photon group boundary energies, compute the contribution of  
     each zone to the radiation flux emerging from one surface of the  
     slab.  If NPASS is given, the calculation is repeated that many  
     times.  The zoning, photon group structure, opacities, and source  
     functions are all computed arbitrarily, but the number of zones  
     and groups are taken to be representative of a typical 1-D  
     radiation transport calculation.  */  
interpreted function, defined at i/test2.i   line 10  

             test3  
          or test3, npass  
 
     Computes the ratio r which solves 1 + r^2 + r^3 +...+ r^n = s,  
     given n and s.  If NPASS is given, the calculation is repeated  
     that many times (actually the equation is solved many times for  
     each pass).  The worker routine invgeom can actually be  
     vectorized; the vector version is gseries_r in series.i.  */  
interpreted function, defined at i/test3.i   line 10  

 testLU  
 
  
interpreted function, defined at i/testm.i   line 116  

 testQR  
 
  
interpreted function, defined at i/testm.i   line 152  

 testSV  
 
  
interpreted function, defined at i/testm.i   line 209  

 testSVD  
 
  
interpreted function, defined at i/testm.i   line 176  

 testTD  
 
  
interpreted function, defined at i/testm.i   line 91  

 test_clog  
 
  
interpreted function, defined at i/testb.i   line 260  

 test_full  
 
  
interpreted function, defined at i/testb.i   line 219  

 test_hist  
 
  
interpreted function, defined at i/testb.i   line 302  

             testb  
          or testb, 1      (prints yorick_stats)  
 
     Perform systematic test of all features of Yorick's binary I/O  
     package.  This extends the simple test in testp.i.  
interpreted function, defined at i/testb.i   line 14  

 tester1  
 
  
interpreted function, defined at i/testb.i   line 74  

 tester2  
 
  
interpreted function, defined at i/testb.i   line 122  

 tester3  
 
  
interpreted function, defined at i/testb.i   line 174  

 tester4  
 
  
interpreted function, defined at i/testb.i   line 227  

 tester5  
 
  
interpreted function, defined at i/testb.i   line 279  

 tester6  
 
  
interpreted function, defined at i/testb.i   line 362  

             testg  
 
     runs a Yorick near-equivalent of Steve Langer's grbench graphics  
     timing benchmark.  
interpreted function, defined at i/testg.i   line 11  

             testlp  
 
     Run a benchmark of Yorick's LUsolve routine similar to the  
     Linpack benchmark.  
interpreted function, defined at i/testlp.i   line 11  

 testm  
 
  
interpreted function, defined at i/testm.i   line 10  

             compute 3 pt correlation function in 1D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield1D(20); u=fft(ui,[-1]).re;  
   res =threeptcor1D(u)  
       
interpreted function, defined at contrib/correl.i   line 833  

             compute 3 pt correlation function in 2D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield2D(20); u=fft(ui,[-1,-1]).re;  
   res =threeptcor2D(u)  
       
interpreted function, defined at contrib/correl.i   line 757  

             compute 3 pt correlation function in 3D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield3D(50); u=fft(ui,[-1,-1,-1]).re;  
   res =threeptcor(u)  
       
interpreted function, defined at contrib/correl.i   line 677  

 threeptcor_reap  
 
  
interpreted function, defined at contrib/correl.i   line 1049  

 threeptcor_sow  
 
  
interpreted function, defined at contrib/correl.i   line 999  

 threeptcor_work  
 
  
interpreted function, defined at contrib/correl.i   line 1011  

             timer, elapsed  
          or timer, elapsed, split  
 
     updates the ELAPSED and optionally SPLIT timing arrays.  These  
     arrays must each be of type array(double,3); the layout is  
     [cpu, system, wall], with all three times measured in seconds.  
     ELAPSED is updated to the total times elapsed since this copy  
     of Yorick started.  SPLIT is incremented by the difference between  
     the new values of ELAPSED and the values of ELAPSED on entry.  
     This feature allows for primitive code profiling by keeping  
     separate accounting of time usage in several categories, e.g.--  
        elapsed= total= cat1= cat2= cat3= array(double, 3);  
        timer, elapsed0;  
        elasped= elapsed0;  
        ... category 1 code ...  
        timer, elapsed, cat1;  
        ... category 2 code ...  
        timer, elapsed, cat2;  
        ... category 3 code ...  
        timer, elapsed, cat3;  
        ... more category 2 code ...  
        timer, elapsed, cat2;  
        timer, elapsed0, total;  
     The wall time is not absolutely reliable, owning to possible  
     rollover at midnight.  
builtin function, documented at i0/std.i   line 2772  

             timer_print, label1, split1, label2, split2, ...  
          or timer_print  
          or timer_print, label_total  
 
     prints out a timing summary for splits accumulated by timer.  
        timer_print, "category 1", cat1, "category 2", cat2,  
                     "category 3", cat3, "total", total;  
interpreted function, defined at i0/std.i   line 2800  

             timestamp()  
 
     returns string of the form "Sun Jan  3 15:14:13 1988" -- always  
     has 24 characters.  
builtin function, documented at i0/std.i   line 2765  

             to_corners(list, ni, nj)  
 
     convert a LIST of cell indices in an (NI-1)-by-(NJ-1)-by-(nk-1)  
     logically rectangular grid of cells into the list of  
     2-by-2-by-2-by-numberof(LIST) cell corner indices in the  
     corresponding NI-by-NJ-by-nk list of vertices.  
interpreted function, defined at i/slice3.i   line 488  

             to_db(signal, ref)  
          or to_db(signal)  
 
     return 20.*log10(abs(SIGNAL)/REF), the number of decibels  
     corresponding to the input SIGNAL.  REF defaults to 1.0.  
interpreted function, defined at i/filter.i   line 510  

 to_ecliptic  
 
  
interpreted function, defined at i/kepler.i   line 157  

             hsv= to_hsv(rgb)  
          or hsv= to_hsv([r,g,b])  
 
     return the HSV representation of the n-by-3 array of RGB colors  
     rgb: red, green, blue from 0 to 255  
     hsv: h= hue in degrees, red=0, green=120, blue=240  
          s= saturation from 0 (gray) to 1 (full hue)  
          v= value from 0 (black) to 1 (full intensity)  
          s= 1 - min(r,g,b)/max(r,g,b)  
          v= max(r,g,b)  
interpreted function, defined at i/color.i   line 111  

             to_phase(signal)  
          or to_phase(signal, 1)  
 
     return atan(SIGNAL.im,SIGNAL.re), the phase of the input SIGNAL.  
     If the second argument is present and non-0, the phase will be in  
     degrees; by default the phase is in radians.  
     To_phase attempts to unroll any jumps from -180 to +180 degrees  
     or vice-versa; zero phase will be taken somewhere near the middle  
     of the signal.  The external variable to_phase_eps controls the  
     details of this unrolling; you can turn off unrolling by setting  
     to_phase_eps=0.0 (initially it is 0.3).  
interpreted function, defined at i/filter.i   line 524  

             rgb= to_rgb(hsv)  
          or rgb= to_rgb([h,s,v])  
 
     return the RGB representation of the n-by-3 array of HSV colors  
     rgb: red, green, blue from 0 to 255  
     hsv: h= hue in degrees, red=0, green=120, blue=240  
          s= saturation from 0 (gray) to 1 (full hue)  
          v= value from 0 (black) to 1 (full intensity)  
          s= 1 - min(r,g,b)/max(r,g,b)  
          v= max(r,g,b)/255  
interpreted function, defined at i/color.i   line 68  

 tokenize_line  
 
  
interpreted function, defined at i/make.i   line 527  

             toy_mesh, filename  
 
     generates a toy mesh in the file FILENAME in order to be able to  
     play with the rezone function.  (FILENAME must be a string enclosed  
     in double quotes, of course.)  
interpreted function, defined at i/rezone.i   line 13  

             result= track_integ(nlist, transp, selfem, last)  
 
     integrates a transport equation by doing the sums:  
        transparency(i) = transparency(i-1) * TRANSP(i)  
        emissivity(i) = emissivity(i-1) * TRANSP(i) + SELFEM(i)  
     returning only the final values transparency(n) and emissivity(n).  
     The NLIST is a list of n values, so that many transport integrals  
     can be performed simultaneously; sum(NLIST) = numberof(TRANSP) =  
     numberof(SELFEM).  The result is 2-by-dimsof(NLIST).  
     If TRANSP is nil, result is dimsof(NLIST) sums of SELFEM.  
     If SELFEM is nil, result is dimsof(NLIST) products of TRANSP.  
     TRANSP and SELFEM may by 2D to do multigroup integrations  
     simultaneously.  By default, the group dimension is first, but  
     if LAST is non-nil and non-zero, the group dimension is second.  
     In either case, the result will be ngroup-by-2-by-dimsof(NLIST).  
     track_solve is the higher-level interface.  
interpreted function, defined at i0/hex.i   line 290  

             ray_paths= track_rays(rays, mesh, slimits)  
 
     returns array of Ray_Path structs representing the progress of  
     RAYS through the MESH between the given SLIMITS.  
interpreted function, defined at i0/drat.i   line 1242  

             nlist= track_reduce(c, s)  
          or nlist= track_reduce(c, s, rays, slimits)  
 
     compresses the C and S returns from the tracking routines (see  
     hex5_track) to the following form:  
       [cell1,cell2,cell3,..., cell1,cell2,cell3,..., ...]  
       [s1-s0,s2-s1,s3-s2,..., s1-s0,s2-s1,s3-s2,..., ...]  
     returning nlist as  
       [#hits, #hits, ...]  
     In this form, any negative #hits are combined with the preceding  
     positive values, and #hits=1 (indicating a miss) appear as #hits=0  
     in nlist.  Hence, nlist always has exactly Nrays elements.  
     If RAYS is supplied, it is used to force the dimensions of the  
     returned nlist to match the dimensions of RAYS (the value of RAYS  
     is never used).  The RAYS argument need not have the trailing 2  
     dimension, so if you specified RAYS as [P,Q] if the call to  
     hex5_track, you can use just P or Q as the RAYS argument to  
     track_reduce.  
     If SLIMITS is supplied, it should be [smin,smax] or [smin,smax]-  
     by-dimsof(nlist) in order to reject input S values outside the  
     specified limits.  The C list will be culled appropriately, and  
     the first and last returned ds values adjusted.  
     With a non-zero flip= keyword, the order of the elements of  
     C and S within each group of #hits is reversed, so that a  
     subsequent track_solve will track the ray backwards.  If you  
     use this, both the ray direction input to the tracking routine  
     and any SLIMITS argument here should refer to the reverse of  
     the ray you intend to track.  
interpreted function, defined at i0/hex.i   line 156  

             result= track_solve(nlist, c, s, akap, ekap, last)  
 
     integrates a transport equation for NLIST, C, and S returned  
     by track_reduce (and optionally c_adjust).  The RAYS argument  
     is used only to set the dimensions of the result.  AKAP and  
     EKAP are mesh-sized arrays of opacity and emissivity, respectively.  
     They may have an additional group dimension, as well.  The  
     units of AKAP are 1/length (where length is the unit of S),  
     while EKAP is (spectral) power per unit area (length^2), where  
     the power is what ever units you want the result in.  The  
     emission per unit volume of material is EKAP*AKAP; an optically  
     thick block of material emits EKAP per unit surface.  
     The NLIST is a list of n values, so that many transport integrals  
     can be performed simultaneously; sum(NLIST) = numberof(AKAP) =  
     numberof(EKAP).  The result is 2-by-dimsof(NLIST), where the  
     first element of the first index is the transmission fraction  
     through the entire ray path, and the second element of the  
     result is the self-emission along the ray, which has the same  
     units as EKAP.  
     If EKAP is nil, result is dimsof(NLIST) -- exactly the same as  
     the transparency (1st element of result) when both EKAP and AKAP  
     are specified.  
     If AKAP is nil, result is dimsof(NLIST).  In this case, EKAP  
     must have units of emission per unit volume instead of per unit  
     area; the result will be the sum of EKAP*S along each ray.  
     AKAP and EKAP may by 2D to do multigroup integrations  
     simultaneously.  By default, the group dimension is first, but  
     if LAST is non-nil and non-zero, the group dimension is last.  
     In either case, the result will be ngroup-by-2-by-dimsof(NLIST).  
     To use in conjuction with hex5_track, one might do this:  
        c= hex5_track(mesh, rays, s);  
        nlist= track_reduce(c, s, rays);  
        c_adjust, c, mesh;  // if necessary  
        result= track_solve(nlist, c, s, akap, ekap);  
interpreted function, defined at i0/hex.i   line 349  

             transpose(x)  
          or transpose(x, permutation1, permutation2, ...)  
 
     transpose the first and last dimensions of array X.  In the second  
     form, each PERMUTATION specifies a simple permutation of the  
     dimensions of X.  These permutations are compounded left to right  
     to determine the final permutation to be applied to the dimensions  
     of X.  Each PERMUTATION is either an integer or a 1D array of  
     integers.  A 1D array specifies a cyclic permutation of the  
     dimensions as follows: [3, 5, 2] moves the 3rd dimension to the  
     5th dimension, the 5th dimension to the 2nd dimension, and the 2nd  
     dimension to the 3rd dimension.  Non-positive numbers count from the  
     end of the dimension list of X, so that 0 is the final dimension,  
     -1 in the next to last, etc.  A scalar PERMUTATION is a shorthand  
     for a cyclic permutation of all of the dimensions of X.  The value  
     of the scalar is the dimension to which the 1st dimension will move.  
     Examples:  Let x have dimsof(x) equal [6, 1,2,3,4,5,6] in order  
        to be able to easily identify a dimension by its length. Then:  
        dimsof(x)                          == [6, 1,2,3,4,5,6]  
        dimsof(transpose(x))               == [6, 6,2,3,4,5,1]  
        dimsof(transpose(x,[1,2]))         == [6, 2,1,3,4,5,6]  
        dimsof(transpose(x,[1,0]))         == [6, 6,2,3,4,5,1]  
        dimsof(transpose(x,2))             == [6, 6,1,2,3,4,5]  
        dimsof(transpose(x,0))             == [6, 2,3,4,5,6,1]  
        dimsof(transpose(x,3))             == [6, 5,6,1,2,3,4]  
        dimsof(transpose(x,[4,6,3],[2,5])) == [6, 1,5,6,3,2,4]  
builtin function, documented at i0/std.i   line 1195  

 trapezoid  
 
  
interpreted function, defined at i/romberg.i   line 95  

 trapezoid_cosmo  
 
  
interpreted function, defined at contrib/cosmo.i   line 368  

             d2ydx2= tspline(tension, y, x)  
 
       -or-     yp= tspline(tension, d2ydx2, y, x, xp)  
       -or-     yp= tspline(tension, y, x, xp)  
     computes a tensioned spline curve passing through the points (X, Y).  
     The first argument, TENSION, is a positive number which determines  
     the "tension" in the spline.  In a cubic spline, the second derivative  
     of the spline function varies linearly between the points X.  In the  
     tensioned spline, the curvature is concentrated near the points X,  
     falling off at a rate proportional to the tension.  Between the points  
     of X, the function varies as:  
           y= C1*exp(k*x) + C2*exp(-k*x) + C3*x + C4  
     The parameter k is proportional to the TENSION; for k->0, the function  
     reduces to the cubic spline (a piecewise cubic function), while for  
     k->infinity, the function reduces to the piecewise linear function  
     connecting the points.  The TENSION argument may either be a scalar  
     value, in which case, k will be TENSION*(numberof(X)-1)/(max(X)-min(X))  
     in every interval of X, or TENSION may be an array of length one less  
     than the length of X, in which case the parameter k will be  
     abs(TENSION/X(dif)), possibly varying from one interval to the next.  
     You can use a variable tension to flatten "bumps" in one interval  
     without affecting nearby intervals.  Internally, tspline forces  
     k*X(dif) to lie between 0.01 and 100.0 in every interval, independent  
     of the value of TENSION.  Typically, the most dramatic variation  
     occurs between TENSION of 1.0 and 10.0.  
     With three arguments, Y and X, spline returns the derivatives D2YDX2 at  
     the points, an array of the same length as X and Y.  The D2YDX2 values  
     are chosen so that the tensioned spline function returned by the five  
     argument call will have a continuous first derivative.  
     The X array must be strictly monotonic; it may either increase or  
     decrease.  
     The values Y and the derivatives D2YDX2 uniquely determine a tensioned  
     spline function, whose value is returned in the five argument form.  
     In this form, tspline is analogous to the piecewise linear interpolator  
     interp; usually you will regard it as a continuous function of its  
     fifth (or fourth) argument, XP.  
     The XP array may have any dimensionality; the result YP will have  
     the same dimensions as XP.  
     The D2YDX2 argument will normally have been computed by a previous call  
     to the three argument tspline function.  If you will be computing the  
     values of the spline function for many sets of XP, use this five  
     argument form.  
     If you only want the tspline evaluated at a single set of XP, use the  
     four argument form.  This is equivalent to:  
          yp= tspline(tension, tspline(tension,y,x), y, x, xp)  
     The keywords DYDX1 and DYDX0 can be used to set the values of the  
     returned DYDX(1) and DYDX(0) -- the first and last values of the  
     slope, respectively.  If either is not specified or nil, the slope at  
     that end will be chosen so that the second derivative is zero there.  
     The function tspline (tensioned spline) gives an interpolation  
     function which lies between spline and interp, at the cost of  
     requiring you to specify another parameter (the tension).  
interpreted function, defined at i/spline.i   line 122  

             compute 2 pt correlation function in 1D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield1D(1024); u=fft(ui,[-1]).re;  
   res =twoptcor1D(u)  
   iso= 1 returns the azimuthally averaged corelation function  
   ft=  1 does the corelation via fft  
interpreted function, defined at contrib/correl.i   line 532  

             compute 2 pt correlation function in 2D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield2D(50); u=fft(ui,[-1,-1]).re;  
   res =twoptcor2D(u)  
   iso= 1 returns the azimuthally averaged corelation function  
   ft=  1 does the corelation via fft  
interpreted function, defined at contrib/correl.i   line 451  

             compute 2 pt correlation function in 3D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "Chris/randfield.i"  
   ui=genrandfield3D(64); u=fft(ui,[-1,-1,-1]).re;  
   res =twoptcor3D(u)  
   iso= 1 returns the azimuthally averaged corelation function  
   ft=  1 does the corelation via fft  
interpreted function, defined at contrib/correl.i   line 380  

             txtest  
             txtest, n  
 
     Print some tests of Yorick's plt command.  Start with the nth  
     page in the second form.  
interpreted function, defined at i/testg.i   line 527  

             typeof(object)  
 
     returns a string describing the type of object.  For the basic  
     data types, these are "char", "short", "int", "long", "float",  
     "double", "complex", "string", "pointer", "struct_instance",  
     "void", "range", "struct_definition", "function", "builtin",  
     "stream" (for a binary stream), and "text_stream".  
builtin function, documented at i0/std.i   line 399