view NEWS @ 15489:481417a57a2d

improve sign and signbit docs * mappers.cc (Fsign): Note sign (-0) is 0. Add @seealso for signbit. (Fsignbit): Add @seealso for sign.
author John W. Eaton <jwe@octave.org>
date Thu, 04 Oct 2012 10:20:59 -0400
parents 6823ad7a25b1
children 7a0a202fedfe
line wrap: on
line source

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

 ** A new GUI is now available with Octave.

 ** Warning states may now be set temporarily, until the end of the
    current function, using the syntax

      warning STATE ID "local"

    in which STATE may be "on", "off", or "error".  Changes to warning
    states that are set locally affect the current function and all
    functions called from the current scope.  The previous warning state
    is restored on return from the current function.  The "local"
    option is ignored if used in the top-level workspace.

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

 ** Octave now supports nested functions with scoping rules that are
    compatible with Matlab.  A nested function is one declared and defined
    within the body of another function.  The nested function is only
    accessible from within the enclosing function which makes it one
    method for making private functions whose names do not conflict with those
    in the global namespace (See also subfunctions and private functions).
    In addition, variables in the enclosing function are visible within the
    nested function.  This makes it possible to have a pseudo-global variable
    which can be seen by a group of functions, but which is not visible in
    the global namespace.
    
    Example:
    function outerfunc (...)
      ...
      function nested1 (...)
        ...
        function nested2 (...)
           ...
        endfunction
      endfunction

      function nested3 (...)
        ...
      endfunction
    endfunction

 ** 'emptymatch', 'noemptymatch' options added to regular expressions.

    With this addition Octave now accepts the entire set of Matlab options
    for regular expressions.  'noemptymatch' is the default, but 'emptymatch'
    has certain uses where you need to match an assertion rather than actual
    characters.  For example, 

    regexprep ('World', '^', 'Hello ', 'emptymatch')
      => Hello World

    where the pattern is actually the assertion '^' or start-of-line.

 ** For compatibility with Matlab, the regexp, regexpi, and regexprep
    functions now process backslash escapes in single-quoted pattern
    strings.  In addition, the regexprep function now processes backslash
    escapes in single-quoted replacement strings.

 ** Redundant terminal comma accepted by parser

    A redundant terminal comma is now accepted in matrix
    definitions which allows writing code such as 

    [a,...
     b,...
     c,...
    ] = deal (1,2,3)

 ** Warning IDs renamed:

    Octave:array-as-scalar => Octave:array-to-scalar
    Octave:array-as-vector => Octave:array-to-vector

 ** The colormap function now provides new options--"list", "register",
    and "unregister"--to list all available colormap functions, and to
    add or remove a function name from the list of known colormap
    functions.  Packages that implement extra colormaps should use these
    commands with PKG_ADD and PKG_DEL statements.

 ** The datevec function has been extended for better Matlab compatibility.
    It now accepts string inputs in the following numerical formats: 12, 21,
    22, 26, 29, 31.  This is undocumented, but verifiable, Matlab behavior.
    In addition, the default for formats which do not specify a date is
    January 1st of the current year.  The previous default was the current day,
    month, and year.  This may produce changes in existing scripts.

 ** The default name of the Octave crash dump file is now called
    octave-workspace instead of octave-core.
      
 ** Other new functions added in 3.8.0:

      betaincinv   erfcinv      polyeig      shrinkfaces 
      cmpermute    findfigs     splinefit
      cmunique     fminsearch   tetramesh
      colorcube    lines        rgbplot     
 ** Deprecated functions.

    The following functions were deprecated in Octave 3.4 and have been
    removed from Octave 3.8.
                                           
      autocor    dispatch              is_global    strerror
      autocov    fstat                 krylovb      values  
      betai      gammai                perror               
      cellidx    glpkmex               replot               
      cquad      is_duplicate_entry    saveimage            
      
    The following functions have been deprecated in Octave 3.8 and will
    be removed from Octave 3.12 (or whatever version is the second major
    release after 3.8):

      <none yet>

    The following keywords have been deprecated in Octave 3.8 and will
    be removed from Octave 3.12 (or whatever version is the second major
    release after 3.8):

      static

    The following configuration variables have been deprecated in Octave
    3.8 and will be removed from Octave 3.12 (or whatever version is the
    second major release after 3.8):

      CC_VERSION  (now GCC_VERSION)
      CXX_VERSION (now GXX_VERSION)


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

 ** The PCRE library is now required to build Octave.  If a pre-compiled
    package does not exist for your system, you can find PCRE sources
    at http://www.pcre.org

 ** The ARPACK library is no longer distributed with Octave.
    If you need the eigs or svds functions you must provide an
    external ARPACK through a package manager or by compiling it
    yourself.  If a pre-compiled package does not exist for your system,
    you can find the current ARPACK sources at
    http://forge.scilab.org/index.php/p/arpack-ng

 ** Many of Octave's binary operators (.*, .^, +, -, ...) now perform
    automatic broadcasting for array operations which allows you to use
    operator notation instead of calling bsxfun or expanding arrays (and
    unnecessarily wasting memory) with repmat or similar idioms.  For
    example, to scale the columns of a matrix by the elements of a row
    vector, you may now write

      rv .* M

    In this expression, the number of elements of rv must match the
    number of columns of M.  The following operators are affected:

      plus      +  .+
      minus     -  .-
      times     .*
      rdivide   ./
      ldivide   .\
      power     .^  .**
      lt        <
      le        <=
      eq        ==
      gt        >
      ge        >=
      ne        !=  ~=
      and       &
      or        |
      atan2
      hypot
      max
      min
      mod
      rem
      xor

    additionally, since the A op= B assignment operators are equivalent
    to A = A op B, the following operators are also affected:

      +=  -=  .+=  .-=  .*=  ./=  .\=  .^=  .**=  &=  |=

    See the "Broadcasting" section in the new "Vectorization and Faster
    Code Execution" chapter of the manual for more details.

 ** Octave now features a profiler, thanks to the work of Daniel Kraft
    under the Google Summer of Code mentorship program.  The manual has
    been updated to reflect this addition.  The new user-visible
    functions are profile, profshow, and profexplore.

 ** Overhaul of statistical distribution functions

    Functions now return "single" outputs for inputs of class "single".

    75% reduction in memory usage through use of logical indexing.

    Random sample functions now use the same syntax as rand and accept
    a comma separated list of dimensions or a dimension vector.

    Functions have been made Matlab-compatible with regard to special
    cases (probability on boundaries, probabilities for values outside
    distribution, etc.).  This may cause subtle changes to existing
    scripts.

    negative binomial function has been extended to real, non-integer
    inputs.  The discrete_inv function now returns v(1) for 0 instead of
    NaN.  The nbincdf function has been recoded to use a closed form
    solution with betainc.

 ** strread, textscan, and textread have been completely revamped.

    They now support nearly all Matlab functionality including:

      * Matlab-compatible whitespace and delimiter defaults

      * Matlab-compatible options: 'whitespace', treatasempty', format
        string repeat count, user-specified comment style, uneven-length
        output arrays, %n and %u conversion specifiers (provisionally)

 ** All .m string functions have been modified for better performance or
    greater Matlab compatibility.  Performance gains of 15X-30X have
    been demonstrated.  Operations on cell array of strings no longer pay
    quite as high a penalty as those on 2-D character arrays.

      deblank:  Now requires character or cellstr input.

      strtrim:  Now requires character or cellstr input.
                No longer trims nulls ("\0") from string for Matlab
                compatibility.

      strmatch: Follows documentation precisely and ignores trailing spaces
                in pattern and in string.  Note that this is documented
                Matlab behavior but the implementation apparently does
                not always follow it.

      substr:   Now possible to specify a negative LEN option which
                extracts to within LEN of the end of the string.

      strtok:   Now accepts cellstr input.

      base2dec, bin2dec, hex2dec:
                Now accept cellstr inputs.

      dec2base, dec2bin, dec2hex:
                Now accept cellstr inputs.

      index, rindex:
                Now accept 2-D character array input.

      strsplit: Now accepts 2-D character array input.

 ** Geometry functions derived from Qhull (convhull, delaunay, voronoi)
    have been revamped.  The options passed to the underlying qhull
    command have been changed for better results or for Matlab
    compatibility.

      convhull: Default options are "Qt" for 2D, 3D, 4D inputs
                Default options are "Qt Qx" for 5D and higher

      delaunay: Default options are "Qt Qbb Qc Qz" for 2D and 3D inputs
                Default options are "Qt Qbb Qc Qx" for 4D and higher

      voronoi:  No default arguments

 ** Date/Time functions updated.  Millisecond support with FFF format
    string now supported.

    datestr: Numerical formats 21, 22, 29 changed to match Matlab.
             Now accepts cellstr input.

 ** The following warning IDs have been removed:

      Octave:associativity-change
      Octave:complex-cmp-ops
      Octave:empty-list-elements
      Octave:fortran-indexing
      Octave:precedence-change
      
 ** The warning ID Octave:string-concat has been renamed to
    Octave:mixed-string-concat.

 ** Octave now includes the following Matlab-compatible preference
    functions:

      addpref  getpref  ispref  rmpref  setpref

 ** The following Matlab-compatible handle graphics functions have been
    added:

      guidata         uipanel        uitoolbar
      guihandles      uipushtool     uiwait
      uicontextmenu   uiresume       waitfor
      uicontrol       uitoggletool

    The uiXXX functions above are experimental.

    Except for uiwait and uiresume, the uiXXX functions are not
    supported with the FLTK+OpenGL graphics toolkit.

    The gnuplot graphics toolkit does not support any of the uiXXX
    functions nor the waitfor function.

 ** New keyword parfor (parallel for loop) is now recognized as a valid
    keyword.  Implementation, however, is still mapped to an ordinary
    for loop.

 ** Other new functions added in 3.6.0:

      bicg                       nthargout                   usejava
      is_dq_string               narginchk                   waitbar
      is_sq_string               python                      zscore
      is_function_handle         register_graphics_toolkit 
      loaded_graphics_toolkits   recycle                   

 ** Deprecated functions.

    The following functions were deprecated in Octave 3.2 and have been
    removed from Octave 3.6.
                                           
      create_set          spcholinv    splu   
      dmult               spcumprod    spmax
      iscommand           spcumsum     spmin
      israwcommand        spdet        spprod
      lchol               spdiag       spqr
      loadimage           spfind       spsum
      mark_as_command     sphcat       spsumsq
      mark_as_rawcommand  spinv        spvcat 
      spatan2             spkron       str2mat
      spchol              splchol      unmark_command
      spchol2inv          split        unmark_rawcommand

    The following functions have been deprecated in Octave 3.6 and will
    be removed from Octave 3.10 (or whatever version is the second major
    release after 3.6):

      cut                is_duplicate_entry
      cor                polyderiv
      corrcoef           shell_cmd 
      __error_text__     studentize
      error_text         sylvester_matrix

 ** The following functions have been modified for Matlab compatibility:

      randperm

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

 ** Octave 3.4.3 is a bug fixing release.
     
Summary of important user-visible changes for version 3.4.2:
-----------------------------------------------------------

 ** Octave 3.4.2 fixes some minor installation problems that affected
    version 3.4.1.

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

 ** Octave 3.4.1 is primarily a bug fixing release.

 ** IMPORTANT note about binary incompatibility in this release:

    Binary compatibility for all 3.4.x releases was originally planned,
    but this is impossible for the 3.4.1 release due to a bug in the way
    shared libraries were built in Octave 3.4.0.  Because of this bug,
    .oct files built for Octave 3.4.0 must be recompiled before they
    will work with Octave 3.4.1.

    Given that there would be binary incompatibilities with shared
    libraries going from Octave 3.4.0 to 3.4.1, the following
    incompatible changes were also made in this release:

      * The Perl Compatible Regular Expression (PCRE) library is now
        required to build Octave.

      * Octave's libraries and .oct files are now installed in
        subdirectories of $libdir instead of $libexecdir.

    Any future Octave 3.4.x release versions should remain binary
    compatible with Octave 3.4.1 as proper library versioning is now
    being used as recommended by the libtool manual.

 ** The following functions have been deprecated in Octave 3.4.1 and will
    be removed from Octave 3.8 (or whatever version is the second major
    release after 3.4):

      cquad  is_duplicate_entry  perror  strerror

 ** The following functions are new in 3.4.1:

      colstyle  gmres  iscolumn  isrow  mgorth  nproc  rectangle

 ** The get_forge_pkg function is now private.

 ** The rectangle_lw, rectangle_sw, triangle_lw, and triangle_sw
    functions are now private.

 ** The logistic_regression_derivatives and logistic_regression_likelihood
    functions are now private.

 ** ChangeLog files in the Octave sources are no longer maintained
    by hand.  Instead, there is a single ChangeLog file generated from
    the Mercurial version control commit messages.  Older ChangeLog
    information can be found in the etc/OLD-ChangeLogs directory in the
    source distribution.

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

 ** BLAS and LAPACK libraries are now required to build Octave.  The
    subset of the reference BLAS and LAPACK libraries has been removed
    from the Octave sources.
  
 ** The ARPACK library is now distributed with Octave so it no longer
    needs to be available as an external dependency when building
    Octave.

 ** The `lookup' function was extended to be more useful for
    general-purpose binary searching.  Using this improvement, the
    ismember function was rewritten for significantly better
    performance.

 ** Real, integer and logical matrices, when used in indexing, will now
    cache the internal index_vector value (zero-based indices) when
    successfully used as indices, eliminating the conversion penalty for
    subsequent indexing by the same matrix.  In particular, this means it
    is no longer needed to avoid repeated indexing by logical arrays
    using find for performance reasons.

 ** Logical matrices are now treated more efficiently when used as
    indices.  Octave will keep the index as a logical mask unless the
    ratio of true elements is small enough, using a specialized
    code.  Previously, all logical matrices were always first converted
    to index vectors.  This results in savings in both memory and
    computing time.

 ** The `sub2ind' and `ind2sub' functions were reimplemented as compiled
    functions for better performance.  These functions are now faster,
    can deliver more economized results for ranges, and can reuse the
    index cache mechanism described in previous paragraph.

 ** The built-in function equivalents to associative operators (`plus',
    `times', `mtimes', `and', and `or') have been extended to accept
    multiple arguments.  This is especially useful for summing
    (multiplying, etc.) lists of objects (of possibly distinct types):
   
      matrix_sum = plus (matrix_list{:});

 ** An FTP object type based on libcurl has been implemented.  These
    objects allow ftp connections, downloads and uploads to be
    managed.  For example,

      fp = ftp ("ftp.octave.org);
      cd (fp, "gnu/octave");
      mget (fp, "octave-3.2.3.tar.bz2");
      close (fp);

 ** The default behavior of `assert (observed, expected)' has been
    relaxed to employ less strict checking that does not require the
    internals of the values to match.  This avoids previously valid
    tests from breaking due to new internal classes introduced in future
    Octave versions.

    For instance, all of these assertions were true in Octave 3.0.x
    but false in 3.2.x due to new optimizations and improvements:

      assert (2*linspace (1, 5, 5), 2*(1:5))
      assert (zeros (0, 0), [])
      assert (2*ones (1, 5), (2) (ones (1,5)))

 ** The behavior of library functions `ismatrix', `issquare', and
    `issymmetric' has been changed for better consistency.
    
    * The `ismatrix' function now returns true for all numeric,
      logical and character 2-D or N-D matrices.  Previously, `ismatrix' 
      returned false if the first or second dimension was zero.
      Hence, `ismatrix ([])' was false, 
      while `ismatrix (zeros (1,2,0))' was true.

    * The `issquare' function now returns a logical scalar, and is
      equivalent to the expression

        ismatrix (x) && ndims (x) == 2 && rows (x) == columns (x)

      The dimension is no longer returned.  As a result, `issquare ([])'
      now yields true.
    
    * The `issymmetric' function now checks for symmetry instead of
      Hermitianness.  For the latter, ishermitian was created.  Also,
      logical scalar is returned rather than the dimension, so
      `issymmetric ([])' is now true.
      
 ** Function handles are now aware of overloaded functions.  If a
    function is overloaded, the handle determines at the time of its
    reference which function to call.  A non-overloaded version does not
    need to exist.

 ** Overloading functions for built-in classes (double, int8, cell,
    etc.) is now compatible with Matlab.

 ** Function handles can now be compared with the == and != operators,
    as well as the `isequal' function.

 ** Performance of concatenation (using []) and the functions `cat',
    `horzcat', and `vertcat' has been improved for multidimensional
    arrays.

 ** The operation-assignment operators +=, -=, *= and /= now behave more
    efficiently in certain cases.  For instance, if M is a matrix and S a
    scalar, then the statement

      M += S;
 
    will operate on M's data in-place if it is not shared by another
    variable, usually increasing both time and memory efficiency.
    
    Only selected common combinations are affected, namely:
    
      matrix += matrix
      matrix -= matrix
      matrix .*= matrix
      matrix ./= matrix

      matrix += scalar
      matrix -= scalar
      matrix *= scalar
      matrix /= scalar

      logical matrix |= logical matrix
      logical matrix &= logical matrix

    where matrix and scalar belong to the same class.  The left-hand
    side must be a simple variable reference.

    Moreover, when unary operators occur in expressions, Octave will
    also try to do the operation in-place if it's argument is a
    temporary expression.

 ** The effect of comparison operators (<, >, <=, and >=) applied to
    complex numbers has changed to be consistent with the strict
    ordering defined by the `max', `min', and `sort' functions.  More
    specifically, complex numbers are compared by lexicographical
    comparison of the pairs `[abs(z), arg(z)]'.  Previously, only real
    parts were compared; this can be trivially achieved by converting
    the operands to real values with the `real' function.

 ** The automatic simplification of complex computation results has
    changed.  Octave will now simplify any complex number with a zero
    imaginary part or any complex matrix with all elements having zero
    imaginary part to a real value.  Previously, this was done only for
    positive zeros.  Note that the behavior of the complex function is
    unchanged and it still produces a complex value even if the
    imaginary part is zero.

 ** As a side effect of code refactoring in liboctave, the binary
    logical operations are now more easily amenable to compiler
    optimizations and are thus significantly faster.

 ** Octave now allows user-defined `subsasgn' methods to optimize out
    redundant copies.  For more information, see the manual.

 ** More efficient matrix division handling.  Octave is now able to
    handle the expressions
    
      M' \ V
      M.' \ V
      V / M 

    (M is a matrix and V is a vector) more efficiently in certain cases.
    In particular, if M is triangular, all three expressions will be
    handled by a single call to xTRTRS (from LAPACK), with appropriate
    flags.  Previously, all three expressions required a physical
    transpose of M.

 ** More efficient handling of certain mixed real-complex matrix
    operations.  For instance, if RM is a real matrix and CM a complex
    matrix,
    
      RM * CM

    can now be evaluated either as

      complex (RM * real (CM), RM * imag (CM))

    or as

      complex (RM) * CM,

    depending on the dimensions.  The first form requires more
    temporaries and copying, but halves the FLOP count, which normally
    brings better performance if RM has enough rows.  Previously, the
    second form was always used.

    Matrix division is similarly affected.

 ** More efficient handling of triangular matrix factors returned from
    factorizations.  The functions for computing QR, LU and Cholesky
    factorizations will now automatically return the triangular matrix
    factors with proper internal matrix_type set, so that it won't need
    to be computed when the matrix is used for division.

 ** The built-in `sum' function now handles the non-native summation
    (i.e., double precision sum of single or integer inputs) more
    efficiently, avoiding a temporary conversion of the whole input
    array to doubles.  Further, `sum' can now accept an extra option
    argument, using a compensated summation algorithm rather than a
    straightforward sum, which significantly improves precision if lots
    of cancellation occurs in the summation.

 ** The built-in `bsxfun' function now uses optimized code for certain
    cases where built-in operator handles are passed in.  Namely, the
    optimizations concern the operators `plus', `minus', `times',
    `ldivide', `rdivide', `power', `and', `or' (for logical arrays),
    the relational operators `eq', `ne', `lt', `le', `gt', `ge', and the
    functions `min' and `max'.  Optimizations only apply when both
    operands are of the same built-in class.  Mixed real/complex and
    single/double operations will first convert both operands to a
    common type.

 ** The `strfind' and `strrep' functions now have compiled
    implementations, facilitating significantly more efficient searching
    and replacing in strings, especially with longer patterns.  The code
    of `strcat' has been vectorized and is now much more efficient when
    many strings are concatenated.  The `strcmpi' and `strncmpi'
    functions are now built-in functions, providing better performance.

 ** 'str2double' now has a compiled implementation and the API conforms
    to Matlab.  The additional Octave-specific features of returning a
    boolean matrix indicating which elements were successfully converted
    has been removed.
 
 ** Matlab-style ignoring input and output function arguments using
    tilde (~) is now supported.  Ignored output arguments may be
    detected from a function using the built-in function `isargout'.
    For more details, consult the manual. 

 ** The list datatype, deprecated since the introduction of cells, has
    been removed.

 ** The accumarray function has been optimized and is now significantly
    faster in certain important cases.

 ** The behavior of isreal and isnumeric functions was changed to be more
    Matlab-compatible.

 ** The integer math & conversion warnings (Octave:int-convert-nan,
    Octave:int-convert-non-int-val, Octave:int-convert-overflow,
    Octave:int-math-overflow) have been removed.

 ** rem and mod are now built-in functions.  They also handle integer
    types efficiently using integer arithmetic.

 ** Sparse indexing and indexed assignment has been mostly rewritten.
    Since Octave uses compressed column storage for sparse matrices,
    major attention is devoted to operations manipulating whole columns.
    Such operations are now significantly faster, as well as some other
    important cases.

    Further, it is now possible to pre-allocate a sparse matrix and
    subsequently fill it by assignments, provided they meet certain
    conditions.  For more information, consult the `spalloc' function,
    which is no longer a mere dummy.  Consequently, nzmax and nnz are no
    longer always equal in Octave.  Octave may also produce a matrix
    with nnz < nzmax as a result of other operations, so you should
    consistently use nnz unless you really want to use nzmax (i.e., the
    space allocated for nonzero elements).

    Sparse concatenation is also affected, and concatenating sparse 
    matrices, especially larger collections, is now significantly more 
    efficient.  This applies to both the [] operator and the 
    cat/vertcat/horzcat functions.

 ** It is now possible to optionally employ the xGESDD LAPACK drivers
    for computing the singular value decomposition using svd, instead
    of the default xGESVD, using the configuration pseudo-variable
    svd_driver.  The xGESDD driver can be up to 6x times faster when
    singular vectors are requested, but is reported to be somewhat less
    robust on highly ill-conditioned matrices.

 ** Configuration pseudo-variables, such as page_screen_output or 
    confirm_recursive_rmdir (or the above mentioned svd_driver), now 
    accept a "local" option as second argument, requesting the change 
    to be undone when the current function returns:
        
    function [status, msg] = rm_rf (dir)
      confirm_recursive_rmdir (false, "local");
      [status, msg] = rmdir (dir, "s");
      ...
    endfunction
    
    Upon return, confirm_recursive_rmdir will be restored to the value 
    it had on entry to the function, even if there were subsequent 
    changes to the variable in function rm_rf or any of the functions
    it calls.

 ** pkg now accepts a -forge option for downloading and installing
    packages from Octave Forge automatically.  For example, 
    
      pkg install -forge general
    
    will automatically download the latest release of the general
    package and attempt to install it.  No automatic resolving of
    dependencies is provided.  Further,

      pkg list -forge
    
    can be used to list all available packages.

 ** The internal data representation of structs has been completely
    rewritten to make certain optimizations feasible.  The field data
    can now be shared between structs with equal keys but different
    dimensions or values, making operations that preserve the fields
    faster.  Economized storage is now used for scalar structs (just
    like most other scalars), making their usage more
    memory-efficient.  Certain array-like operations on structs
    (concatenation, uniform cellfun, num2cell) have gained a
    significant speed-up.  Additionally, the octave_scalar_map class
    now provides a simpler interface to work with scalar structs within
    a C++ DLD function.

 ** Two new formats are available for displaying numbers:

      format short eng
      format long eng

    Both display numbers in engineering notation, i.e., mantissa +
    exponent where the exponent is a multiple of 3.

 ** The following functions are new in Octave 3.4:
      accumdim    erfcx        nfields      pqpnonneg  uigetdir
      bitpack     fileread     nth_element  quadcc     uigetfile
      bitunpack   fminbnd      onCleanup    randi      uiputfile
      blkmm       fskipl       pbaspect     repelems   uimenu           
      cbrt        ifelse       pie3         reset      whitebg          
      curl        ishermitian  powerset     rsf2csf            
      chop        isindex      ppder        saveas             
      daspect     luupdate     ppint        strread                     
      divergence  merge        ppjumps      textread             

 ** Using the image function to view images with external programs such
    as display, xv, and xloadimage is no longer supported.  The
    image_viewer function has also been removed.

 ** The behavior of struct assignments to non-struct values has been
    changed.  Previously, it was possible to overwrite an arbitrary
    value:

      a = 1;
      a.x = 2;

    This is no longer possible unless a is an empty matrix or cell
    array.
 
 ** The dlmread function has been extended to allow specifying a custom
    value for empty fields.

 ** The dlmread and dlmwrite functions have been modified to accept
    file IDs (as returned by fopen) in addition to file names.

 ** Octave can now optimize away the interpreter overhead of an
    anonymous function handle, if the function simply calls another
    function or handle with some of its parameters bound to certain
    values.  Example:
    
      f = @(x) sum (x, 1);

    When f is called, the call is forwarded to @sum with the constant 1
    appended, and the anonymous function call does not occur on the
    call stack.

 ** For compatibility with Matlab, mu2lin (x) is now equivalent to
    mu2lin (x, 0).

 ** The new function `history_control' may be used to control the way
    command lines are added to the history list when Octave is using
    readline for command-line editing.  For example

      history_control ("ignoredups")

    tells Octave to avoid adding duplicate lines to the history list.

 ** Octave now uses the gnulib library for improved portability and to
    avoid bugs in operating system functions.

 ** Deprecated functions.

    The following functions were deprecated in Octave 3.0 and have been
    removed from Octave 3.4.
                                           
      beta_cdf         geometric_pdf        pascal_pdf      
      beta_inv         geometric_rnd        pascal_rnd      
      beta_pdf         hypergeometric_cdf   poisson_cdf     
      beta_rnd         hypergeometric_inv   poisson_inv     
      binomial_cdf     hypergeometric_pdf   poisson_pdf     
      binomial_inv     hypergeometric_rnd   poisson_rnd     
      binomial_pdf     intersection         polyinteg       
      binomial_rnd     is_bool              setstr          
      chisquare_cdf    is_complex           struct_contains 
      chisquare_inv    is_list              struct_elements 
      chisquare_pdf    is_matrix            t_cdf           
      chisquare_rnd    is_scalar            t_inv           
      clearplot        is_square            t_pdf           
      clg              is_stream            t_rnd           
      com2str          is_struct            uniform_cdf     
      exponential_cdf  is_symmetric         uniform_inv     
      exponential_inv  is_vector            uniform_pdf     
      exponential_pdf  isstr                uniform_rnd     
      exponential_rnd  lognormal_cdf        weibcdf         
      f_cdf            lognormal_inv        weibinv         
      f_inv            lognormal_pdf        weibpdf         
      f_pdf            lognormal_rnd        weibrnd         
      f_rnd            meshdom              weibull_cdf     
      gamma_cdf        normal_cdf           weibull_inv     
      gamma_inv        normal_inv           weibull_pdf     
      gamma_pdf        normal_pdf           weibull_rnd     
      gamma_rnd        normal_rnd           wiener_rnd      
      geometric_cdf    pascal_cdf
      geometric_inv    pascal_inv

    The following functions were deprecated in Octave 3.2 and will
    be removed from Octave 3.6 (or whatever version is the second major
    release after 3.2):

      create_set          spcholinv    splu   
      dmult               spcumprod    spmax
      iscommand           spcumsum     spmin
      israwcommand        spdet        spprod
      lchol               spdiag       spqr
      loadimage           spfind       spsum
      mark_as_command     sphcat       spsumsq
      mark_as_rawcommand  spinv        spvcat 
      spatan2             spkron       str2mat
      spchol              splchol      unmark_command
      spchol2inv          split        unmark_rawcommand

    The following functions have been deprecated in Octave 3.4 and will
    be removed from Octave 3.8 (or whatever version is the second major
    release after 3.4):

      autocor  cellidx   gammai     is_global  replot     values
      autocov  dispatch  glpkmex    krylovb    saveimage
      betai    fstat     intwarning perror     strerror

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

 ** Compatibility with Matlab graphics has been improved.

    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.

 ** New graphics functions:

      addlistener                  ezcontour   gcbo         refresh  
      addproperty                  ezcontourf  ginput       refreshdata
      allchild                     ezmesh      gtext        specular
      available_graphics_toolkits  ezmeshc     intwarning   surfl
      graphics_toolkit             ezplot      ishghandle   trisurf
      cla                          ezplot3     isocolors    waitforbuttonpress
      clabel                       ezpolar     isonormals
      comet                        ezsurf      isosurface  
      dellistener                  findall     linkprop   
      diffuse                      gcbf        plotmatrix

 ** New experimental OpenGL/FLTK based plotting system.

    An experimental plotting system based on OpenGL and the FLTK
    toolkit is now part of Octave.  This graphics toolkit is disabled by
    default.  You can switch to using it with the command

        graphics_toolkit ("fltk")

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

        graphics_toolkit (h, "fltk")

    where "h" is a valid figure handle.

 ** Functions providing direct access to gnuplot have been removed.

    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 Control, Finance and Quaternion functions have been removed.

    These functions are now available as separate packages from

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

    and can be reinstalled using the Octave package manager (see
    the pkg function).

 ** Specific sparse matrix functions removed.

    The following functions, which handled only sparse matrices have
    been removed.  Instead of calling these functions directly, you
    should use the corresponding function without the "sp" prefix.

      spatan2     spcumsum  spkron   spprod
      spchol      spdet     splchol  spqr
      spchol2inv  spdiag    splu     spsum
      spcholinv   spfind    spmax    spsumsqk
      spcumprod   spinv     spmin

 ** Improvements to the debugger.

    The interactive debugging features have been improved.  Stopping
    on statements with dbstop should work correctly now.  Stepping
    into and over functions, and stepping one statement at a time
    (with dbstep) now works.  Moving up and down the call stack with
    dbup and dbdown now works.  The dbstack function is now available
    to print the current function call stack.  The new dbquit function
    is available to exit the debugging mode.

 ** Improved traceback error messages.

    Traceback error messages are much more concise and easier to
    understand.  They now display information about the function call
    stack instead of the stack of all statements that were active at
    the point of the error.

 ** 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.

    New functions related to OOP include

      class  inferiorto  isobject  loadobj  methods  superiorto

    See the Octave manual for more details.

 ** Parsing of Command-style Functions.

    Octave now parses command-style functions without needing to first
    declare them with "mark_as_command".  The rules for recognizing a
    command-style function calls are

      * A command must appear as the first word in a statement,
        followed by a space.

      * The first character after the space must not be '=' or '('

      * The next token after the space must not look like a binary
        operator.

    These rules should be mostly compatible with the way Matlab parses
    command-style function calls and allow users to define commands in
    .m files without having to mark them as commands.

    Note that previous versions of Octave allowed expressions like

      x = load -text foo.dat

    but an expression like this will now generate a parse error.  In
    order to assign the value returned by a function to a variable,
    you must use the normal function call syntax:

      x = load ("-text", "foo.dat");

 ** Block comments.

    Commented code can be between matching "#{" and "#}" or "%{" 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 [s, t] = func (x, y)
      s = 2 * x;
    #{
      s *= y;
      t = y + x;
    #}
    endfunction

    the lines "s *= y;" and "t = y + x" will not be executed.

 ** If any subfunction in a file ends with "end" or "endfunction", then
    they all must end that way.  Previously, Octave accepted

      function main ()
        ...
      # no endfunction here.
      function sub ()
        ...
      endfunction

    but this is no longer allowed.

 ** 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,
    significantly improving performance for these kinds of
    operations.

 ** Single Precision data type.

    Octave now includes a single precision data type.  Single
    precision variables can be created with the "single" command, or
    from functions like ones, eye, 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.  For compatibility with
    Matlab, 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 indexing is now significantly faster.

 ** Improved memory management.

    Octave will now attempt to share data in some cases where previously
    a copy would be made, such as certain array slicing operations or
    conversions between cells, structs and cs-lists.  This usually reduces
    both time and memory consumption.
    Also, Octave will now attempt to detect and optimize usage of a vector 
    as a stack, when elements are being repeatedly inserted at/removed from 
    the end of the vector.

 ** Improved performance for reduction operations.

    The performance of the sum, prod, sumsq, cumsum, cumprod, any, all,
    max and min functions has been significantly improved.

 ** Sorting and searching.
    
    The performance of sort has been improved, especially when sorting
    indices are requested.  An efficient built-in issorted
    implementation was added.  The sortrows function now uses a more
    efficient algorithm, especially in the homogeneous case.  The lookup
    function is now a built-in function performing a binary search,
    optimized for long runs of close elements.  Lookup also works with
    cell arrays of strings.

 ** Range arithmetics

    For some operations on ranges, Octave will attempt to keep the
    result as a range.  These include negation, adding a scalar,
    subtracting a scalar, and multiplying by a scalar.  Ranges with zero
    increment are allowed and can be constructed using the built-in
    function `ones'.

 ** Various performance improvements.

    Performance of a number of other built-in operations and functions
    was improved, including:

    * logical operations
    * comparison operators
    * element-wise power
    * accumarray
    * cellfun
    * isnan
    * isinf
    * isfinite
    * nchoosek
    * repmat
    * strcmp

 ** 64-bit integer arithmetic.

    Arithmetic with 64-bit integers (int64 and uint64 types) is fully
    supported, with saturation semantics like the other integer types.
    Performance of most integer arithmetic operations has been
    improved by using integer arithmetic directly.  Previously, Octave
    performed integer math with saturation semantics by converting the
    operands to double precision, performing the operation, and then
    converting the result back to an integer value, truncating if
    necessary.

 ** Diagonal and permutation matrices.

    The interpreter can now treat diagonal and permutation matrices as
    special objects that store only the non-zero elements, rather than
    general full matrices.  Therefore, it is now possible to construct
    and use these matrices in linear algebra without suffering a
    performance penalty due to storing large numbers of zero elements.

 ** Improvements to fsolve.

    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.
    Additionally, fsolve is now able to solve overdetermined systems,
    complex-differentiable complex systems, systems with a sparse
    jacobian and can work in single precision if given single precision
    inputs.  It can also be called recursively.

 ** Improvements to the norm function.

    The norm function is now able to compute row or column norms of a
    matrix in a single call, as well as general matrix p-norms.

 ** New functions for computing some eigenvalues or singular values.

    The eigs and svds functions have been included in Octave.  These
    functions require the ARPACK library (now distributed under a
    GPL-compatible license).

 ** New QR and Cholesky factorization updating functions.

      choldelete  cholshift   qrdelete  qrshift
      cholinsert  cholupdate  qrinsert  qrupdate

 ** New quadrature functions.

      dblquad  quadgk  quadv  triplequad

 ** New functions for reading and writing images.

    The imwrite and imread functions have been included in Octave.
    These functions require the GraphicsMagick library.  The new
    function imfinfo provides information about an image file (size,
    type, colors, etc.)

 ** The input_event_hook function has been replaced by the pair of
    functions add_input_event_hook and remove_input_event_hook so that
    more than one hook function may be installed at a time.

 ** Other miscellaneous new functions.

      addtodate          hypot                       reallog
      bicgstab           idivide                     realpow
      cellslices         info                        realsqrt
      cgs                interp1q                    rectint
      command_line_path  isdebugmode                 regexptranslate
      contrast           isfloat                     restoredefaultpath
      convn              isstrprop                   roundb
      cummin             log1p                       rundemos
      cummax             lsqnonneg                   runlength
      datetick           matlabroot                  saveobj
      display            namelengthmax               spaugment
      expm1              nargoutchk                  strchr
      filemarker         pathdef                     strvcat
      fstat              perl                        subspace
      full               prctile                     symvar
      fzero              quantile                    treelayout
      genvarname         re_read_readline_init_file  validatestring
      histc

 ** Changes to strcat.

    The strcat function is now compatible with Matlab's strcat
    function, which removes trailing whitespace when concatenating
    character strings.  For example

      strcat ('foo ', 'bar')
      ==> 'foobar'

    The new function cstrcat provides the previous behavior of
    Octave's strcat.

 ** Improvements to the help functions.

    The help system has been mostly re-implemented in .m files to make
    it easier to modify.  Performance of the lookfor function has been
    greatly improved by caching the help text from all functions that
    are distributed with Octave.  The pkg function has been modified
    to generate cache files for external packages when they are
    installed.

 ** Deprecated functions.

    The following functions were deprecated in Octave 3.0 and will be
    removed from Octave 3.4 (or whatever version is the second major
    release after 3.0):
                                           
      beta_cdf         geometric_pdf       pascal_pdf      
      beta_inv         geometric_rnd       pascal_rnd      
      beta_pdf         hypergeometric_cdf  poisson_cdf     
      beta_rnd         hypergeometric_inv  poisson_inv     
      binomial_cdf     hypergeometric_pdf  poisson_pdf     
      binomial_inv     hypergeometric_rnd  poisson_rnd     
      binomial_pdf     intersection        polyinteg       
      binomial_rnd     is_bool             setstr          
      chisquare_cdf    is_complex          struct_contains 
      chisquare_inv    is_list             struct_elements 
      chisquare_pdf    is_matrix           t_cdf           
      chisquare_rnd    is_scalar           t_inv           
      clearplot        is_square           t_pdf           
      clg              is_stream           t_rnd           
      com2str          is_struct           uniform_cdf     
      exponential_cdf  is_symmetric        uniform_inv     
      exponential_inv  is_vector           uniform_pdf     
      exponential_pdf  isstr               uniform_rnd     
      exponential_rnd  lognormal_cdf       weibcdf         
      f_cdf            lognormal_inv       weibinv         
      f_inv            lognormal_pdf       weibpdf         
      f_pdf            lognormal_rnd       weibrnd         
      f_rnd            meshdom             weibull_cdf     
      gamma_cdf        normal_cdf          weibull_inv     
      gamma_inv        normal_inv          weibull_pdf     
      gamma_pdf        normal_pdf          weibull_rnd     
      gamma_rnd        normal_rnd          wiener_rnd      
      geometric_cdf    pascal_cdf
      geometric_inv    pascal_inv

    The following functions are now deprecated in Octave 3.2 and will
    be removed from Octave 3.6 (or whatever version is the second major
    release after 3.2):

      create_set          spcholinv  spmax
      dmult               spcumprod  spmin
      iscommand           spcumsum   spprod
      israwcommand        spdet      spqr
      lchol               spdiag     spsum
      loadimage           spfind     spsumsq
      mark_as_command     spinv      str2mat
      mark_as_rawcommand  spkron     unmark_command
      spatan2             splchol    unmark_rawcommand
      spchol              split
      spchol2inv          splu

See NEWS.3 for old news.