section n of routines in global.i

Home Manual Packages Global Index Keywords Quick Reference | # all functions - n
nallof |
     nallof

    builtin function, documented at i0/std.i   line 742
SEE | allof
nameof |
                 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
SEE ALSO: | typeof
nbow |
                 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
SEE ALSO: | bowtie
nc_addrec |
                 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 493
SEE ALSO: | nc_create, nc_vardef, nc_enddef
nc_attrdef |
                 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 387
SEE ALSO: | nc_open, nc_dimsof, nc_create, nc_enddef, nc_attribute
nc_attribute |
                 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 506
SEE ALSO: | nc_open, nc_attrdef, nc_dimsof, nc_create, nc_enddef
nc_create |
                 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 230
SEE ALSO: | nc_open, nc_vardef, nc_attrdef, nc_enddef, nc_addrec, nc_attribute, nc_dimsof
nc_dimdef |
                 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 360
SEE ALSO: | nc_vardef
nc_dimsof |
                 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 531
SEE ALSO: | nc_open, nc_dimsof, nc_create, nc_enddef
nc_enddef |
                 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 416
SEE ALSO: | nc_create, nc_addrec, nc_open, nc_attrdef, nc_dimsof
nc_open |
                 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
SEE ALSO: | nc_create, nc_enddef, nc_attribute, nc_dimsof
nc_vardef |
                 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 244
SEE ALSO: | nc_create, nc_attrdef, nc_enddef, nc_addrec, nc_dimdef
new_makefile |
     new_makefile

    interpreted function, defined at i/make.i   line 213
nobc |
     nobc

    interpreted function, defined at i/demo1.i   line 93
noneof |
     noneof

    builtin function, documented at i0/std.i   line 742
SEE | allof
not_near |
     not_near

    interpreted function, defined at i/testp.i   line 908
nraphson |
                 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
SEE ALSO: | mnbrent, mxbrent, f_inverse
numberof |
                 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
SEE ALSO: | sizeof, dimsof, typeof, structof