all functions - n

 nallof  
 
builtin function, documented at i0/std.i   line 786  

             nameof(object)  
 
     If OBJECT is a function or a structure definition, returns the  
     name of the func or struct as it was defined (not necessarily  
     the name of the variable passed to the nameof function).  
builtin function, documented at i0/std.i   line 409  

             nbow, map  
          or nbow, file  
          or nbow, rt, zt  
          or nbow, rt, zt, ireg  
 
     prints information about topological oddities in a mesh.  
     MAP is a bowtie map as returned by the bowtie function.  
     FILE is a binary file containing rt, zt, and ireg arrays.  
     RT, ZT and IREG are 2-D arrays defining a quadrilateral mesh.  
     The information printed includes the zone index (corner with  
     the largest indices) of zones which are concave (boomerangs)  
     or bowtied, and of zones with negative area.  You can set  
     the global variable nbow_negative to 1 to reverse the default  
     sense of positive area.  By default, only the first 10 zones  
     in each category are printed; use the all=1 keyword argument  
     to print a complete (and maybe very long) list.  
interpreted function, defined at i/bowtie.i   line 77  

             nc_addrec, f, time  
 
       -or- nc_addrec, f  
     adds a new record to the netCDF file F at time TIME.  
interpreted function, defined at i/netcdf.i   line 501  

             nc_attrdef, ncf, attr_name, var_name, value  
 
     sets the value of the netCDF attribute ATTR_NAME associated  
     with variable VAR_NAME to VALUE (note that the data type of VALUE  
     becomes the data type of the attribute).  
     The NCF is the structure returned by nc_create; nc_attrdef  
     must be called prior to nc_enddef, which actually writes the  
     attribute data to the file.  
     If VAR_NAME is omitted, ATTR_NAME refers to the whole file.  
interpreted function, defined at i/netcdf.i   line 395  

             value= nc_attribute(attr_name, var_name)  
 
     gets the value of the netCDF attribute ATTR_NAME associated  
     with variable VAR_NAME, or nil if none.  Uses the external  
     variable nc_file set by nc_open.  
     If VAR_NAME is omitted, ATTR_NAME refers to the whole file,  
     and is retrieved (if present) from the nc_file.attrs variable.  
interpreted function, defined at i/netcdf.i   line 514  

             ncf= nc_create(filename)  
 
     creates a netCDF file FILENAME.  
     After this call, use nc_vardef to declare the netCDF variables.  
     Then use nc_enddef to write the netCDF self-descriptive  
     information.  Only after this are you free to actually write data.  
interpreted function, defined at i/netcdf.i   line 238  

             nc_dimdef, ncf, dim_name, size  
 
       -or- nc_dimdef, ncf, dim_name, "unlimited"  
     define a named dimension.  The SIZE parameter is the length of  
     the dimension, or the string "unlimited" for the unlimited  
     dimension.  (The numerical value 0 is the same as "unlimited".)  
     You can also define named dimensions implicitly using nc_vardef.  
interpreted function, defined at i/netcdf.i   line 368  

             def_string= nc_dimsof(var_name)  
 
     returns the dimension list of a netCDF variable VAR_NAME in symbolic  
     form, i.e.- using the netCDF dimension names.  This requires the  
     nc_file external variable set by nc_open.  
interpreted function, defined at i/netcdf.i   line 539  

             f= nc_enddef(ncf)  
 
     creates netCDF file NCF (returned by nc_create), and writes the self-  
     descriptive information.  Returns the ordinary Yorick file object  
     corresponding to the new file.  You are then free to write variables,  
     or use the save or nc_addrec functions.  
interpreted function, defined at i/netcdf.i   line 424  

             f= nc_open(filename, mode)  
 
     opens a netCDF file FILENAME for reading or update as specified  
     by MODE, which defaults to "rb".  Attributes and dimension names  
     can be found in the three external variables nc_dims (an array of  
     type NC_dim), nc_attrs (an array of type NC_attr), and nc_vars  
     (an array of type NC_var) after this call.  
     MODE should be either "rb" or "r+b"; nothing else makes sense.  
     If FILENAME is an array of strings, exactly those files will be  
     opened as a family (if possible).  Note that nc_open("myfile00")  
     potentially opens myfile01, myfile02, and so on, as for openb,  
     but that nc_open(["myfile00"]) opens myfile00 only.  
interpreted function, defined at i/netcdf.i   line 36  

             nc_vardef, ncf, name, type, dims, record=0/1  
 
       -or- nc_vardef, ncf, name, type, record=0/1  
       -or- nc_vardef, ncf, name, template=template, record=0/1  
     define a variable in the NCF (returned by nc_create) with name  
     NAME, type TYPE (as returned by typeof or structof), and dimensions  
     DIMS (as returned by dimsof).  The template= keyword may be used  
     instead of type and dims; the type and dims will be those of the  
     TEMPLATE.  If dims is not specified, a scalar is assumed.  If the  
     record= keyword is present and non-zero, the variable is a record  
     variable; otherwise it is a non-record variable.  
     You can use the dimnames= keyword to write specific dimension  
     names into the netCDF file.  These are not useful to Yorick, but  
     other codes may require them.  If two variables share a dimension  
     name, the corresponding dimension must have the same length.  For  
     example:  
       nc_vardef, ncf, "theta", double, [1,nlat], dimnames=["latitude"]  
       nc_vardef, ncf, "phi", double, [1,nlong], dimnames=["longitude"]  
       nc_vardef, ncf, "elevation", double,  
                  dimnames=["latitude","longitude"]  
     A dimension name of "" lets Yorick invent a fake dimension name,  
     as it does by default.  If dimnames= is present and the lengths  
     of the dimensions have previously been defined, then the DIMS  
     parameter is unnecessary, as in the "elevation" array in the example.  
     You can use the nc_dimdef function to define a named dimension size  
     before you define any variables with that dimension.  
interpreted function, defined at i/netcdf.i   line 252  

 new_makefile  
 
  
interpreted function, defined at i/make.i   line 227  

 nobc  
 
  
interpreted function, defined at i/demo1.i   line 93  

 noneof  
 
builtin function, documented at i0/std.i   line 786  

 not_near  
 
  
interpreted function, defined at i/testp.i   line 908  

             nraphson(f_and_dfdx, x0, x1)  
          or nraphson(f_and_dfdx, x0, x1, xerr)  
 
     Find a root of a function by Newton-Raphson iteration, backed  
     up by bisection if the convergence seems poor.  The subroutine  
     F_AND_DFDX must be defined as:  
          func F_AND_DFDX (x, &f, &dfdx)  
     returning both the function value f(x) and derivative dfdx(x).  
     If F_AND_DFDX always returns dfdx==0, nraphson uses bisection.  
     The value of x is constrained to lie within the interval from  
     X0 to X1; the function values at these two points must have  
     opposite sign.  The iteration stops when the root is known to  
     within XERR, or to machine precision if XERR is nil or zero.  
     f_inverse is a "vectorized" version of nraphson.  
     Based on rtsafe from Press, et. al. Numerical Recipes, Ch 9.  
interpreted function, defined at i/roots.i   line 21  

             numberof(object)  
 
     returns the number of elements if object is an array, or 0 if not.  
builtin function, documented at i0/std.i   line 393