status

[John W. Eaton]

Since releasing 2.0.5, I've been working on some small projects and
thinking about how to clean up Octave's internals a bit, so that it
will be easier to work with later, particularly if anyone ever tries
to implement an Octave to C++ translator (I would like to, but it is a
big project and some people may be more interested in seeing better
graphics or GUI tools first).

In any case, here are some of the things that are already done:

  * Commas in global statements are no longer special.  They are now
    treated as command separators.  This removes a conflict in the
    grammar and is consistent with the way Matlab behaves.  The
    variable `warn_comma_in_global_decl' has been eliminated.

  * It is now possible to declare static variables that retain their
    values across function calls.  For example,

      function ncall = f () static n = 0; ncall = ++n; endfunction

    defines a function that returns the number of times that it has
    been called.

  * Functions like quad, fsolve, and lsode can take either a function
    name or a simple function body as a string.  For example,

      quad ("sqrt (x)", 0, 1)

    is equivalent to

      function y = f (x) y = sqrt (x); endfunction
      quad ("f", 0, 1)

  * If the argument to eig() is symmetric, Octave uses the specialized
    Lapack subroutine for symmetric matrices for a significant
    increase in performance.

  * Octave now has a logical data type that should be mostly
    compatible with the logical data type that Matlab 5 apparently
    has.  A true value is represented by 1, and false value by 0.
    Comparison operations like <, <=, ==, >, >=, and != now return
    logical values.  Indexing operations that use zero-one style
    indexing must now use logical values.  You can use the new
    function logical() to convert a numeric value to a logical value.
    This avoids the need for the built-in variable
    `prefer_zero_one_indexing', so it has been removed.  Logical
    values are automatically converted to numeric values where
    appropriate.

  * If the argument to lsode that names the user-supplied function is
    a 2-element string array, the second element is taken as the name
    of the Jacobian function.  The named function should have the
    following form:

      JAC = f (X, T)

    where JAC is the Jacobian matrix of partial derivatives of the
    right-hand-side functions that define the set of differential
    equations with respect to the state vector X.  (Similar changes
    need to be made for other functions that require user-supplied
    functions).


I plan to start making snapshots again fairly soon so that people can
start using and testing some of these new features.

My next message will contain some more information about some of the
things I'm thinking about working on.  I'd appreciate any comments or
suggestions people might have.

Thanks,

jwe