yorick banner

Home

Manual

Packages

Global Index

Keywords

Quick Reference

all functions - b

 
 
 
backup


 backup  
 
builtin function, documented at i0/std.i   line 1597  
SEE bookmark  
 
 
 
baget


             baget(file, varname)  
 
     read and return the (first) variable named VARNAME in FILE.  
     The obasis function opens files read-only.  If you want to update  
     a PFB Basis-generated PDB file without altering its "@decorated"  
     variable names, open the file with updateb, then use baset to  
     modify variables.  Since you can only change the entire variable  
     with baset, you may want to read it first with baget.  
interpreted function, defined at i/basfix.i   line 97  
SEE ALSO: obasis,   baset  
 
 
 
baset


             baset, file, varname, value  
 
     set the (first) variable named VARNAME in FILE to VALUE.  
     The obasis function opens files read-only.  If you want to update  
     a PFB Basis-generated PDB file without altering its "@decorated"  
     variable names, open the file with updateb, then use baset to  
     modify variables.  Since you can only change the entire variable  
     with baset, you may want to read it first with baget.  
interpreted function, defined at i/basfix.i   line 74  
SEE ALSO: obasis,   baget  
 
 
 
basfix_xopenb


 basfix_xopenb  
 
  
interpreted function, defined at i/basfix.i   line 120  
 
 
 
batch


             batch, 1  
             batch, 0  
             batch()  
 
     turns on, turns off, or tests for batch mode, respectively.  
     If yorick is started with the command line:  
        yorick -batch batch_include.i ...  
     then batch mode is turned on, the usual custom.i startup file is  
     skipped, and the file batch_include.i is parsed and executed.  The  
     -batch and batch_include.i command line arguments are removed from  
     the list returned by get_argv().  These must be the first two  
     arguments on the command line.  
     In batch mode, any error will terminate Yorick (as by the quit  
     function) rather than entering debug mode.  Also, any attempt to  
     read from the keyboard is an error.  
builtin function, documented at i0/std.i   line 2731  
SEE ALSO: process_argv,   get_argv,   set_idler  
 
 
 
bess_check


 bess_check  
 
  
interpreted function, defined at i/bessel.i   line 421  
 
 
 
bessi


             bessi(n, x)  
 
     returns Bessel function In of order N at points X.  N must be scalar.  
interpreted function, defined at i/bessel.i   line 287  
SEE ALSO: bessk,   bessj,   bessy,   bessi0,   bessi1  
 
 
 
bessi0


             bessi0(x)  
 
     returns Bessel function I0 at points X.  
interpreted function, defined at i/bessel.i   line 235  
SEE ALSO: bessi  
 
 
 
bessi1


             bessi1(x)  
 
     returns Bessel function I1 at points X.  
interpreted function, defined at i/bessel.i   line 260  
SEE ALSO: bessi  
 
 
 
bessj


             bessj(n, x)  
 
     returns Bessel function Jn of order N at points X.  N must be scalar.  
interpreted function, defined at i/bessel.i   line 74  
SEE ALSO: bessy,   bessi,   bessk,   bessj0,   bessj1  
 
 
 
bessj0


             bessj0(x)  
 
     returns Bessel function J0 at points X.  
interpreted function, defined at i/bessel.i   line 12  
SEE ALSO: bessj  
 
 
 
bessj1


             bessj1(x)  
 
     returns Bessel function J1 at points X.  
interpreted function, defined at i/bessel.i   line 43  
SEE ALSO: bessj  
 
 
 
bessk


             bessk(n, x)  
 
     returns Bessel function Kn of order N at points X.  N must be scalar.  
interpreted function, defined at i/bessel.i   line 389  
SEE ALSO: bessi,   bessj,   bessy,   bessi0,   bessi1  
 
 
 
bessk0


             bessk0(x)  
 
     returns Bessel function K0 at points X.  
interpreted function, defined at i/bessel.i   line 339  
SEE ALSO: bessk  
 
 
 
bessk1


             bessk1(x)  
 
     returns Bessel function K1 at points X.  
interpreted function, defined at i/bessel.i   line 364  
SEE ALSO: bessk  
 
 
 
bessy


             bessy(n, x)  
 
     returns Bessel function Yn of order N at points X.  N must be scalar.  
interpreted function, defined at i/bessel.i   line 209  
SEE ALSO: bessj,   bessi,   bessk,   bessy0,   bessy1  
 
 
 
bessy0


             bessy0(x)  
 
     returns Bessel function Y0 at points X.  
interpreted function, defined at i/bessel.i   line 146  
SEE ALSO: bessy  
 
 
 
bessy1


             bessy1(x)  
 
     returns Bessel function Y1 at points X.  
interpreted function, defined at i/bessel.i   line 177  
SEE ALSO: bessy  
 
 
 
best_rays


             best_rays(rays)  
 
     returns 5-element (x,y,z,theta,phi) 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 5.  
     The "best" coordinate system is the easiest to visualize:  
     (x,y,z) represents any point on the ray, while (theta,phi)  
     represents the ray direction in standard spherical coordinates  
     relative to the +z-axis.  Namely, theta is the angle from the  
     +z-direction to the ray direction (between 0 and pi), and phi is  
     the counterclockwise angle from the +x-axis to the projection of  
     the ray direction into the xy-plane, assuming xyz is a right-handed  
     coordinate system.  
     As a specification of a ray, this system is doubly redundant because  
     the point (x,y,z) could be any point on the ray, and the underlying  
     mesh through which the ray propagates is cylindrically symmetric about  
     the z-axis.  
     However, the slimits parameter -- used to specify the points along  
     a ray where the transport integration starts and stops -- is  
     measured from the point (x,y,z) specified as a part of the  
     (x,y,z,theta,phi) ray coordinate.  Thus, any change in the point  
     (x,y,z) on a ray must be accompanied by a corresponding change in  
     the slimits for that ray.  
interpreted function, defined at i/rays.i   line 40  
SEE ALSO: form_rays,   dirt_rays,   internal_rays,   get_s0,  
picture_rays  
 
 
 
beta


             beta(z,w)  
 
     returns the beta function gamma(z)gamma(w)/gamma(z+w)  
interpreted function, defined at i/gamma.i   line 74  
SEE ALSO: ln_gamma,   bico  
 
 
 
betai


             betai(a, b, x)  
 
    return I_x(a,x) = int[0 to x]{ du * u^(a-1)*(1-u)^(b-1) } / beta(a,b)  
    the incomplete beta function  
    
    betai(a,b,x) = 1 - betai(b,a,1-x)  
    
    Note that Student's t-distribution is  
      A(t|nu) = 1 - betai(0.5*nu,0.5, nu/(nu+t^2))  
    The F-distribution is  
      Q(F|nu1,nu2) = betai(0.5*nu2,0.5*nu1, nu2/(nu2+F*nu1))  
    
interpreted function, defined at i/gammp.i   line 135  
SEE ALSO: gammp,   gammq,   ln_gamma  
 
 
 
bico


             bico(n,k)  
 
     returns the binomial coefficient n!/(k!(n-k)!) as a double.  
interpreted function, defined at i/gamma.i   line 65  
SEE ALSO: ln_gamma,   beta  
 
 
 
binomialCDF


               
 
     CDF of binomial ditribution  
interpreted function, defined at contrib/countincell.i   line 88  
SEE ALSO:
 
 
 
binomialMoments


               
 
     Moments of binomial ditribution  
interpreted function, defined at contrib/countincell.i   line 98  
SEE ALSO:
 
 
 
binomialPDF


               
 
     PDF of binomial ditribution  
interpreted function, defined at contrib/countincell.i   line 70  
SEE ALSO:
 
 
 
bnu


 bnu  
 
  
interpreted function, defined at i/test2.i   line 311  
 
 
 
bookmark


             backup, f  
          or bmark= bookmark(f)  
             ...  
             backup, f, bmark  
 
     back up the text stream F, so that the next call to the read  
     function returns the same line as the previous call to read  
     (note that you can only back up one line).  If the optional  
     second argument BMARK is supplied, restores the state of the  
     file F to its state at the time the bookmark function was  
     called.  
     After a matching failure in read, use the single argument form  
     of backup to reread the line containing the matching failure.  
builtin function, documented at i0/std.i   line 1597  
SEE ALSO: read,   rdline,   open,   close  
 
 
 
bowtie


             map= bowtie(rt, zt)  
          or map= bowtie(rt, zt, ireg)  
 
     returns a "bowtie map" for the quadrilateral mesh defined by  
     RT, ZT, and (optionally) IREG.  If IREG is present, it should be  
     an integer array of the same dimensions as RT and ZT; its first  
     row and column are ignored, otherwise each non-zero element of  
     IREG marks an existing zone in the mesh.  (An IREG with one fewer  
     row and column than RT and ZT will also be accepted.)  If IREG  
     is omitted, every zone is presumed to exist.  
     The returned MAP is a 2-D integer array with one fewer row and  
     column than RT and ZT.  It's values have the following meanings:  
          2   marks a convex zone with positive area  
          1   marks a concave (boomerang) zone with positive area  
          0   marks a bowtied zone  
         -1   marks a concave (boomerang) zone with negative area  
         -2   marks a convex zone with negative area  
         -9   marks a non-existent zone  
     Use the nbow function to print the results.  
interpreted function, defined at i/bowtie.i   line 11  
SEE ALSO: nbow  
 
 
 
brighten


             brighten, factor  
          or brighten  
 
     brighten the current palette by the specified FACTOR.  
     The FACTOR is the slope of the transfer function for the color value  
     (see to_hsv for a description of the hsv color system); a value of  
     1.0 always remains 1.0, but values near 0.0 change by FACTOR.  
     FACTOR= 1.0 is a no-op.  The default factor is 4.0.  
interpreted function, defined at i/color.i   line 38  
SEE ALSO: dump_palette  
 
 
 
bs_integrate


             y= bs_integrate(derivative, y1, x, epsilon, dx1)  
 
     Bulirsch-Stoer integrator, otherwise identical to rk_integrate  
     routine. All of the options for rk_integrate work here as well.  
     Based on odeint from Numerical Recipes (Press, et.al.).  
     If the function you are trying to integrate is not very  
     smooth, or your X values are closely spaced, rk_integrate  
     will probably work better than bs_integrate.  
interpreted function, defined at i/rkutta.i   line 252  
SEE ALSO: bstoer,   rk_integrate,   rk_maxits,   rk_minstep,  
rk_maxstep,   rk_ngood,   rk_nbad,   rkdumb,   rk4  
 
 
 
bsplit


            T  bsplit  splits tensor tens into vectors defining the  
 
    unit sub tensors; works in dimensions 1 to 5.  
interpreted function, defined at contrib/split.i   line 21  
 
 
 
bsstep


 bsstep  
 
  
interpreted function, defined at i/rkutta.i   line 293  
 
 
 
bstoer


             y1= bstoer(derivative, y0,x0, x1,epsilon, dx0)  
 
     Bulirsch-Stoer integrator, otherwise identical to rkutta routine.  
     All of the options for rkutta (rk_nstore, etc.) work here as well.  
     If the function you are trying to integrate is not very  
     smooth, rkutta will probably work better than bstoer.  
interpreted function, defined at i/rkutta.i   line 274  
SEE ALSO: rkutta,   rk_nstore,   rk_maxits,   rk_minstep,  
rk_maxstep,   rk_ngood,   rk_nbad  
 
 
 
bucky


 bucky  
 
  
interpreted function, defined at i/plato.i   line 76  
 
 
 
build_dimlist


             build_dimlist, dimlist, next_argument  
 
     build a DIMLIST, as used in the array function.  Use like this:  
     func your_function(arg1, arg2, etc, dimlist, ..)  
     {  
       while (more_args()) build_dimlist, dimlist, next_arg();  
       ...  
     }  
     After this, DIMLIST will be an array of the form  
     [#dims, dim1, dim2, ...], compounded from the multiple arguments  
     in the same way as the array function.  If no DIMLIST arguments  
     given, DIMLIST will be [] instead of [0], which will act the  
     same in most situations.  If that possibility is unacceptible,  
     you may add  
       if (is_void(dimlist)) dimlist= [0];  
     after the while loop.  
interpreted function, defined at i/random.i   line 38  
 
 
 
butter


             butter(np, w)  
          or butter(np, w, wc, db)  
 
     return frequency response (amplitude) for Butterworth filter;  
     the parameters are the same as for fil_butter.  
interpreted function, defined at i/filter.i   line 565  
SEE ALSO: fil_butter  
 
 
 
button_build


             button_build(button)  
 
       -or- button_build(button, which)  
     Returns a Button structure instance, modified interactively to be at  
     the correct position and to have the correct box half widths, e.g.:  
        button= button_build(Button(text="label",y=initial_y))  
     You can either drag the center of the button to a new location  
     (press down near the center of the button, move the pointer to  
     where you want the center, and release at the new center point),  
     or press the "Set Box" or "Done" button.  In the "Set Box" mode,  
     you can either drag a new box over the button, or press "Set Center"  
     (to return to the original mode) or "Done" button.  
     Yorick has no way to determine the size of a text string produced  
     by the plt command, which is why you need to be able to adjust  
     the size of the box draawn around the text.  The idea is to use  
     button_build to get the buttons where you like, then put those  
     coordinates into the include file for the mouse-driven function  
     you are writing.  
     Also, the input BUTTON may be an array of buttons, and BUTTON(WHICH)  
     will be the one that is modified.  WHICH defaults to 1.  By using an  
     array of buttons, you can see all the other buttons in a group while  
     you adjust one.  
interpreted function, defined at i/button.i   line 21  
SEE ALSO: Button,   button_test,   button_plot  
 
 
 
button_plot


             button_plot, button1, button2, ...  
 
     plot the specified BUTTONs.  Each button in the list may be an array  
     of Button structs.  Void arguments are no-ops.  
interpreted function, defined at i/button.i   line 127  
SEE ALSO: Button,   button_build,   button_test  
 
 
 
button_test


             button_test(button, x, y)  
 
     true if the BUTTON contains NDC coordinates (X,Y).  
interpreted function, defined at i/button.i   line 158  
SEE ALSO: Button,   button_build,   button_plot  
 
 
 
bytscl


             bytscl(z)  
          or bytscl(z, top=max_byte, cmin=lower_cutoff, cmax=upper_cutoff)  
 
     returns a char array of the same shape as Z, with values linearly  
     scaled to the range 0 to one less than the current palette size.  
     If MAX_BYTE is specified, the scaled values will run from 0 to  
     MAX_BYTE instead.  
     If LOWER_CUTOFF and/or UPPER_CUTOFF are specified, Z values outside  
     this range are mapped to the cutoff value; otherwise the linear  
     scaling maps the extreme values of Z to 0 and MAX_BYTE.  
builtin function, documented at i0/graph.i   line 1276  
SEE ALSO: plf,   pli,   histeq_scale