Summary of important user-visible changes for version 3.2:
---------------------------------------------------------

 ** Compatibility with Matlab graphics is much better now.  

    The hggroup object and associated listener callback functions have
    been added allowing the inclusion of group objects. Data sources
    have been added to these group objects such that

           x = 0:0.1:10;
           y = sin (x);
           plot (x, y, "ydatasource", "y");
           for i = 1 : 100
             pause(0.1)
             y = sin (x + 0.1 * i);
             refreshdata();
           endfor

    works as expected. This capability has be used to introduce stem-series,
    bar-series, etc objects for better Matlab compatibility.

 ** Experimental OpenGL/FLTK based backend to replace gnuplot

    An experimental backend to replace the gnuplot backend has been
    written based on FLTK. This backend is off by default. You can
    switch to using this  with the command

        backend ("fltk")

    for all future figures or for a particular figure with the command

        backend (h, "fltk")

    where "h" is a valid figure handle.

 ** Eliminate the functions for direct access to gnuplot from Octave.
    The functions __gnuplot_plot__, __gnuplot_set__, __gnuplot_raw__,
     __gnuplot_show__, __gnuplot_replot__, __gnuplot_splot__,
     __gnuplot_save_data__  and __gnuplot_send_inline_data__ have been
    removed from Octave. These function were incompatible with the high
    level graphics handle code.

 ** The fsolve function now accepts an option structure argument (see
    also the optimset function).
    The INFO values returned from fsolve have changed to be compatible
    with Matlab's fsolve function.

 ** Object Oriented Programming

    Octave now includes OOP features and the user can create their 
    own class objects and overloaded functions and operators. For
    example, all methods of a class called "myclass" will be found in 
    a directory "@myclass" on the users path. The class specific versions
    of functions and operators take precedence over the generic versions
    of these functions. See the Octave manual for more details.

 ** Block comments
    Commented code can be between matching "%{" and "%}" markers, even
    if the commented code spans several line. This allows blocks code
    to be commented, without needing to comment each line. For
    example, 

    function y = func (x)
      y = 2 * x;
    %{
      y += 1;
    %}
    endfunction

    the line "y += 1;" will not be executed.
  
 ** Removed the Control, Finance and Quaternions toolboxes
    These toolboxes have been removed and ported to octave-forge, and
    they are specialized toolboxes that not all users need. These
    functions can be reinstalled use the Octave package manager (see
    the pkg function) and the packages available at

    http://octave.sourceforge.net/packages.html

 ** The imwrite and imread function have been included in Octave based
    on the GraphicsMagick library.

 ** Special treatment in the parser of expressions like "a' * b". In
    these cases the transpose is no longer explicitly formed and BLAS
    libraries are called with the transpose flagged. This significantly  
    improves the speed.

 ** Single Precision data type
    Octave now includes a single precision data type. Single precision
    variables can be created with the "single" command, or from
    function like ones, etc. For example

    single (1)
    ones (2, 2, "single")
    zeros (2, 2, "single")
    eye (2, 2, "single")
    Inf (2, 2, "single")
    NaN (2, 2, "single")
    NA (2, 2, "single")

    all create single precision variables. Mixed double/single
    precision operators and functions return single precision
    types. As a consequence of this addition to Octave the internal
    representation of the double precision NA value has changed, and
    so users that make use of data generated by Octave with R or
    visa-versa are warned that compatibility might not be assured.

 ** Improved array indexing
    The underlying code used for indexing of arrays has been completely
    rewritten and so the indexing of arrays is now significantly faster.

See NEWS.3 for old news.