functions in std.i - t

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

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

             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 2639  

             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 2667  

             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 2632  

             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 1064  

             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