February 8, 2011
News for version 9 8 7 6 5 4.4 4.2 4 3.8 3.6 3.4 3.2 3 2 1 (Release History)
** 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 `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 expresssion.
** 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 wrapping the
operands in real().
** 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.
** 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.
** 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 krylovb values
autocov dispatch glpkmex replot
betai fstat is_global saveimage
* For compatibility with Matlab, mu2lin (x) is now equivalent to
mu2lin (x, 0).
* The ARPACK library is now distributed with Octave so it no longer
needs to be available as an external dependency when building
Octave.