### 7.3 Status of Variables ¶

When creating simple one-shot programs it can be very convenient to see which variables are available at the prompt. The function `who` and its siblings `whos` and `whos_line_format` will show different information about what is in memory, as the following shows.

    str = "A random string";
    who
     -| Variables in the current scope:
     -|
     -| ans  str

who ¶
who `pattern …` ¶
who `option pattern …` ¶
`C =` who `(…)` ¶

  List currently defined variables matching the given patterns.

  Valid pattern syntax is the same as described for the `clear` command. If no patterns are supplied, all variables are listed.

  By default, only variables visible in the local scope are displayed.

  The following are valid options, but may not be combined.

  `global`

    List variables in the global scope rather than the current scope.

  `-regexp`

    The patterns are considered to be regular expressions when matching the variables to display. The same pattern syntax accepted by the `regexp` function is used.

  `-file`

    The next argument is treated as a filename. All variables found within the specified file are listed. No patterns are accepted when reading variables from a file.

  If called as a function, return a cell array of defined variable names matching the given patterns.

  See also: whos, isglobal, isvarname, exist, regexp.

whos ¶
whos `pattern …` ¶
whos `option pattern …` ¶
`S =` whos `("pattern", …)` ¶

  Provide detailed information on currently defined variables matching the given patterns.

  Options and pattern syntax are the same as for the `who` command.

  Extended information about each variable is summarized in a table with the following default entries.

  Attr

    Attributes of the listed variable. Possible attributes are:

    blank

      Variable in local scope

    `c`

      Variable of complex type.

    `f`

      Formal parameter (function argument).

    `g`

      Variable with global scope.

    `p`

      Persistent variable.

  Name

    The name of the variable.

  Size

    The logical size of the variable. A scalar is 1x1, a vector is 1xN or Nx1, a 2-D matrix is MxN.

  Bytes

    The amount of memory currently used to store the variable.

  Class

    The class of the variable. Examples include double, single, char, uint16, cell, and struct.

  The table can be customized to display more or less information through the function `whos_line_format`.

  If `whos` is called as a function, return a struct array of defined variable names matching the given patterns. Fields in the structure describing each variable are: name, size, bytes, class, global, sparse, complex, nesting, persistent.

  See also: who, whos_line_format.

`val =` whos_line_format `()` ¶
`old_val =` whos_line_format `(new_val)` ¶
`old_val =` whos_line_format `(new_val, "local")` ¶

  Query or set the format string used by the command `whos`.

  A full format string is:

      %[modifier]<command>[:width[:left-min[:balance]]];

  The following command sequences are available:

  `%a`

    Prints attributes of variables (c=complex, s=sparse, f=formal parameter, g=global, p=persistent).

  `%b`

    Prints number of bytes occupied by variables.

  `%c`

    Prints class names of variables.

  `%e`

    Prints elements held by variables.

  `%n`

    Prints variable names.

  `%s`

    Prints dimensions of variables.

  `%t`

    Prints type names of variables.

  Every command may also have an alignment modifier:

  `l`

    Left alignment.

  `r`

    Right alignment (default).

  `c`

    Column-aligned (only applicable to command %s).

  The `width` parameter is a positive integer specifying the minimum number of columns used for printing. No maximum is needed as the field will auto-expand as required.

  The parameters `left-min` and `balance` are only available when the column-aligned modifier is used with the command ‘`%s`’. `balance` specifies the column number within the field width which will be aligned between entries. Numbering starts from 0 which indicates the leftmost column. `left-min` specifies the minimum field width to the left of the specified balance column.

  The default format is:

      "  %la:5; %ln:6; %cs:16:6:1;  %rb:12;  %lc:-1;\n"

  When called from inside a function with the `"local"` option, the variable is changed locally for the function and any subroutines it calls. The original variable value is restored when exiting the function.

  See also: whos.

Instead of displaying which variables are in memory, it is possible to determine if a given variable is available. That way it is possible to alter the behavior of a program depending on the existence of a variable. The following example illustrates this.

    if (! exist ("meaning", "var"))
      disp ("The program has no 'meaning'");
    endif

`c =` exist `(name)` ¶
`c =` exist `(name, type)` ¶

  Check for the existence of name as a variable, function, file, directory, or class.

  The return code c is one of

  1

    name is a variable.

  2

    name is an absolute filename, an ordinary file in Octave’s `path`, or (after appending ‘`.m`’) a function file in Octave’s `path`.

  3

    name is a ‘`.oct`’ or ‘`.mex`’ file in Octave’s `path`.

  5

    name is a built-in function.

  7

    name is a directory.

  8

    name is a classdef class.

  103

    name is a function not associated with a file (entered on the command line).

  0

    name does not exist.

  If the optional argument type is supplied, check only for symbols of the specified type. Valid types are

  `"var"`

    Check only for variables.

  `"builtin"`

    Check only for built-in functions.

  `"dir"`

    Check only for directories.

  `"file"`

    Check only for files and directories.

  `"class"`

    Check only for classdef classes.

  If no type is given, and there are multiple possible matches for name, `exist` will return a code according to the following priority list: variable, built-in function, oct-file, directory, file, class.

  `exist` returns 2 if a regular file called name is present in Octave’s search path. For information about other types of files not on the search path use some combination of the functions `file_in_path` and `stat` instead.

  Programming Note: If name is implemented by a buggy .oct/.mex file, calling exist may cause Octave to crash. To maintain high performance, Octave trusts .oct/.mex files instead of sandboxing them.

  See also: file_in_loadpath, file_in_path, dir_in_loadpath, stat.

Usually Octave will manage the memory, but sometimes it can be practical to remove variables from memory manually. This is usually needed when working with large variables that fill a substantial part of the memory. On a computer that uses the IEEE 754 floating point format, the following program allocates a matrix that requires around 128 MB memory.

    large_matrix = zeros (4000, 4000);

Since having this variable in memory might slow down other computations, it can be necessary to remove it manually from memory. The `clear` or `clearvars` functions do this.

clear ¶
clear `pattern …` ¶
clear `options pattern …` ¶

  Delete the names matching the given patterns thereby freeing memory.

  The pattern may contain the following special characters:

  `?`

    Match any single character.

  `*`

    Match zero or more characters.

  `[ list ]`

    Match the list of characters specified by list. If the first character is `!` or `^`, match all characters except those specified by list. For example, the pattern `[a-zA-Z]` will match all lowercase and uppercase alphabetic characters. On Windows, square brackets are matched literally and are not used to group characters.

  For example, the command

      clear foo b*r

  clears the name `foo` and all names that begin with the letter ‘`b`’ and end with the letter ‘`r`’.

  If `clear` is called without any arguments, all user-defined variables are cleared from the current workspace (i.e., local variables). Any global variables present will no longer be visible in the current workspace, but they will continue to exist in the global workspace. Functions are unaffected by this form of `clear`.

  The following options are available in both long and short form

  `all, -all, -a`

    Clear all local and global user-defined variables, and all functions from the symbol table.

  `-exclusive, -x`

    Clear variables that do not match the following pattern.

  `functions, -functions, -f`

    Clear function names from the function symbol table. Persistent variables will be re-initialized to their default value unless the function has been locked in memory with `mlock`.

  `global, -global, -g`

    Clear global variable names.

  `variables, -variables, -v`

    Clear local variable names.

  `classes, -classes, -c`

    Clear the class structure table and all objects.

  `-regexp, -r`

    The pattern arguments are treated as regular expressions and any matches will be cleared.

  With the exception of `-exclusive` and `-regexp`, all long options can be used without the dash as well. Note that, aside from `-exclusive`, only one other option may appear. All options must appear before any patterns.

  Programming Notes: The command `clear name` only clears the variable name when both a variable and a (shadowed) function named name are currently defined. For example, suppose you have defined a function `foo`, and then hidden it by performing the assignment `foo = 2`. Executing the command `clear foo` once will clear the variable definition and restore the definition of `foo` as a function. Executing `clear foo` a second time will clear the function definition.

  When a local variable name, which is linked to a global variable, is cleared only the local copy of the variable is removed. The global copy is untouched and can be restored with `global global_varname`. Conversely, `clear -g global_varname` will remove both the local and global variables.

  See also: clearvars, who, whos, exist, mlock.

clearvars ¶
clearvars `pattern …` ¶
clearvars `-regexp pattern …` ¶
clearvars `… -except pattern …` ¶
clearvars `… -except -regexp pattern …` ¶
clearvars `-global …` ¶

  Delete the variables matching the given patterns from memory.

  The pattern may contain the following special characters:

  `?`

    Match any single character.

  `*`

    Match zero or more characters.

  `[ list ]`

    Match the list of characters specified by list. If the first character is `!` or `^`, match all characters except those specified by list. For example, the pattern `[a-zA-Z]` will match all lowercase and uppercase alphabetic characters.

  If the `-regexp` option is given then subsequent patterns are treated as regular expressions and any matches will be cleared.

  If the `-except` option is given then subsequent patterns select variables that will not be cleared.

  If the `-global` option is given then all patterns will be applied to global variables rather than local variables.

  When called with no arguments, `clearvars` deletes all local variables.

  Example Code:

  Clear all variables starting with `'x'` and the specific variable `"foobar"`

      clearvars x* foobar

  Clear the specific variable `"foobar"` and use regular expressions to clear all variables starting with `'x'` or `'y'`.

      clearvars foobar -regexp ^x ^y

  Clear all variables except for `"foobar"`

      clearvars -except foobar

  Clear all variables beginning with `"foo"`, except for those ending in `"bar"`

      clearvars foo* -except -regexp bar$

  See also: clear, who, whos, exist.

pack `()` ¶

  Consolidate workspace memory in MATLAB.

  This function is provided for compatibility, but does nothing in Octave.

  See also: clear.

Information about a function or variable such as its location in the file system can also be acquired from within Octave. This is usually only useful during development of programs, and not within a program.

type `name …` ¶
type `-q name …` ¶
`text =` type `("name", …)` ¶

  Display the contents of name which may be a file, function (m-file), variable, operator, or keyword.

  `type` normally prepends a header line describing the category of name such as function or variable; The `-q` option suppresses this behavior.

  If no output variable is used the contents are displayed on screen. Otherwise, a cell array of strings is returned, where each element corresponds to the contents of each requested function.

which `name …` ¶
`[str, …] =` which `('name', …)` ¶

  Display the type of each name.

  If name is defined from a function file, the full name of the file is also displayed.

  See also: help, lookfor.

what ¶
what `dir` ¶
`w =` what `(dir)` ¶

  List the Octave specific files in directory dir.

  If dir is not specified then the current directory is used.

  If a return argument is requested, the files found are returned in the structure w. The structure contains the following fields:

  path

    Full path to directory dir

  m

    Cell array of m-files

  mat

    Cell array of mat files

  mex

    Cell array of mex files

  oct

    Cell array of oct files

  mdl

    Cell array of mdl files

  slx

    Cell array of slx files

  p

    Cell array of p-files

  classes

    Cell array of class directories (`@classname/`)

  packages

    Cell array of package directories (`+pkgname/`)

  Compatibility Note: Octave does not support mdl, slx, and p files. `what` will always return an empty list for these categories.

  See also: which, ls, exist.