Info: (octave) Variables

Info Catalog
octave: Data Containers
octave: Top
octave: Expressions
octave: Variables

 
 7 Variables
 ***********
 
 Variables let you give names to values and refer to them later.  You
 have already seen variables in many of the examples.  The name of a
 variable must be a sequence of letters, digits and underscores, but it
 may not begin with a digit.  Octave does not enforce a limit on the
 length of variable names, but it is seldom useful to have variables with
 names longer than about 30 characters.  The following are all valid
 variable names
 
      x
      x15
      __foo_bar_baz__
      fucnrdthsucngtagdjb
 
 However, names like ‘__foo_bar_baz__’ that begin and end with two
 underscores are understood to be reserved for internal use by Octave.
 You should not use them in code you write, except to access Octave’s
 documented internal variables and built-in symbolic constants.
 
    Case is significant in variable names.  The symbols ‘a’ and ‘A’ are
 distinct variables.
 
    A variable name is a valid expression by itself.  It represents the
 variable’s current value.  Variables are given new values with
 “assignment operators” and “increment operators”.  Assignment
 Expressions Assignment Ops.
 
    There is one built-in variable with a special meaning.  The ‘ans’
 variable always contains the result of the last computation, where the
 output wasn’t assigned to any variable.  The code ‘a = cos (pi)’ will
 assign the value -1 to the variable ‘a’, but will not change the value
 of ‘ans’.  However, the code ‘cos (pi)’ will set the value of ‘ans’ to
 -1.
 
    Variables in Octave do not have fixed types, so it is possible to
 first store a numeric value in a variable and then to later use the same
 name to hold a string value in the same program.  Variables may not be
 used before they have been given a value.  Doing so results in an error.
 
  -- Automatic Variable: ans
      The most recently computed result that was not explicitly assigned
      to a variable.
 
      For example, after the expression
 
           3^2 + 4^2
 
      is evaluated, the value returned by ‘ans’ is 25.
 
  -- : isvarname (NAME)
      Return true if NAME is a valid variable name.
 
      See also: iskeyword XREFiskeyword, exist XREFexist,
      who XREFwho.
 
  -- : VARNAME = genvarname (STR)
  -- : VARNAME = genvarname (STR, EXCLUSIONS)
      Create valid unique variable name(s) from STR.
 
      If STR is a cellstr, then a unique variable is created for each
      cell in STR.
 
           genvarname ({"foo", "foo"})
             ⇒
                {
                  [1,1] = foo
                  [1,2] = foo1
                }
 
      If EXCLUSIONS is given, then the variable(s) will be unique to each
      other and to EXCLUSIONS (EXCLUSIONS may be either a string or a
      cellstr).
 
           x = 3.141;
           genvarname ("x", who ())
             ⇒ x1
 
      Note that the result is a char array or cell array of strings, not
      the variables themselves.  To define a variable, ‘eval()’ can be
      used.  The following trivial example sets ‘x’ to ‘42’.
 
           name = genvarname ("x");
           eval ([name " = 42"]);
             ⇒ x =  42
 
      This can be useful for creating unique struct field names.
 
           x = struct ();
           for i = 1:3
             x.(genvarname ("a", fieldnames (x))) = i;
           endfor
             ⇒ x =
                {
                  a =  1
                  a1 =  2
                  a2 =  3
                }
 
      Since variable names may only contain letters, digits, and
      underscores, ‘genvarname’ will replace any sequence of disallowed
      characters with an underscore.  Also, variables may not begin with
      a digit; in this case an ‘x’ is added before the variable name.
 
      Variable names beginning and ending with two underscores "__" are
      valid, but they are used internally by Octave and should generally
      be avoided; therefore, ‘genvarname’ will not generate such names.
 
      ‘genvarname’ will also ensure that returned names do not clash with
      keywords such as "for" and "if".  A number will be appended if
      necessary.  Note, however, that this does *not* include function
      names such as "sin".  Such names should be included in EXCLUSIONS
      if necessary.
 
DONTPRINTYET       See also: isvarname XREFisvarname, *noteiskeyword:
DONTPRINTYET DONTPRINTYET       See also: isvarname XREFisvarname, iskeyword

      XREFiskeyword, exist XREFexist, who XREFwho, *noteDONTPRINTYET DONTPRINTYET       See also: isvarname XREFisvarname, iskeyword

      XREFiskeyword, exist XREFexist, who XREFwho, 
      tempname XREFtempname, eval XREFeval.
 
  -- : namelengthmax ()
      Return the MATLAB compatible maximum variable name length.
 
      Octave is capable of storing strings up to 2^{31} - 1 in length.
      However for MATLAB compatibility all variable, function, and
      structure field names should be shorter than the length returned by
      ‘namelengthmax’.  In particular, variables stored to a MATLAB file
      format (‘*.mat’) will have their names truncated to this length.
octave: Variables

Menu
