Mercurial > web-octave
changeset 67:373d2dba318e kai
Include stuff from current octave.org for later hosting.
| author | Kai T. Ohlhus <k.ohlhus@gmail.com> |
|---|---|
| date | Thu, 13 Oct 2016 17:41:24 +0200 |
| parents | a7952259f5d3 |
| children | 8224b565e6fd |
| files | .htaccess NEWS-1.html NEWS-2.html NEWS-3.2.html NEWS-3.4.html NEWS-3.6.html NEWS-3.8.html NEWS-3.html NEWS-4.0.html |
| diffstat | 9 files changed, 5000 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.htaccess Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,25 @@ +<FilesMatch "\.(in|m4)$"> + Order allow,deny + Deny from all +</FilesMatch> + +<FilesMatch "Makefile$"> + Order allow,deny + Deny from all +</FilesMatch> + +<FilesMatch "CVS"> + Order allow,deny + Deny from all +</FilesMatch> + +RewriteEngine on + +RewriteBase /software/octave/ + +RewriteRule ^octave.pdf doc/octave-4.0.3.pdf [L] +RewriteRule ^NEWS.html NEWS-4.0.html [L] +RewriteRule ^contribute.html get-involved.html [L] + +RewriteRule ^doc/interpreter$ doc/interpreter/ [R,L] +RewriteRule ^doc/interpreter/(.*) doc/v4.0.3/$1 [L]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-1.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,1644 @@ +<!doctype html public "-//IETF//DTD HTML Strict//EN"> +<html> +<head> +<title> Changes in Octave version 1 </title> +</head> + +<body> +<h1> News for Octave Version 1 </h1> +<hr> + +<h2>Summary of changes for version 1.1.1</h2> + +<pre> + * New built-in variables, default_return_value and + define_all_return_values. + + If define_all_return_values is set to "false", Octave does not do + anything special for return values that are left undefined, and + you will get an error message if you try to use them. For + example, if the function + + function [x, y] = f () + y = 1; + endfunction + + is called as + + octave:13> [a, b] = f () + + Octave will print an error message for the attempt to assign an + undefined value to `a'. + + This is incompatible with Matlab, which will define the return + variable `x' to be the empty matrix. To get the Matlab-like + behavior, you can set the variable define_all_return_values to + "true" (the default is "false") and default_return_value to `[]' + (the default). Then, any return values that remain undefined when + the function returns will be initialized to `[]'. + + If the function is called without explicitly asking for an output, + it will succeed. This behavior is compatible and unchanged from + previous versions of Octave. + + * New built-in variable suppress_verbose_help_message. If set to + "true", Octave will not add additional help information to the end + of the output from the help command and usage messages for + built-in commands. The default value is "false". + + * New built-in variable PS4 is used as the prefix of echoed input + (enabled with the --echo-input (-x) option). + + * The function size() now accepts an optional second argument. + + * Output from `save - ...' now goes through the pager. + + * The break statement may also be used to exit a function, for + compatibility with Matlab. + + * The directory tree for installing Octave is now closer to + conforming with the current GNU standards. + + * More bug fixes. +</pre> + +<h2>Summary of changes for version 1.1.0</h2> + +<pre> + * Octave now requires g++ 2.6.3 or later. This change is necessary + to make template instantiations cleaner, and to avoid having to + have special cases in the code for earlier versions of gcc. + + * A new data structure type has been added. The implementation uses + an associative array with indices limited to strings, but the + syntax is more like C-style structures. here are some examples of + using it. + + Elements of structures can be of any type, including structures: + + octave:1> x.a = 1; + octave:2> x.b = [1, 2; 3, 4]; + octave:3> x.c = "string"; + octave:4> x + x = + + <structure: a b c> + + octave:5> x.a + x.a = 1 + octave:6> x.b + x.b = + + 1 2 + 3 4 + + octave:7> x.c + x.c = string + octave:8> x.b.d = 3 + x.b.d = 3 + octave:9> x.b + x.b = + + <structure: d> + + octave:10> x.b.d + x.b.d = 3 + + Functions can return structures: + + octave:1> a = rand (3) + rand (3) * I; + octave:2> function y = f (x) + > y.re = real (x); + > y.im = imag (x); + > endfunction + octave:3> f (a) + ans = + + <structure: im re> + + octave:4> ans.im + ans.im = + + 0.093411 0.229690 0.627585 + 0.415128 0.221706 0.850341 + 0.894990 0.343265 0.384018 + + octave:5> ans.re + ans.re = + + 0.56234 0.14797 0.26416 + 0.72120 0.62691 0.20910 + 0.89211 0.25175 0.21081 + + Return lists can include structure elements: + + octave:1> [x.u, x.s, x.v] = svd ([1, 2; 3, 4]) + x.u = + + -0.40455 -0.91451 + -0.91451 0.40455 + + x.s = + + 5.46499 0.00000 + 0.00000 0.36597 + + x.v = + + -0.57605 0.81742 + -0.81742 -0.57605 + + octave:8> x + x = + + <structure: s u v> + + This feature should be considered experimental, but it seems to + work ok. Suggestions for ways to improve it are welcome. + + * Octave now supports a limited form of exception handling modelled + after the unwind-protect form of Lisp: + + unwind_protect + BODY + unwind_protect_cleanup + CLEANUP + end_unwind_protect + + Where BODY and CLEANUP are both optional and may contain any + Octave expressions or commands. The statements in CLEANUP are + guaranteed to be executed regardless of how control exits BODY. + + This is useful to protect temporary changes to global variables + from possible errors. For example, the following code will always + restore the original value of the built-in variable + do_fortran_indexing even if an error occurs while performing the + indexing operation. + + save_do_fortran_indexing = do_fortran_indexing; + unwind_protect + do_fortran_indexing = "true"; + elt = a (idx) + unwind_protect_cleanup + do_fortran_indexing = save_do_fortran_indexing; + end_unwind_protect + + Without unwind_protect, the value of do_fortran_indexing would not + be restored if an error occurs while performing the indexing + operation because evaluation would stop at the point of the error + and the statement to restore the value would not be executed. + + * Recursive directory searching has been implemented using Karl + Berry's kpathsea library. Directories below path elements that + end in // are searched recursively for .m files. + + * Octave now waits for additional input when a pair of parentheses + is `open' instead of giving an error. This allows one to write + statements like this + + if (big_long_variable_name == other_long_variable_name + || not_so_short_variable_name > 4 + && y > x) + some (code, here); + + without having to clutter up the if statement with continuation + characters. + + * Continuation lines are now allowed in string constants and are + handled correctly inside matrix constants. + + * Both `...{whitespace}\n' and `\{whitespace}\n' can be used to + introduce continuation lines, where {whitespace} may include + spaces, tabs and comemnts. + + * The script directory has been split up by topic. + + * Dynamic linking mostly works with dld. The following limitations + are known problems: + + -- Clearing dynamically linked functions doesn't work. + + -- Dynamic linking only works with dld, which has not been ported + to very many systems yet. + + -- Configuring with --enable-lite-kernel seems to mostly work to + make nonessential built-in functions dynamically loaded, but + there also seem to be some problems. For example, fsolve seems + to always return info == 3. This is difficult to debug since + gdb won't seem to allow breakpoints to be set inside + dynamically loaded functions. + + -- Octave uses a lot of memory if the dynamically linked functions + are compiled with -g. This appears to be a limitation with + dld, and can be avoided by not using -g to compile functions + that will be linked dynamically. + + * fft2 and ifft2 are now built-in functions. + + * The `&&' and `||' logical operators are now evaluated in a + short-circuit fashion and work differently than the element by + element operators `&' and `|'. See the Octave manual for more + details. + + * Expressions like 1./m are now parsed as 1 ./ m, not 1. / m. + + * The replot command now takes the same arguments as gplot or + gsplot (except ranges, which cannot be respecified with replot + (yet)) so you can add additional lines to existing plots. + + * The hold command has been implemented. + + * New function `clearplot' clears the plot window. The name `clg' + is aliased to `clearplot' for compatibility with Matlab. + + * The commands `gplot clear' and `gsplot clear' are equivalent to + `clearplot'. (Previously, `gplot clear' would evaluate `clear' as + an ordinary expression and clear all the visible variables.) + + * The Matlab-style plotting commands have been improved. They now + accept line-style arguments, multiple x-y pairs, and other plot + option flags. For example, + + plot (x, y, "@12", x, y2, x, y3, "4", x, y4, "+") + + results in a plot with + + y plotted with points of type 2 ("+") and color 1 (red). + y2 plotted with lines. + y3 plotted with lines of color 4. + y4 plotted with points which are "+"s. + + the help message for `plot' and `plot_opt' provide full + descriptions of the options. + + * NaN is now dropped from plot data, and Inf is converted to a + very large value before calling gnuplot. + + * Improved load and save commands: + + -- The save and load commands can now read and write a new binary + file format. Conversion to and from IEEE big and little endian + formats is handled automatically. Conversion for other formats + has not yet been implemented. + + -- The load command can now read Matlab .mat files, though it is + not yet able to read sparse matrices or handle conversion for + all data formats. + + -- The save command can write Matlab .mat files. + + -- The load command automatically determines the save format + (binary, ascii, or Matlab binary). + + -- The default format for the save command is taken from the + built-in variable `default_save_format'. + + -- The save and load commands now both accept a list of globbing + patterns so you can easily load a list of variables from a + file. + + -- The load command now accepts the option -list, for listing the + variable names without actually loading the data. With + -verbose, it prints a long listing. + + -- The load command now accepts the option -float-binary, for + saving floating point data in binary files in single precision. + + * who and whos now accept a list of globbing patterns so you can + limit the lists of variables and functions to those that match a + given set of patterns. + + * New functions for manipulating polynomials + + compan -- companion matrix corresponding to polynomial coefficients + conv -- convolve two vectors + deconv -- deconvolve two vectors + roots -- find the roots of a polynomial + poly -- characteristic polynomial of a matrix + polyderiv -- differentiate a polynomial + polyinteg -- integrate a polynomial + polyreduce -- reduce a polynomial to minimum number of terms + polyval -- evaluate a polynomial at a point + polyvalm -- evaluate a polynomial in the matrix sense + residue -- partial fraction expansion corresponding to the ratio + of two polynomials + + * New functions for manipulating sets + + create_set -- create a set of unique values + complement -- find the complement of two sets + intersection -- find the intersection of two sets + union -- find the union of two sets + + * New elementary functions: + + acot acoth acsc acsch + asec asech cot coth + csc csch log2 sec + sech + + * New special functions: + + beta -- beta function + betai -- incomplete beta function + gammai -- incomplete gamma function + + * New image processing functions: + + colormap -- set and return current colormap + gray -- set a gray colormap + gray2ind -- image format conversion + image -- display an image + imagesc -- scale and display an image + imshow -- display images + ind2gray -- image format conversion + ind2rgb -- image format conversion + loadimage -- load an image from a file + ntsc2rgb -- image format conversion + ocean -- set a color colormap + rgb2ind -- image format conversion + rgb2ntsc -- image format conversion + saveimage -- save an image to a file + + * New time and date funcitons: + + tic -- set wall-clock timer + toc -- get elapsed wall-clock time, since timer last set + etime -- another way to get elapsed wall-clock time + cputime -- get CPU time used since Octave started + is_leap_year -- is the given year a leap year? + + * Other new functions: + + bug_report -- submit a bug report to the bug-octave mailing list + + toascii -- convert a string to a matrix of ASCII character codes + + octave_tmp_file -- generate a unique temporary file name + + undo_string_escapes -- replace special characters in a string by + their backslash forms + + is_struct -- determine whether something is a structure data type + + feof -- check EOF condition for a specified file + ferror -- check error state for a specified file + fread -- read binary data from a file + fwrite -- write binary data to a file + + file_in_path -- check to see if named file exists in given path + + kbhit -- get a single character from the terminal + + axis -- change plot ranges + hist -- plot histograms + + diary -- save commands and output to a file + + type -- show the definition of a function + which -- print the type of an identifier or the location of a + function file + + isieee -- Returns 1 if host uses IEEE floating point + realmax -- Returns largest floating point number + realmin -- Returns smallest floating point number + + gcd -- greatest common divisor + lcm -- least common multiple + + null -- orthonormal basis of the null space of a matrix + orth -- orthonormal basis of the range space of a matrix + + fft2 -- two-dimensional fast fourier transform + ifft2 -- two-dimensional inverse fast fourier transform + filter -- digital filter + fftfilt -- filter using fft + fftconv -- convolve to vectors using fft + sinc -- returns sin(pi*x)/(pi*x) + freqz -- compute the frequency response of a filter + + * The meaning of nargin (== args.length ()) in built-in functions + has been changed to match the meaning of nargin in user-defined + functions. + + * Variable return lists. Octave now has a real mechanism for + handling functions that return an unspecified number of values, + so it is no longer necessary to place an upper bound on the number + of outputs that a function can produce. + + Here is an example of a function that uses the new syntax to + produce n values: + + function [...] = foo (n) + for i = 1:n + vr_val (i * x); + endfor + endfunction + + * New keyword, all_va_args, that allows the entire list of va_args + to be passed to another function. For example, given the functions + + function f (...) + while (nargin--) + disp (va_arg ()) + endwhile + endfunction + function g (...) + f ("begin", all_va_args, "end") + endfunction + + the statement + + g (1, 2, 3) + + prints + + begin + 1 + 2 + 3 + end + + all_va_args may be used more than once, but can only be used + within functions that take a variable number of arguments. + + * If given a second argument, svd now returns an economy-sized + decomposition, eliminating the unecessary rows or columns of U or + V. + + * The max and min functions correctly handle complex matrices in + which some columns contain real values only. + + * The find function now handles 2 and 3 output arguments. + + * The qr function now allows computation of QR with pivoting. + + * hilb() is much faster for large matrices. + + * computer() is now a built-in function. + + * pinv() is now a built-in function. + + * The output from the history command now goes through the pager. + + * If a function is called without assigning the result, nargout is + now correctly set to 0. + + * It is now possible to write functions that only set some return + values. For example, calling the function + + function [x, y, z] = f () x = 1; z = 2; endfunction + + as + + [a, b, c] = f () + + produces: + + a = 1 + + b = [](0x0) + + c = 2 + + * The shell_cmd function has been renamed to system (the name + shell_cmd remains for compatibility). It now returns [output, status]. + + * New built-in variable `OCTAVE_VERSION'. Also a new function, + version, for compatibility with Matlab. + + * New built-in variable `automatic_replot'. If it is "true", Octave + will automatically send a replot command to gnuplot each time the + plot changes. Since this is fairly inefficient, the default value + is "false". + + * New built-in variable `whitespace_in_literal_matrix' allows some + control over how Octave decides to convert spaces to commas in + matrix expressions like `[m (1)]'. + + If the value of `whitespace_in_literal_matrix' is "ignore", Octave + will never insert a comma or a semicolon in a literal matrix list. + For example, the expression `[1 2]' will result in an error + instead of being treated the same as `[1, 2]', and the expression + + [ 1, 2, + 3, 4 ] + + will result in the vector [1 2 3 4] instead of a matrix. + + If the value of `whitespace_in_literal_matrix' is "traditional", + Octave will convert spaces to a comma between identifiers and `('. + For example, given the matrix + + m = [3 2] + + the expression + + [m (1)] + + will be parsed as + + [m, (1)] + + and will result in + + [3 2 1] + + and the expression + + [ 1, 2, + 3, 4 ] + + will result in a matrix because the newline character is converted + to a semicolon (row separator) even though there is a comma at the + end of the first line (trailing commas or semicolons are ignored). + This is apparently how Matlab behaves. + + Any other value for `whitespace_in_literal_matrix' results in + behavior that is the same as traditional, except that Octave does + not convert spaces to a comma between identifiers and `('. + For example, the expression + + [m (1)] + + will produce 3. This is the way Octave has always behaved. + + * Line numbers in error messages for functions defined in files and + for script files now correspond to the file line number, not the + number of lines after the function keyword appeared. + + * Octave now extracts help from script files. The comments must + come before any other statements in the file. + + * In function files, the first block of comments in the file will + now be interpreted as the help text if it doesn't look like the + Octave copyright notice. Otherwise, Octave extracts the first set + of comments after the function keyword. + + * The function clock is more accurate on systems that have the + gettimeofday() function. + + * The standard output stream is now automatically flushed before + reading from stdin with any of the *scanf() functions. + + * Expanded reference card. + + * The Octave distribution now includes a frequently asked questions + file, with answers. Better answers and more questions (with + answers!) are welcome. + + * New option --verbose. If Octave is invoked with --verbose and not + --silent, a message is printed if an octaverc file is read while + Octave is starting. + + * An improved configure script generated by Autoconf 2.0. + + * Lots of bug fixes. +</pre> + +<h2>Summary of changes for version 1.0</h2> + +<pre> + * C-style I/O functions now handle files referenced by name or by + number more consistently. +</pre> + +<h2>Summary of changes for version 0.83</h2> + +<pre> + * Loading global symbols should work now. + + * Clearing the screen doesn't reprint the prompt unnecessarily. + + * The operations <complex scalar> OP <real matrix> for OP == +, -, + *, or ./ no longer crash Octave. + + * More portability and configuration fixes. +</pre> + +<h2>Summary of changes for version 0.82</h2> + +<pre> + * Octave now comes with a reference card. + + * The manual has been improved, but more work remains to be done. + + * The atanh function now works for complex arguments. + + * The asin, acos, acosh, and atanh functions now work properly when + given real-valued arguments that produce complex results. + + * SEEK_SET, SEEK_CUR, and SEEK_END are now constants. + + * The `using' qualifier now works with gplot and gsplot when the + data to plot is coming directly from a file. + + * The strcmp function now works correctly for empty strings. + + * Eliminated bogus parse error for M-files that don't end with `end' + or `endfunction'. + + * For empty matrices with one nonzero dimension, the +, -, .*, and + ./ operators now correctly preserve the dimension. + + * Octave no longer crashes if you type ^D at the beginning of a line + in the middle of defining a loop or if statement. + + * On AIX systems, Back off on indexing DiagArray via Proxy class to + avoid gcc (or possibly AIX assembler?) bug. + + * Various other bug and portability fixes. +</pre> + +<h2>Summary of changes for version 0.81</h2> + +<pre> + * Octave no longer dumps core if you try to define a function in + your .octaverc file. + + * Fixed bug in Array class that resulted in bogus off-diagonal + elements when computing eigenvalue and singular value + decompositions. + + * Fixed bug that prevented lsode from working on the SPARCstation, + at least with some versions of Sun's f77. This bug was introduced + in 0.80, when I changed LSODE to allow the user to abort the + integration from within the RHS function. + + * Fixed bug that prevented global attribute of variables from being + saved with save(), and another that prevented load() from working + at all. +</pre> + +<h2>Summary of changes for version 0.80</h2> + +<pre> + * I have started working on a manual for the C++ classes. At this + point, it is little more than a list of function names. If you + would like to volunteer to help work on this, please contact + bug-octave@bevo.che.wisc.edu. + + * The patterns accepted by the save and clear commands now work like + file name globbing patterns instead of regular expressions. I + apologize for any inconvenience this change may cause, but file + name globbing seems like a more reasonable style of pattern + matching for this purpose. + + * It is now possible to specify tolerances and other optional inputs + for dassl, fsolve, lsode, npsol, qpsol, and quad. For each of + these functions, there is a corresponding function X_options, + which takes a keyword and value arguments. If invoked without any + arguments, the X_options functions print a list of possible + keywords and current values. For example, + + npsol_options () + + prints a list of possible options with values, and + + npsol_options ("major print level", 10) + + sets the major print level to 10. + + The keyword match is not case sensitive, and the keywords may be + abbreviated to the shortest unique match. For example, + + npsol_options ("ma p", 10) + + is equivalent to the statement shown above. + + * The new built-in variable save_precision can be used to set the + number of digits preserved by the ASCII save command. + + * Assignment of [] now works in most cases to allow you to delete + rows or columns of matrices and vectors. For example, given a + 4x5 matrix A, the assignment + + A (3, :) = [] + + deletes the third row of A, and the assignment + + A (:, 1:2:5) = [] + + deletes the first, third, and fifth columns. + + * Variable argument lists. Octave now has a real mechanism for + handling functions that take an unspecified number of arguments, + so it is no longer necessary to place an upper bound on the number + of optional arguments that a function can accept. + + Here is an example of a function that uses the new syntax to print + a header followed by an unspecified number of values: + + function foo (heading, ...) + disp (heading); + va_start (); + while (--nargin) + disp (va_arg ()); + endwhile + endfunction + + Note that the argument list must contain at least one named + argument (this restriction may eventually be removed), and the + ellipsis must appear as the last element of the argument list. + + Calling va_start() positions an internal pointer to the first + unnamed argument and allows you to cycle through the arguments + more than once. It is not necessary to call va_start() if you + do not plan to cycle through the arguments more than once. + + * Recursive functions should work now. + + * The environment variable OCTAVE_PATH is now handled in the same + way as TeX handles TEXINPUTS. If the path starts with `:', the + standard path is prepended to the value obtained from the + environment. If it ends with `:' the standard path is appended to + the value obtained from the environment. + + * New functions, from Kurt Hornik (hornik@neuro.tuwien.ac.at) and + the Department of Probability Theory and Statistics TU Wien, + Austria: + + corrcoef -- corrcoef (X, Y) is the correlation between the i-th + variable in X and the j-th variable in Y + corrcoef (X) is corrcoef (X, X) + cov -- cov (X, Y) is the covariance between the i-th + variable in X and the j-th variable in Y + cov (X) is cov (X, X) + gls -- generalized least squares estimation + kurtosis -- kurtosis(x) = N^(-1) std(x)^(-4) SUM_i (x(i)-mean(x))^4 - 3 + If x is a matrix, return the row vector containing + the kurtosis of each column + mahalanobis -- returns Mahalanobis' D-square distance between the + multivariate samples X and Y, which must have the + same number of components (columns), but may have + a different number of observations (rows) + ols -- ordinary least squares estimation + pinv -- returns the pseudoinverse of X; singular values + less than tol are ignored + skewness -- skewness (x) = N^(-1) std(x)^(-3) SUM_i (x(i)-mean(x))^3 + if x is a matrix, return the row vector containing + the skewness of each column + + * Errors in user-supplied functions called from dassl, fsolve, + lsode, npsol, and quad are handled more gracefully. + + * Programming errors in the use of the C++ classes within Octave + should no longer cause Octave to abort. Instead, Octave's error + handler function is called and execution continues as best as is + possible. This should result in eventually returning control to + the top-level Octave prompt. (It would be nice to have a real + exception handling mechanism...) + + * A number of memory leaks have been eliminated. Thanks to + Fong Kin Fui <fui@ee.nus.sg> for reporting them. + + * The C++ matrix classes are now derived from a generic + template-based array class. + + * The readline function operate-and-get-next (from bash) is now + available and bound to C-O by default. + + * Octave now uses the version of readline currently distributed with + bash-1.13. On some systems, interactive invocations of Octave + will now blink the cursor to show matching parens. + + * By default, include files are now installed in + $prefix/include/octave instead of $prefix/include. + + * Octave now uses a config.h file instead of putting all defines on + the compiler command line. +</pre> + +<h2>Summary of changes for version 0.79</h2> + +<pre> + * New control systems functions: + + dgram -- Returns the discrete controllability and observability gramian. + dlqr -- Discrete linear quadratic regulator design. + dlqe -- Discrete linear quadratic estimator (Kalman Filter) design. + c2d -- Convert continuous system description to discrete time + description assuming zero-order hold and given sample time. + + * The max (min) functions can now return the index of the max (min) + value as a second return value. +</pre> + +<h2>Summary of changes for version 0.78</h2> + +<pre> + * Octave's handling of global variables has been completely + rewritten. To access global variables inside a function, you must + now declare them to be global within the function body. Likewise, + if you do not declare a variable as global at the command line, + you will not have access to it within a function, even if it is + declared global there. For example, given the function + + function f () + global x = 1; + y = 2; + endfunction + + the global variable `x' is not visible at the top level until the + command + + octave:13> global x + + has been evaluated, and the variable `y' remains local to the + function f() even if it is declared global at the top level. + + Clearing a global variable at the top level will remove its global + scope and leave it undefined. For example, + + octave:1> function f () # Define a function that accesses + > global x; # the global variable `x'. + > x + > endfunction + octave:2> global x = 1 # Give the variable `x' a value. + octave:3> f () # Evaluating the function accesses the + x = 1 # global `x'. + octave:4> clear x # Remove `x' from global scope, clear value. + octave:5> x = 2 # Define new local `x' at the top level + x = 2 + octave:6> f # The global `x' is no longer defined. + error: `x' undefined near line 1 column 25 + error: evaluating expression near line 1, column 25 + error: called from `f' + octave:7> x # But the local one is. + x = 2 + + * The new function, `is_global (string)' returns 1 if the variable + named by string is globally visible. Otherwise, returns 0. + + * The implementation of `who' has changed. It now accepts the + following options: + + -b -builtins -- display info for built-in variables and functions + -f -functions -- display info for currently compiled functions + -v -variables -- display info for user variables + -l -long -- display long info + + The long output looks like this: + + octave:5> who -l + + *** currently compiled functions: + + prot type rows cols name + ==== ==== ==== ==== ==== + wd user function - - f + + *** local user variables: + + prot type rows cols name + ==== ==== ==== ==== ==== + wd real scalar 1 1 y + + *** globally visible user variables: + + prot type rows cols name + ==== ==== ==== ==== ==== + wd complex matrix 13 13 x + + where the first character of the `protection' field is `w' if the + symbol can be redefined, and `-' if it has read-only access. The + second character may be `d' if the symbol can be deleted, or `-' + if the symbol cannot be cleared. + + * The new built-in variable ignore_function_time_stamp can be used + to prevent Octave from calling stat() each time it looks up + functions defined in M-files. If set to "system", Octave will not + automatically recompile M-files in subdirectories of + $OCTAVE_HOME/lib/VERSION if they have changed since they were last + compiled, but will recompile other M-files in the LOADPATH if they + change. If set to "all", Octave will not recompile any M-files + unless their definitions are removed with clear. For any other + value of ignore_function_time_stamp, Octave will always check to + see if functions defined in M-files need to recompiled. The + default value of ignore_function_time_stamp is "system". + + * The new built-in variable EDITOR can be used to specify the editor + for the edit_history command. It is set to the value of the + environment variable EDITOR, or `vi' if EDITOR is not set, or is + empty. + + * There is a new built-in variable, INFO_FILE, which is used as the + location of the info file. Its initial value is + $OCTAVE_HOME/info/octave.info, so `help -i' should now work + provided that OCTAVE_HOME is set correctly, even if Octave is + installed in a directory different from that specified at compile + time. + + * There is a new command line option, --info-file FILE, that may be + used to set Octave's idea of the location of the info file. It + will override any value of OCTAVE_INFO_FILE found in the + environment, but not any INFO_FILE="filename" commands found in + the system or user startup files. + + * Octave's Info reader will now recognize gzipped files that have + names ending in `.gz'. + + * The save command now accepts regular expressions as arguments. + Note that these patterns are regular expressions, and do not work + like filename globbing. For example, given the variables `a', + `aa', and `a1', the command `save a*' saves `a' and `aa' but not + `a1'. To match all variables beginning with `a', you must use an + expression like `a.*' (match all sequences beginning with `a' + followed by zero or more characters). + + * Line and column information is included in more error messages. +</pre> + +<h2>Summary of changes for version 0.77</h2> + +<pre> + * Improved help. The command `help -i topic' now uses the GNU Info + browser to display help for the given topic directly from the + Texinfo documenation. + + * New function: chol -- Cholesky factorization. +</pre> + +<h2>Summary of changes for version 0.76</h2> + +<pre> + * Better run-time error messages. Many now include line and column + information indicating where the error occurred. Octave will also + print a traceback for errors occurring inside functions. If you + find error messages that could use improvement, or errors that + Octave fails to catch, please send a bug report to + bug-octave@bevo.che.wisc.edu. + + * If gplot (or gsplot) is given a string to plot, and the string + does not name a file, Octave will pass the string along to gnuplot + directly. This allows commands like + + gplot "sin (x)" w l, data w p + + to work (assuming that data is a variable containing a matrix of + values). + + * Long options (--help, --version, etc.) are supported. +</pre> + +<h2>Summary of changes for version 0.75</h2> + +<pre> + * The documentation is much more complete, but still could use a lot + of work. + + * The history function now prints line numbers by default. The + command `history -q' will omit them. + + * The clear function now accepts regular expressions. + + * If gplot (or gsplot) is given a string to plot, and the string + names a file, Octave attempts to plot the contents of the file. + + * New functions: + + history: + + run_history -- run commands from the history list. + edit_history -- edit commands from the history list with your + favorite editor. + + linear algebra: + + balance -- Balancing for algebraic and generalized + eigenvalue problems. + givens -- Givens rotation. + is_square -- Check to see if a matrix is square. + qzhess -- QZ decomposition of the matrix pencil (a - lambda b). + qzval -- Generalized eigenvalues for real matrices. + syl -- Sylvester equation solver. + + control systems: + + is_symmetric -- Check to see if a matrix is symmetric. + abcddim -- Check dimensions of linear dynamic system [A,B,C,D]. + is_controllable -- Check to see if [A,B,C,D] is controllable. + is_observable -- Check to see if [A,B,C,D] is observable. + are -- Solve algebraic Ricatti equation. + dare -- Solve discrete-time algebraic Ricatti equation. + lqe -- Kalman filter design for continuous linear system. + lqr -- Linear Quadratic Regulator design. + lyap -- Solve Lyapunov equation. + dlyap -- Solve discrete Lyapunov equation. + tzero -- Compute the transmission zeros of [A,B,C,D]. +</pre> + +<h2>Summary of changes for version 0.74</h2> + +<pre> + * Formal parameters to functions are now always considered to be + local variables, so things like + + global x = 0 + global y = 0 + function y = f (x) x = 1; y = x; end + f (x) + + result in the function returning 1, with the global values of x + and y unchanged. + + * Multiple assignment expressions are now allowed to take indices, + so things like + + octave:13> [a([1,2],[3,4]), b([5,6],[7,8])] = lu ([1,2;3,4]) + + will work correctly. +</pre> + +<h2>Summary of changes for version 0.73</h2> + +<pre> + * Saving and loading global variables works correctly now. + + * The save command no longer saves built-in variables. + + * Global variables are more reliable. + + * Matrices may now have one or both dimensions zero, so that + operations on empty matrices are now handled more consistently. + + By default, dimensions of the empty matrix are now printed along + with the empty matrix symbol, `[]'. For example: + + octave:13> zeros (3, 0) + ans = + + [](3x0) + + The new variable `print_empty_dimensions' controls this behavior. + + See also Carl de Boor, An Empty Exercise, SIGNUM, Volume 25, + pages 2--6, 1990, or C. N. Nett and W. M. Haddad, A + System-Theoretic Appropriate Realization of the Empty Matrix + Concept, IEEE Transactions on Automatic Control, Volume 38, + Number 5, May 1993. + + * The right and left division operators `/' and `\' will now find a + minimum norm solution if the system is not square, or if the + coefficient matrix is singular. + + * New functions: + + hess -- Hessenberg decomposition + schur -- Ordered Schur factorization + perror -- print error messages corresponding to error codes + returned from the functions fsolve, npsol, and qpsol + (with others to possibly be added later). + + * Octave now prints a warning if it finds anything other than + whitespace or comments after the final `end' or `endfunction' + statement. + + * The bodies of functions, and the for, while, and if commands are + now allowed to be empty. + + * Support for Gill and Murray's QPSOL has been added. Like NPSOL, + QPSOL is not freely redistributable either, so you must obtain + your own copy to be able to use this feature. More information + about where to find QPSOL and NPSOL are in the file README.NLP. +</pre> + +<h2>Summary of changes for version 0.72</h2> + +<pre> + * For numeric output, columns are now lined up on the decimal point. + (This requires libg++-2.3.1 or later to work correctly). + + * If octave is running interactively and the output intended for the + screen is longer than one page and a pager is available, it is + sent to the pager through a pipe. You may specify the program to + use as the pager by setting the variable PAGER. PAGER may also + specify a command pipeline. + + * Spaces are not always significant inside square brackets now, so + commands like + + [ linspace (1, 2) ] + + will work. However, some possible sources of confusion remain + because Octave tries (possibly too hard) to determine exactly what + operation is intended from the context surrounding an operator. + For example: + + -- In the command + + [ 1 - 1 ] + + the `-' is treated as a binary operator and the result is the + scalar 0, but in the command + + [ 1 -1 ] + + the `-' is treated as a unary operator and the result is the + vector [ 1 -1 ]. + + -- In the command + + a = 1; [ 1 a' ] + + the single quote character `'' is treated as a transpose operator + and the result is the vector [ 1 1 ], but in the command + + a = 1; [ 1 a ' ] + + an error message indicating an unterminated string constant is + printed. + + * Assignments are just expressions now, so they are valid anywhere + other expressions are. This means that things like + + if (a = n < m) ... endif + + are valid. This is parsed as: compare `n < m', assign the result + to the variable `a', and use it as the test expression in the if + statement. + + To help avoid errors where `=' has been used but `==' was + intended, Octave issues a warning suggesting parenthesis around + assignments used as truth values. You can suppress this warning + by adding parenthesis, or by setting the value of the new built-in + variable `warn_assign_as_truth_value' to 'false' (the default + value is 'true'). + + This is also true for multiple assignments, so expressions like + + [a, b, c] = [u, s, v] = expression + + are now possible. If the expression is a function, nargout is set + to the number of arguments for the right-most assignment. The + other assignments need not contain the same number of elements. + Extra left hand side variables in an assignment become undefined. + + * The default line style for plots is now `lines' instead of + `points'. To change it, use the `set data style STYLE' command. + + * New file handling and I/O functions: + + fopen -- open a file for reading or writing + fclose -- close a file + fflush -- flush output to a file + fgets -- read characters from a file + frewind -- set file position to the beginning of a file + fseek -- set file position + ftell -- tell file position + freport -- print a report for all open files + fscanf -- read from a file + sscanf -- read from a string + scanf -- read from the standard input + + * New built-in variables for file and I/O functions: + + stdin -- file number corresponding to the standard input stream. + stdout -- file number corresponding to the standard output stream. + stderr -- file number corresponding to the standard error stream. + + The following may be used as the final (optional) argument for + fseek: + + SEEK_SET -- set position relative to the beginning of the file. + SEEK_CUR -- set position relative to the current position. + SEEK_END -- set position relative to the end of the file. + + * New function: setstr -- convert vectors or scalars to strings + (doesn't work for matrices yet). + + * If possible, computer now prints the system type instead of + always printing `Hi Dave, I'm a HAL-9000'. + + * Octave now properly saves and restores its internal state + correctly in more places. Interrupting Octave while it is + executing a script file no longer causes it to exit. + + * Octave now does tilde expansion on each element of the LOADPATH. + + * A number of memory leaks have been plugged. + + * Dependencies for C++ source files are now generated automatically + by g++. + + * There is a new command line option, -p PATH, that may be used to + set Octave's loadpath from the command line. It will override any + value of OCTAVE_PATH found in the environment, but not any + LOADPATH="path" commands found in the system or user startup files. + + * It is now possible to override Octave's default idea of the + location of the system-wide startup file (usually stored in + $(prefix)/lib/octave/octaverc) using the environment variable + OCTAVE_HOME. If OCTAVE_HOME has a value, Octave will look for + octaverc and its M-files in the directory $OCTAVE_HOME/lib/octave. + + This allows people who are using binary distributions (as is + common with systems like Linux) to install the real octave binary + in any directory (using a name like octave.bin) and then install + a simple script like this + + #!/bin/sh + OCTAVE_HOME=/foo/bar/baz + export OCTAVE_HOME + exec octave.bin + + to be invoked as octave. + +</pre> + +<h2>Summary of changes for version 0.71</h2> + +<pre> + * Much improved plotting facility. With this release, Octave does + not require a specially modified version of gnuplot, so gnuplot + sources are no longer distributed with Octave. For a more + detailed description of the new plotting features, see the file + PLOTTING. + + * New plotting commands: + + plot -- 2D plots + semilogx -- 2D semilog plot with logscale on the x axis + semilogy -- 2D semilog plot with logscale on the y axis + loglog -- 2D log-log plot + mesh -- 3D mesh plot + meshdom -- create matrices for 3D plotting from two vectors + contour -- contour plots of 3D data + bar -- create bar graphs + stairs -- create stairstep plots + polar -- 2D plots from theta-R data + grid -- turn plot grid lines on or off + xlabel, ylabel -- place labels on the x and y axes of 2D plots + sombrero -- demonstrate 3D plotting + gplot -- 2D plot command with gnuplot-like syntax + gsplot -- 3D plot command with gnuplot-like syntax + set -- set plot options with gnuplot syntax + show -- show plot options with gnuplot syntax + closeplot -- close stream to gnuplot process + purge_tmp_files -- delete temporary files created by plot command + + * Other new commands: + + ls, dir -- print a directory listing + shell_cmd -- execute shell commands + keyboard -- get input from keyboard, useful for debugging + menu -- display a menu of options and ask for input + fft -- fast fourier transform + ifft -- inverse fast fourier transform + + * Strings may be enclosed in either single or double quote + characters. Double quote characters are not special within single + quote strings, and single quotes are not special within double + quote strings. + + * Command name completion now works for M-file names too. + + * Better help and usage messages for many functions. + + * Help is now available for functions defined in M-files. The first + block of comments is taken as the text of the help message. + + * Numerous changes in preparation to support dynamic loading of + object files with dld. + + * Bug fixes to make solving DAEs with dassl actually work. + + * The command `save file' now saves all variables in the named file. + + * If do_fortran_indexing is 'true', indexing a scalar with + [1,1,1,...] (n times) replicates its value n times. The + orientation of the resulting vector depends on the value of + prefer_column_vectors. + + * Things like [[1,2][3,4]] no longer cause core dumps, and invalid + input like [1,2;3,4,[5,6]] now produces a diagnositic message. + + * The cd, save, and load commands now do tilde expansion. + + * It's now possible to clear global variables and functions by name. + + * Use of clear inside functions is now a parse error. +</pre> + +<h2>Summary of changes for version 0.70</h2> + +<pre> + * Better parse error diagnostics. For interactive input, you get + messages like + + octave:1> a = 3 + * 4; + + parse error: + + a = 3 + * 4; + ^ + + and for script files, the message includes the file name and input + line number: + + octave:1> foo + + parse error near line 4 of file foo.m: + + a = 3 + * 4; + ^ + + * New built-in variable PS2 which is used as the secondary prompt. + The default value is '> '. + + * New file, octave-mode.el, for editing Octave code with GNU Emacs. + This is a modified version of Matthew R. Wette's matlab-mode.el. + + * Better support for missing math functions. + + * User preferences are now cached in a global struct so we don't + have to do a symbol table lookup each time we need to know what + they are. This should mean slightly improved performance for + evaluating expressions. +</pre> + +<h2>Summary of changes for version 0.69</h2> + +<pre> + * Multiple assignments are now possible, so statements like + + a = b = c = 3; + a = b = c = [1,2;3,4]; + + or + + c = (a = (b = 2) * 3 + 4) * 5 + + are legal, as are things that have even more bizarre effects, like + + a(4:6,4:6) = b(2:3,2:3) = [1,2;3,4]; + + (try it). + + * Improved parsing of strings (but they still don't work as matrix + elements). + + * An M-file may now either define a function or be a list of + commands to execute. + + * Better detection and conditional compilation of IEEE functions + isinf, finite, and isnan. + + * Replacements for acosh, asinh, atanh, and gamma from the BSD math + library for those systems that don't have them. +</pre> + +<h2>Summary of changes for version 0.68</h2> + +<pre> + * New functions: + + eval -- evaluate a string as a sequence of Octave commands. + input -- print a prompt and get user input. +</pre> + +<h2>Summary of changes for version 0.67</h2> + +<pre> + * New functions: + + find -- return the indices of nonzero elements. + + * Zero-one style indexing now works. For example, + + a = [1,2,3,4]; + b = a([1,0,0,1]) + + sets b to the first and fourth elememnts of a. + + Zero-one style indexing also works for indexing the left hand side + of an assignment. For example, + + a = rand (1,2;3,4); + a([0,1],:) = [-1,-2] + + sets the second row of a to [-1 -2] + + The behavior for the ambiguous case + + a = [1,2,3,4]; + b = a([1,1,1,1]); + + is controlled by the new global variable `prefer_zero_one_indexing'. + If this variable is equal to 'true', b will be set to [1 2 3 4]. + If it is false, b will be set to [1 1 1 1]. The default value is + 'false'. + + * Using the new global variable `propagate_empty_matrices', it is + possible to have unary andy binary operations on empty matrices + return an empty matrix. The default value of this variable is + 'warn', so that empty matrices are propagated but you get a + warning. Some functions, like eig and svd have also been changed + to handle this. + + * Empty matrices can be used in conditionals, but they always + evaluate to `false'. With propagate_empty_matrices = 'true', both + of the following expressions print 0: + + if [], 1, else 0, end + if ~[], 1, else 0, end + + * Octave no longer converts input like `3.2 i' or `3 I' to complex + constants directly because that causes problems inside square + brackets, where spaces are important. This abbreviated notation + *does* work if there isn't a space between the number and the i, + I, j, or J. +</pre> + +<h2>Summary of changes for version 0.66</h2> + +<pre> + * Logical unary not operator (~ or !) now works for complex. + + * Left division works. + + * Right and left element by element division should work correctly + now. + + * Numbers like .3e+2 are no longer errors. + + * Indexing a matrix with a complex value doesn't cause a core dump. + + * The min and max functions should work correctly for two arguments. + + * Improved (I hope!) configuration checks. + + * Octave is now installed as octave-M.N, where M and N are version + numbers, and octave is a link to that file. This makes it + possible to have more than one version of the interpreter installed. +</pre> + +<h2>Summary of changes for version 0.63</h2> + +<pre> + * The reshape function works again. + + * Octave now converts input like `3.2i' or `3 I' or `2.3e5 j' to be + complex constants directly, rather than requiring an expression + like `3.3 * i' to be evaluated. +</pre> + +<h2>Summary of changes for version 0.61</h2> + +<pre> + * Octave has been successfully compiled using gcc 2.3.3 and libg++ 2.3. + on a 486 system running Linux. + + * The win_texas_lotto function is now called texas_lotto (it's a + script file, and win_texas_lotto.m is too long for some Linux and + System V systems). +</pre> + +<h2>Summary of changes for version 0.57</h2> + +<pre> + * The C-like formatted print functions printf, fprintf, and sprintf + finally work. +</pre> + +<h2>Summary of changes for version 0.56</h2> + +<pre> + * By default, octave prints a short disclaimer when it starts. + (You can suppress it by invoking octave with -q). + + * You can keep octave from reading your ~/.octaverc and .octaverc + files by invoking it with -f. + + * When returning two values, eig now returns [v, d] instead of + [lambda, v], where d is a diagonal matrix made from lambda. + + * The win_texas_lotto function now produces a sorted list. + + * New functions: + + expm -- matrix exponential. + logm -- matrix logarithm. +</pre> + +<h2>Summary of changes for version 0.55</h2> + +<pre> + * The following (C-style) backslash escape sequences work in quoted + strings (useful(?) with printf()): + + \a bell \r carriage return + \b backspace \t horizontal tab + \f formfeed \v vertical tab + \n newline \\ backslash + + * Use of `...' at the end of a line will allow a statement to + continue over more than one line. + + * The names `inf' and `nan' are now aliases for `Inf' and `NaN', + respectively. + + * New functions: + + casesen -- print a warning if the luser tries to turn off case + sensitivity. + median -- find median value. + norm -- compute the norm of a matrix. + sort -- sort columns. + + * New variable, `silent_functions'. If silent_functions == 'true', + the results of expressions are not printed even if they are not + followed by a semicolon. The disp() and printf() functions still + result in output. The default value for this variable is 'false'. + + * New variable `return_last_value_computed'. If it is 'true', + functions defined in script files return the last value computed + if a return value has not been explicitly declared. The default + value for this variable is 'false'. +</pre> + +<h2>Summary of changes for version 0.52</h2> + +<pre> + * Name completion works for function and variable names currently in + the symbol tables. Coming soon: completion for names of functions + defined in script files but not yet compiled. + + * The initial value of do_fortran_indexing is now false, and the + initial value of prefer_column_vectors is now true. Swap the + values of these variables if you want behavior that is more like + Matlab. + + * All script files check the number of input arguments before doing + much real work. + + * The identifiers `i' and `j' are now also names for sqrt(-1). + These symbols may be used for other purposes, but their original + definition will reappear if they are cleared. + + * The symbol tables are now implemented with hash tables for faster + searching. + + * A small amount of help is now available for most built-in + operators, keywords and functions. Coming soon: help for script + files. + + * Without any arguments, the help command now lists all known + built-in operators, keywords and functions. + + * Generic parse errors are now signalled by `Eh, what's up doc?', + which is closer to what Bugs actually says. + + * The who command now only prints variable names by default. + Use the -fcn (or -fcns, or -functions) switch to print the names of + built-in or currently compiled functions. +</pre> + +<h2>Summary of changes for version 0.51</h2> + +<pre> + * Major overhaul of array indexing. + + * The colloc function actually works now. +</pre> + +<h2>Summary of changes for version 0.50</h2> + +<pre> + * The lsode and dassl functions now return the states only, + instead of the time and the states, so you must keep track of + the corresponding times (this is easy though, because you have + to specify a vector of desired output times anyway). + + * Solution of NLPs with NPSOL now works on the SPARC. + + * New keywords `endif', `endfor', `endfunction', `endif', and + `endwhile', which allow for better diagnostics. The `end' keyword + is still recognized. All script files have been changed to use + these new keywords in place of `end'. + + * It is now possible to uninstall Octave by doing a `make uninstall' + in the top level directory. + + * The Makefiles are much closer to conforming with GNU coding standards. + + * New functions: + + win_texas_lotto -- produce six unique random numbers between 1 and 50. + quad -- numerical integration. + lu -- LU factorization + qr -- QR factorization + dassl -- Solution of DAEs using DASSL. + + * New files: + + THANKS -- A list of people and organazations who have supported + the development of Octave. + + NEWS -- This file, listing recent changes. + + * Help is now available at the gnuplot prompt. +</pre> + +</body> +</html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-2.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,1274 @@ +<!doctype html public "-//IETF//DTD HTML Strict//EN"> +<html> +<head> +<title> Changes in Octave version 2 </title> +</head> + +<body> +<h1> News for Octave Version 2 </h1> +<hr> + +<h2>Summary of changes for version 2.0.17</h2> + +<p>This will probably be the last release in the 2.0.x series. There are +a few bug fixes, but the major change is to print a message saying +that Octave 2.0.x cannot be compiled with gcc 3.0.x or gcc 2.96. If +you want to build Octave 2.0.x, you will need to use gcc 2.95.x. If +you want to use gcc 3.0.x or some later version, you should be using +the Octave 2.1.35 sources or a more recent version.</p> + +<h2>Summary of changes for version 2.0.16</h2> + +<p>This is primarily a bug-fixing release.</p> + +<h2>Summary of changes for version 2.0.15</h2> + +<p>This is primarily a bug-fixing release.</p> + +<ul> +<li>If you are using GNU Emacs 19.34 or earlier, you will need to add + the following code to your ~/.emacs file in order to use Emacs + Octave mode: +<pre> + ;; Set up the custom library. + ;; taken from http://www.dina.kvl.dk/~abraham/custom/ + (eval-and-compile + (condition-case () + (require 'custom) + (error nil)) + (if (and (featurep 'custom) (fboundp 'custom-declare-variable)) + nil ;; We've got what we needed + ;; We have the old custom-library, hack around it! + (defmacro defgroup (&rest args) + nil) + (defmacro defcustom (var value doc &rest args) + (` (defvar (, var) (, value) (, doc)))))) +</pre></li> +</ul> + +<h2>Summary of changes for version 2.0.14</h2> + +This release fixes numerous bugs and adds the following new features: + +<ul> +<li>argv is now padded with blanks instead of ASCII NUL.</li> + +<li>New functions: +<dl> +<dt><b>besselh</b></dt> +Hankel functions of the first and second kind +<dt><b>airy</b></dt> +Airy functions of the first and second kind, and + their derivatives +</dl></li> + +<li>The Bessel functions now accept complex values for the argument + and any real value for the order.</li> + +<li>The value of LOADPATH set by the environment variable + OCTAVE_PATH, the -p or --path command line options, or on the + command line is no longer modified to include the default path. + Instead it is left as specified. Its default value is now ":", + which tells Octave to search the default path, and the new + built-in variable DEFAULT_LOADPATH contains the default list of + directories to search. </li> + +<li>The function file_in_path no longer does any special processing of + its PATH argument. To search LOADPATH for files, it is now + generally better to use the new function file_in_loadpath.</li> + +<li>If fread is given a skip parameter, the skip is performed after + the read instead of before (for compatibility with Matlab).</li> + +<li>The new built-in variable `crash_dumps_octave_core' controls + whether Octave writes user variables to the file `octave-core' + when it crashes or is killed by a signal. The default value is 1 + (0 if you use --traditional).</li> + +<li>If LOADPATH contains a doubled colon, the default path is inserted + in its place. This is similar to the substitution that also takes + place for leading or trailing colons in the LOADPATH.</li> + +<li>Loops of the form `for i = STRING ... endfor' are now allowed.</li> + +<li>It is now possible to set the iteration limit for lsode using + lsode_options ("step limit", N).</li> + +<li>New functions: +<dl> +<dt><b>is_complex</b></dt> +tell whether a value is complex +<dt><b>isnumeric</b></dt> +tell whether a value is a numeric object +<dt><b>isfinite</b></dt> +find finite elements of a matrix object +<dt><b>rehash</b></dt> +re-initialize the cache of directories in LOADPATH +<dt><b>graw</b></dt> +send a string to the gnuplot subprocess +</dl></li> + +<li>New functions from Kurt Hornik's Octave-ci package: +<ul> +<li>In finance (new directory): +<dl> +<dt><b>fv</b></dt> +<dd>future value of an investment</dd> +<dt><b>fvl</b></dt> +<dd>future value of an initial lump sum investment</dd> +<dt><b>irr</b></dt> +<dd>internal rate of return of an investment</dd> +<dt><b>nper</b></dt> +<dd>number of payments needed for amortizing a loan</dd> +<dt><b>npv</b></dt> +<dd>net present value of a series of payments</dd> +<dt><b>pmt</b></dt> +<dd>amount of periodic payment needed to amortize a loan</dd> +<dt><b>pv</b></dt> +<dd>present value of an investment</dd> +<dt><b>pvl</b></dt> +<dd>present value of an investment that pays off at the end</dd> +<dt><b>rate</b></dt> +<dd>rate of return of an investment</dd> +<dt><b>vol</b></dt> +<dd>volatility of financial time series data</dd> +</dl></li> + +<li>In linear-algebra: +<dl> +<dt><b>dmult</b></dt> +<dd>rescale the rows of a matrix</dd> +</dl></li> + +<li>In signal: +<dl> +<dt><b>arch_fit</b></dt> +<dd>fit an ARCH regression model</dd> +<dt><b>arch_rnd</b></dt> +<dd>simulate an ARCH process</dd> +<dt><b>arch_test</b></dt> +<dd>test for conditional heteroscedascity</dd> +<dt><b>arma_rnd</b></dt> +<dd>simulate an ARMA process</dd> +<dt><b>autocor</b></dt> +<dd>compute autocorrelations</dd> +<dt><b>autocov</b></dt> +<dd>compute autocovariances</dd> +<dt><b>autoreg_matrix</b></dt> +<dd>design matrix for autoregressions</dd> +<dt><b>bartlett</b></dt> +<dd>coefficients of the Bartlett (triangular) window</dd> +<dt><b>blackman</b></dt> +<dd>coefficients of the Blackman window</dd> +<dt><b>diffpara</b></dt> +<dd>estimate the fractional differencing parameter</dd> +<dt><b>durbinlevinson</b></dt> +<dd>perform one step of the Durbin-Levinson algorithm</dd> +<dt><b>fractdiff</b></dt> +<dd>compute fractional differences</dd> +<dt><b>hamming</b></dt> +<dd>coefficients of the Hamming window</dd> +<dt><b>hanning</b></dt> +<dd>coefficients of the Hanning window</dd> +<dt><b>hurst</b></dt> +<dd>estimate the Hurst parameter</dd> +<dt><b>periodogram</b></dt> +<dd>compute the periodogram</dd> +<dt><b>rectangle_lw</b></dt> +<dd>rectangular lag window</dd> +<dt><b>rectangle_sw</b></dt> +<dd>rectangular spectral window</dd> +<dt><b>sinetone</b></dt> +<dd>compute a sine tone</dd> +<dt><b>sinewave</b></dt> +<dd>compute a sine wave</dd> +<dt><b>spectral_adf</b></dt> +<dd>spectral density estimation</dd> +<dt><b>spectral_xdf</b></dt> +<dd>spectral density estimation</dd> +<dt><b>spencer</b></dt> +<dd>apply Spencer's 15-point MA filter</dd> +<dt><b>stft</b></dt> +<dd>short-term Fourier transform</dd> +<dt><b>synthesis</b></dt> +<dd>recover a signal from its short-term Fourier transform</dd> +<dt><b>triangle_lw</b></dt> +<dd>triangular lag window</dd> +<dt><b>triangle_sw</b></dt> +<dd>triangular spectral window</dd> +<dt><b>yulewalker</b></dt> +<dd>fit AR model by Yule-Walker method</dd> +</dl></li> + +<li>In statistics/base (new directory): +<dl> +<dt><b>center</b></dt> +<dd>center by subtracting means</dd> +<dt><b>cloglog</b></dt> +<dd>complementary log-log function</dd> +<dt><b>cor</b></dt> +<dd>compute correlations</dd> +<dt><b>cov</b></dt> +<dd>compute covariances</dd> +<dt><b>cut</b></dt> +<dd>cut data into intervals</dd> +<dt><b>iqr</b></dt> +<dd>interquartile range</dd> +<dt><b>kendall</b></dt> +<dd>kendall's rank correlation tau</dd> +<dt><b>logit</b></dt> +<dd>logit transformation</dd> +<dt><b>mean</b></dt> +<dd>compute arithmetic, geometric, and harmonic mean</dd> +<dt><b>meansq</b></dt> +<dd>compute mean square</dd> +<dt><b>moment</b></dt> +<dd>compute moments</dd> +<dt><b>ppplot</b></dt> +<dd>perform a PP-plot (probability plot)</dd> +<dt><b>probit</b></dt> +<dd>probit transformation</dd> +<dt><b>qqplot</b></dt> +<dd>perform a QQ-plot (quantile plot)</dd> +<dt><b>range</b></dt> +<dd>compute range</dd> +<dt><b>ranks</b></dt> +<dd>compute ranks</dd> +<dt><b>run_count</b></dt> +<dd>count upward runs</dd> +<dt><b>spearman</b></dt> +<dd>spearman's rank correlation rho</dd> +<dt><b>statistics</b></dt> +<dd>compute basic statistics</dd> +<dt><b>studentize</b></dt> +<dd>subtract mean and divide by standard deviation</dd> +<dt><b>table</b></dt> +<dd>cross tabulation</dd> +<dt><b>values</b></dt> +<dd>extract unique elements</dd> +<dt><b>var</b></dt> +<dd>compute variance</dd> +</dl></li> + +<li>In statistics/distributions (new directory): +<dl> +<dt><b>beta_cdf</b></dt> +<dd>CDF of the Beta distribution</dd> +<dt><b>beta_inv</b></dt> +<dd>Quantile function of the Beta distribution</dd> +<dt><b>beta_pdf</b></dt> +<dd>PDF of the Beta distribution</dd> +<dt><b>beta_rnd</b></dt> +<dd>Random deviates from the Beta distribution +</dd> +<dt><b>binomial_cdf</b></dt> +<dd>CDF of the binomial distribution</dd> +<dt><b>binomial_inv</b></dt> +<dd>Quantile function of the binomial distribution</dd> +<dt><b>binomial_pdf</b></dt> +<dd>PDF of the binomial distribution</dd> +<dt><b>binomial_rnd</b></dt> +<dd>Random deviates from the binomial distribution +</dd> +<dt><b>cauchy_cdf</b></dt> +<dd>CDF of the Cauchy distribution</dd> +<dt><b>cauchy_inv</b></dt> +<dd>Quantile function of the Cauchy distribution</dd> +<dt><b>cauchy_pdf</b></dt> +<dd>PDF of the Cauchy distribution</dd> +<dt><b>cauchy_rnd</b></dt> +<dd>Random deviates from the Cauchy distribution +</dd> +<dt><b>chisquare_cdf</b></dt> +<dd>CDF of the chi-square distribution</dd> +<dt><b>chisquare_inv</b></dt> +<dd>Quantile function of the chi-square distribution</dd> +<dt><b>chisquare_pdf</b></dt> +<dd>PDF of the chi-sqaure distribution</dd> +<dt><b>chisquare_rnd</b></dt> +<dd>Random deviates from the chi-square distribution +</dd> +<dt><b>discrete_cdf</b></dt> +<dd>CDF of a discrete distribution</dd> +<dt><b>discrete_inv</b></dt> +<dd>Quantile function of a discrete distribution</dd> +<dt><b>discrete_pdf</b></dt> +<dd>PDF of a discrete distribution</dd> +<dt><b>discrete_rnd</b></dt> +<dd>Random deviates from a discrete distribution +</dd> +<dt><b>empirical_cdf</b></dt> +<dd>CDF of the empirical distribution</dd> +<dt><b>empirical_inv</b></dt> +<dd>Quantile function of the empirical distribution</dd> +<dt><b>empirical_pdf</b></dt> +<dd>PDF of the empirical distribution</dd> +<dt><b>empirical_rnd</b></dt> +<dd>Bootstrap samples from the empirical distribution +</dd> +<dt><b>exponential_cdf</b></dt> +<dd>CDF of the exponential distribution</dd> +<dt><b>exponential_inv</b></dt> +<dd>Quantile function of the exponential distribution</dd> +<dt><b>exponential_pdf</b></dt> +<dd>PDF of the exponential distribution</dd> +<dt><b>exponential_rnd</b></dt> +<dd>Random deviates from the exponential distribution +</dd> +<dt><b>f_cdf</b></dt> +<dd>CDF of the F distribution</dd> +<dt><b>f_inv</b></dt> +<dd>Quantile function of the F distribution</dd> +<dt><b>f_pdf</b></dt> +<dd>PDF of the F distribution</dd> +<dt><b>f_rnd</b></dt> +<dd>Random deviates from the F distribution +</dd> +<dt><b>gamma_cdf</b></dt> +<dd>CDF of the Gamma distribution</dd> +<dt><b>gamma_inv</b></dt> +<dd>Quantile function of the Gamma distribution</dd> +<dt><b>gamma_pdf</b></dt> +<dd>PDF of the Gamma distribution</dd> +<dt><b>gamma_rnd</b></dt> +<dd>Random deviates from the Gamma distribution +</dd> +<dt><b>geometric_cdf</b></dt> +<dd>CDF of the geometric distribution</dd> +<dt><b>geometric_inv</b></dt> +<dd>Quantile function of the geometric distribution</dd> +<dt><b>geometric_pdf</b></dt> +<dd>PDF of the geometric distribution</dd> +<dt><b>geometric_rnd</b></dt> +<dd>Random deviates from the geometric distribution +</dd> +<dt><b>hypergeometric_cdf</b></dt> +<dd>CDF of the hypergeometric distribution</dd> +<dt><b>hypergeometric_inv</b></dt> +<dd>Random deviates from hypergeometric distribution</dd> +<dt><b>hypergeometric_pdf</b></dt> +<dd>PDF of the hypergeometric distribution</dd> +<dt><b>hypergeometric_rnd</b></dt> +<dd>Random deviates from hypergeometric distribution +</dd> +<dt><b>kolmogorov_smirnov_cdf</b></dt> +<dd>CDF of the Kolmogorov-Smirnov distribution +</dd> +<dt><b>laplace_cdf</b></dt> +<dd>CDF of the Laplace distribution</dd> +<dt><b>laplace_inv</b></dt> +<dd>Quantile function of the Laplace distribution</dd> +<dt><b>laplace_pdf</b></dt> +<dd>PDF of the Laplace distribution</dd> +<dt><b>laplace_rnd</b></dt> +<dd>Random deviates from the Laplace distribution +</dd> +<dt><b>logistic_cdf</b></dt> +<dd>CDF of the logistic distribution</dd> +<dt><b>logistic_inv</b></dt> +<dd>Quantile function of the logistic distribution</dd> +<dt><b>logistic_pdf</b></dt> +<dd>PDF of the logistic distribution</dd> +<dt><b>logistic_rnd</b></dt> +<dd>Random deviates from the logistic distribution +</dd> +<dt><b>lognormal_cdf</b></dt> +<dd>CDF of the log normal distribution</dd> +<dt><b>lognormal_inv</b></dt> +<dd>Quantile function of the log normal distribution</dd> +<dt><b>lognormal_pdf</b></dt> +<dd>PDF of the log normal distribution</dd> +<dt><b>lognormal_rnd</b></dt> +<dd>Random deviates from the log normal distribution +</dd> +<dt><b>normal_cdf</b></dt> +<dd>CDF of the normal distribution</dd> +<dt><b>normal_inv</b></dt> +<dd>Quantile function of the normal distribution</dd> +<dt><b>normal_pdf</b></dt> +<dd>PDF of the normal distribution</dd> +<dt><b>normal_rnd</b></dt> +<dd>Random deviates from the normal distribution +</dd> +<dt><b>pascal_cdf</b></dt> +<dd>CDF of the Pascal (negative binomial) distribution</dd> +<dt><b>pascal_inv</b></dt> +<dd>Quantile function of the Pascal distribution</dd> +<dt><b>pascal_pdf</b></dt> +<dd>PDF of the Pascal (negative binomial) distribution</dd> +<dt><b>pascal_rnd</b></dt> +<dd>Random deviates from the Pascal distribution +</dd> +<dt><b>poisson_cdf</b></dt> +<dd>CDF of the Poisson distribution</dd> +<dt><b>poisson_inv</b></dt> +<dd>Quantile function of the Poisson distribution</dd> +<dt><b>poisson_pdf</b></dt> +<dd>PDF of the Poisson distribution</dd> +<dt><b>poisson_rnd</b></dt> +<dd>Random deviates from the Poisson distribution +</dd> +<dt><b>stdnormal_cdf</b></dt> +<dd>CDF of the standard normal distribution</dd> +<dt><b>stdnormal_inv</b></dt> +<dd>Quantile function of standard normal distribution</dd> +<dt><b>stdnormal_pdf</b></dt> +<dd>PDF of the standard normal distribution</dd> +<dt><b>stdnormal_rnd</b></dt> +<dd>Random deviates from standard normal distribution +</dd> +<dt><b>t_cdf</b></dt> +<dd>CDF of the t distribution</dd> +<dt><b>t_inv</b></dt> +<dd>Quantile function of the t distribution</dd> +<dt><b>t_pdf</b></dt> +<dd>PDF of the t distribution</dd> +<dt><b>t_rnd</b></dt> +<dd>Random deviates from the t distribution +</dd> +<dt><b>uniform_cdf</b></dt> +<dd>CDF of the uniform distribution</dd> +<dt><b>uniform_inv</b></dt> +<dd>Quantile function of the uniform distribution</dd> +<dt><b>uniform_pdf</b></dt> +<dd>PDF of the uniform distribution</dd> +<dt><b>uniform_rnd</b></dt> +<dd>Random deviates from the uniform distribution +</dd> +<dt><b>weibull_cdf</b></dt> +<dd>CDF of the Weibull distribution</dd> +<dt><b>weibull_inv</b></dt> +<dd>Quantile function of the Weibull distribution</dd> +<dt><b>weibull_pdf</b></dt> +<dd>PDF of the Weibull distribution</dd> +<dt><b>weibull_rnd</b></dt> +<dd>Random deviates from the Weibull distribution +</dd> +<dt><b>wiener_rnd</b></dt> +<dd>Simulate a Wiener process</dd> +</dl></li> + +<li>In statistics/models (new directory): +<dl> +<dt><b>logistic_regression</b></dt> +<dd>ordinal logistic regression</dd> +<dt><b>logistic_regression_derivatives</b></dt> +<dd>derivates of log-likelihood + in logistic regression</dd> +<dt><b>logistic_regression_likelihood</b></dt> +<dd>likelihood in logistic regression</dd> +</dl></li> + +<li>In statistics/tests (new directory): +<dl> +<dt><b>anova</b></dt> +<dd>one-way analysis of variance</dd> +<dt><b>bartlett_test</b></dt> +<dd>bartlett test for homogeneity of variances</dd> +<dt><b>chisquare_test_homogeneity</b></dt> +<dd>chi-square test for homogeneity</dd> +<dt><b>chisquare_test_independence</b></dt> +<dd>chi-square test for independence</dd> +<dt><b>cor_test</b></dt> +<dd>test for zero correlation</dd> +<dt><b>f_test_regression</b></dt> +<dd>test linear hypotheses in linear + regression model</dd> +<dt><b>hotelling_test</b></dt> +<dd>test for mean of a multivariate normal</dd> +<dt><b>hotelling_test_2</b></dt> +<dd>compare means of two multivariate normals</dd> +<dt><b>kolmogorov_smirnov_test</b></dt> +<dd>one-sample Kolmogorov-Smirnov test</dd> +<dt><b>kolmogorov_smirnov_test_2</b></dt> +<dd>two-sample Kolmogorov-Smirnov test</dd> +<dt><b>kruskal_wallis_test</b></dt> +<dd>kruskal-Wallis test</dd> +<dt><b>manova</b></dt> +<dd>one-way multivariate analysis of variance</dd> +<dt><b>mcnemar_test</b></dt> +<dd>mcnemar's test for symmetry</dd> +<dt><b>prop_test_2</b></dt> +<dd>compare two proportions</dd> +<dt><b>run_test</b></dt> +<dd>run test for independence</dd> +<dt><b>sign_test</b></dt> +<dd>sign test</dd> +<dt><b>t_test</b></dt> +<dd>student's one-sample t test </dd> +<dt><b>t_test_2</b></dt> +<dd>student's two-sample t test</dd> +<dt><b>t_test_regression</b></dt> +<dd>test one linear hypothesis in linear + regression model</dd> +<dt><b>u_test</b></dt> +<dd>mann-Whitney U-test</dd> +<dt><b>var_test</b></dt> +<dd>f test to compare two variances</dd> +<dt><b>welch_test</b></dt> +<dd>welch two-sample t test</dd> +<dt><b>wilcoxon_test</b></dt> +<dd>wilcoxon signed-rank test</dd> +<dt><b>z_test</b></dt> +<dd>test for mean of a normal sample with + known variance</dd> +<dt><b>z_test_2</b></dt> +<dd>compare means of two normal samples with + known variances</dd> +</dl></li> +</ul></li> + +<li>The save command now accepts the option -append to save the + variables at the end of the file, leaving the existing contents.</li> + +<li>New command-line option --no-history (also available using the + single character option -H) inhibits saving command history.</li> + +<li>The mkoctfile script now accepts -DDEF options and passes them on + to the C and C++ compilers.</li> +</ul +> +<h2>Summary of changes for version 2.0.13</h2> + +<p>This is a bug-fixing release. There are no new user-visible features.</p> + +<h2>Summary of changes for version 2.0.12</h2> + +<ul> +<li>Tilde expansion is once again performed on the directories listed + in the LOADPATH variable.</li> + +<li>gplot now supports the `axes' qualifier that is new with gnuplot + 3.6beta.</li> + +<li>Timestamps on .m and .oct files are now only checked if a prompt + has been printed since the last timestamp check.</li> + +<li>Octave now prints a warning if a .m or .oct file has a time stamp + in the future.</li> + +<li>For matrices, x(:) now works no matter what the value of + do_fortran_indexing is.</li> + +<li>New keywords __FILE__ and __LINE__ expand to the name of the file + that is being read and the current input line number, respectively.</li> + +<li>The GNU Info reader is no longer distributed with Octave because + current releases of GNU Info now support all the features needed + by Octave. If your copy of GNU Info doesn't support the + --index-search option, you should install a newer version of GNU + Info, which is distributed as part of the GNU Texinfo package.</li> + +<li>Running `make check' should work now before you run `make install', + even if you build a copy of Octave that depends on shared versions + of the Octave libraries.</li> + +<li>Octave now uses kpathsea 3.2.</li> + +<li>The new built-in variable `kluge_procbuf_delay' specifies the number + of microseconds to delay in the parent process after forking. By + default on gnu-win32 systems, it's set to 500000 (1/2 second). On + other systems, the default value is 0. Delaying for a short time + in the parent after forking seems to avoid problems in which + communicating with subprocesses via pipes would sometimes cause + Octave to hang. I doubt that the delay is really the right + solution. If anyone has a better idea, I'd love to hear it.</li> +</ul> + +<h2>Summary of changes for version 2.0.11</h2> + +<ul> +<li>There are two new built-in variables that control how global + variables are initialized. If `initialize_global_variables' is + nonzero, global variables are initialized to the value of the + variable `default_global_variable_value'. The default value of + `initialize_global_variables' is 0 (1 if you use --traditional) + and `default_global_variable_value' is undefined (the empty matrix + if you use --traditional). The default settings are compatible + with versions of Octave before 2.0.10.</li> +</ul> + +<h2>Summary of changes for version 2.0.10</h2> + +<ul> +<li>The built-in variable `PWD' has been removed. If you need to get + the value of the current working directory, use the pwd() function + instead.</li> +<li>For compatibility with Matlab, Octave's lyap function now solves +<pre> + A*X + X*A' + C = 0 +</pre> + instead of +<pre> + A'*X + X*A + C = 0 +</pre> + To try to avoid confusion for people who are used to the way + Octave behaved in previous versions, a warning is printed the + first time lyap is called in a given session. To completely + disable the warning, simply add +<pre> + global __disable_lyap_interface_change_warning__; +</pre> + to your ~/.octaverc file. The warning will eventually disappear + for good in some future version of Octave.</li> +<li>New built-in functions for computing Bessel functions: + besseli, besselj, besselk, and bessely.</li> +<li>The gammai and betai functions are now implemented as built-in + functions rather than function files.</li> +<li>The new built-in variable `implicit_num_to_str_ok' controls + whether Octave converts expressions like `[97, 98, 99, "123"]' to + strings. The default value is 0 unless you use --traditional.</li> +<li>The new built-in variable `fixed_point_format' controls whether + Octave uses a scaled fixed-point format for displaying matrices. + The default value is 0 unless you use --traditional.</li> +<li>The function sumsq now computes sum (x .* conj (x)) for complex values.</li> +<li>Dynamically linked functions can be cleared.</li> +<li>If a .oct file has a time stamp more recent than the time that it + was loaded, it is automatically reloaded. Reloading a .oct file + may cause several functions to be cleared automatically. By + default, a warning is printed that lists the names of the + functions that will be cleared. You can suppress the message by + setting the new built-in variable `warn_reload_forces_clear' to 0.</li> +<li>Global variables are now initialized to the empty matrix, for + compatibility with Matlab.</li> +<li>Explicit initialization of global variables only happens once. + For example, after the following statements are evaluated, g still + has the value 1. +<pre> + global g = 1 + global g = 2 +</pre> + This is useful for initializing global variables that are used to + maintain state information that is shared among several functions.</li> +<li>The new built-in variable max_recursion_depth allows you to + prevent Octave from attempting infinite recursion. The default + value is 256.</li> +<li>Octave now uses readline version 2.1 and kpathsea 3.0.</li> +<li>The libreadline and libkpathsea libraries are no longer installed.</li> +<li>The libcruft, liboctave, and liboctinterp libraries are now + installed in $libdir/octave instead of just $libdir.</li> +<li>It's no longer necessary to have libg++, but you do need to have + the GNU implementation of libstdc++. If you are using gcc 2.7.2, + libstdc++ is distributed as part of libg++ 2.7.2. For later + versions, libstdc++ is distributed separately. For egcs, + libstdc++ is included with the compiler distribution.</li> +</ul> + +<h2>Summary of changes for version 2.0.9</h2> + +<p>This is a bug-fixing release, but there is one new user-visible +feature:</p> + +<ul> +<li>It is now possible to specify a label for lines in the plot key + when using the plot function. For example, +<pre> + plot (x, y, "-*;sin(x);") +</pre> + plots y vs. x using the linespoints style and sets the title of + the line in the key to be `sin(x)'</li> +</ul> + +<h2>Summary of changes for version 2.0.8</h2> + +<p>This is a bug-fixing release. There are only a few new user-visible +features.</p> + +<ul> +<li>If the argument to eig() is symmetric, Octave uses the specialized + Lapack subroutine for symmetric matrices for a significant + increase in performance.</li> +<li>It is now possible to use the mkoctfile script to create .oct + files from multiple source and object files.</li> +</ul> + +<h2>Summary of changes for version 2.0.7</h2> + +<p>This is a bug-fixing release. There are no new user-visible features.</p> + +<h2>Summary of changes for version 2.0.6</h2> + +<p>This is primarily a bug-fixing release. There are only a few new +user-visilbe features.</p> + +<ul> +<li>The new built-in variable default_eval_print_flag controls whether + Octave prints the results of commands executed by eval() that do + not end with semicolons. The default is 1.</li> +<li>The new built-in constant OCTAVE_HOME specifies the top-level + directory where Octave is installed.</li> +<li>Octave no longer includes functions to work with NPSOL or QPSOL, + because they are not free software.</li> +</ul> + +<h2>Summary of changes for version 2.0.5</h2> + +<ul> +<li>A `switch' statement is now available. See the Statements chapter + in the manual for details.</li> +<li>Commands like ls, save, and cd may now also be used as formal + parameters for functions.</li> +<li>More tests.</li> +</ul> + +<h2>Summary of changes for version 2.0.4</h2> + +<ul> +<li>It is now possible to use commands like ls, save, and cd as simple + variable names. They still cannot be used as formal parameters + for functions, or as the names of structure variables. Failed + assignments leave them undefined (you can recover the orginal + function definition using clear).</li> +<li>Is is now possible to invoke commands like ls, save, and cd as + normal functions (for example, load ("foo", "x", "y", "z")).</li> +</ul> + +<h2>Summary of changes for version 2.0.3</h2> + +<ul> +<li>The manual has been completely revised and now corresponds much + more closely to the features of the current version.</li> +<li>The return value for assignment expressions is now the RHS since + that is more consistent with the way other programming languages + work. However, Octave still prints the entire LHS value so that +<pre> + x = zeros (1, 2); + x(2) = 1 +</pre> + still prints +<pre> + x = + + 0 1 + +</pre> + but an assignment like +<pre> + z = x(2) = 1 +</pre> + sets z to 1 (not [ 0, 1 ] as in previous versions of Octave).</li> +<li>It is now much easier to make binary distributions. See the + Binary Distributions section of the manual for more details.</li> +</ul> + +<h2>Summary of changes for version 2.0.2</h2> + +<ul></li> +<li>Octave now stops executing commands from a script file if an error + is encountered.</li> +<li>The return, and break commands now cause Octave to quit executing + commands from script files. When used in invalid contexts, the + break, continue, and return commands are now simply ignored + instead of producing parse errors.</li> +<li>size ("") is now [0, 0].</li> +<li>New functions: +<dl> +<dt><b>sleep</b></dt> +<dd>pause execution for a specified number of seconds</dd> +<dt><b>usleep</b></dt> +<dd>pause execution for a specified number of microseconds</dd> +</dl></li> +</ul> +</pre> + +<h2>Summary of changes for version 2.0.1</h2> + +<p>Other than bug fixes, there were no user-visible changes in version +2.0.1. + +<h2>Summary of changes for version 2.0</h2> + +<p><ul> +<li>The set and show commands for setting and displaying gnuplot + parameters have been replaced by gset and gshow. This change will + probably break lots of things, but it is necessary to allow for + compatibility with the Matlab graphics and GUI commands in a + future version of Octave. (For now, the old set and show commands + do work, but they print an annoying warning message to try to get + people to switch to using gset.)</li> +<li>Octave has been mostly ported to Windows NT and Windows 95 using + the beta 17 release of the Cygnus GNU-WIN32 tools. Not everything + works, but it is usable. See the file README.WINDOWS for more + information.</li> +<li>Dynamic linking works on more systems using dlopen() and friends + (most modern Unix systems) or shl_load() and friends (HP/UX + systems). A simple example is provided in examples/hello.cc. + For this feature to work, you must configure Octave with + --enable-shared. You may also need to have a shared-library + version of libg++ and libstdc++.</li> +<li>New data types can be added to Octave by writing a C++ class. On + systems that support dynamic linking, new data types can be added + to an already running Octave binary. A simple example appears in + the file examples/make_int.cc. Other examples are the standard + Octave data types defined in the files src/ov*.{h,cc} and + src/op-*.cc.</li> +<li>The configure option --enable-bounds-check turns on bounds + checking on element references for Octave's internal array and + matrix classes. It's enabled by default. To disable this + feature, configure Octave with --disable-bounds-check.</li> +<li>The C-style I/O functions (fopen, fprintf, etc.) have been + rewritten to be more compatible with Matlab. The fputs function + has also been added. Usage of the *printf functions that was + allowed in previous versions of Octave should still work. + However, there is no way to make the new versions of the *scanf + functions compatible with Matlab *and* previous versions of + Octave. An optional argument to the *scanf functions is now + available to make them behave in a way that is compatible with + previous versions of Octave.</li> +<li>Octave can now read files that contain columns of numbers only, + with no header information. The name of the loaded variable is + constructed from the file name. Each line in the file must have + the same number of elements.</li> +<li>The interface to the pager has changed. The new built-in variable + `page_output_immediately' controls when Octave sends output to the + pager. If it is nonzero, Octave sends output to the pager as soon + as it is available. Otherwise, Octave buffers its output and + waits until just before the prompt is printed to flush it to the + pager.</li> +<li>Expressions of the form +<pre> + A(i,j) = x +</pre> + where X is a scalar and the indices i and j define a matrix of + elements now work as you would expect rather than giving an error. + I am told that this is how Matlab 5.0 will behave when it is + released.</li> +<li>Indexing of character strings now works.</li> +<li>The echo command has been implemented.</li> +<li>The document command is now a regular function.</li> +<li>New method for handling errors: +<pre> + try + BODY + catch + CLEANUP + end_try_catch +</pre> + Where BODY and CLEANUP are both optional and may contain any + Octave expressions or commands. The statements in CLEANUP are + only executed if an error occurs in BODY. + +<p> No warnings or error messages are printed while BODY is + executing. If an error does occur during the execution of BODY, + CLEANUP can access the text of the message that would have been + printed in the builtin constant __error_text__. This is the same + as eval (TRY, CATCH) (which may now also use __error_text__) but + it is more efficient since the commands do not need to be parsed + each time the TRY and CATCH statements are evaluated.</li> +<li>Octave no longer parses the help command by grabbing everything + after the keyword `help' until a newline character is read. To + get help for `;' or `,', now, you need to use the command + `help semicolon' or `help comma'.</li> +<li>Octave's parser now does some simple constant folding. This means + that expressions like 3*i are now evaluated only once, when a + function is compiled, and the right hand side of expressions like + a = [1,2;3,4] are treated as true matrix constants rather than + lists of elements which must be evaluated each time they are + needed.</li> +<li>Built-in variables that can take values of "true" and "false" can + now also be set to any nonzero scalar value to indicate "true", + and 0 to indicate "false".</li> +<li>New built-in variables `history_file', `history_size', and + `saving_history'.</li> +<li>New built-in variable `string_fill_char' specifies the character + to fill with when creating arrays of strings.</li> +<li>If the new built-in variable `gnuplot_has_frames' is nonzero, + Octave assumes that your copy of gnuplot includes support for + multiple plot windows when using X11. + + If the new built-in variable `gnuplot_has_multiplot' is nonzero, + Octave assumes that your copy of gnuplot has the multiplot support + that is included in recent 3.6beta releases. + + The initial values of these variables are determined by configure, + but can be changed in your startup script or at the command line + in case configure got it wrong, or if you upgrade your gnuplot + installation.</li> +<li>The new plot function `figure' allows multiple plot windows when + using newer versions of gnuplot with X11.</li> +<li>Octave now notices when the plotter has exited unexpectedly.</li> +<li>New built-in variable `warn_missing_semicolon'. If nonzero, Octave + will warn when statements in function definitions don't end in + semicolons. The default value is 0.</li> +<li>Octave now attempts to continue after floating point exceptions + or out-of-memory errors.</li> +<li>If Octave crashes, it now attempts to save all user-defined + variables in a file named `octave-core' in the current directory + before exiting.</li> +<li>It is now possible to get the values of individual option settings + for the dassl, fsolve, lsode, npsol, qpsol, and quad functions + using commands like +<pre> + dassl_reltol = dassl_options ("relative tolerance"); +</pre></li> +<li>The svd() function no longer computes the left and right singular + matrices unnecessarily. This can significantly improve + performance for large matrices if you are just looking for the + singular values.</li> +<li>The filter() function is now a built-in function.</li> +<li>New function randn() returns a pseudo-random number from a normal + distribution. The rand() and randn() functions have separate + seeds and generators.</li> +<li>Octave's command-line arguments are now available in the built-in + variable `argv'. The program name is also available in the + variables `program_invocation_name' and `program_name'. If + executing a script from the command line (e.g., octave foo.m) or + using the `#! /bin/octave' hack, the program name is set to the + name of the script.</li> +<li>New built-in variable `completion_append_char' used as the + character to append to successful command-line completion + attempts. The default is " " (a single space).</li> +<li>Octave now uses a modified copy of the readline library from + version 1.14.5 of GNU bash.</li> +<li>In prompt strings, `\H' expands to the whole host name.</li> +<li>New built-in variable `beep_on_error'. If nonzero, Octave will try + to ring your terminal's bell before printing an error message. + The default value is 0.</li> +<li>For functions defined from files, the type command now prints the + text of the file. You can still get the text reconstructed from + the parse tree by using the new option -t (-transformed).</li> +<li>New command-line argument --traditional sets the following + preference variables for compatibility with Matlab: +<pre> + PS1 = ">> " + PS2 = "" + beep_on_error = 1 + default_save_format = "mat-binary" + define_all_return_values = 1 + do_fortran_indexing = 1 + empty_list_elements_ok = 1 + implicit_str_to_num_ok = 1 + ok_to_lose_imaginary_part = 1 + page_screen_output = 0 + prefer_column_vectors = 0 + prefer_zero_one_indexing = 1 + print_empty_dimensions = 0 + treat_neg_dim_as_zero = 1 + warn_function_name_clash = 0 + whitespace_in_literal_matrix = "traditional" +</pre></li> +<li>New functions: +<dl> +<dt><b>readdir</b></dt> +<dd>returns names of files in directory as array of strings</dd> +<dt><b>mkdir</b></dt> +<dd>create a directory</dd> +<dt><b>rmdir</b></dt> +<dd>remove a directory</dd> +<dt><b>rename</b></dt> +<dd>rename a file</dd> +<dt><b>unlink</b></dt> +<dd>delete a file</dd> +<dt><b>umask</b></dt> +<dd>set permission mask for file creation</dd> +<dt><b>stat</b></dt> +<dd>get information about a file</dd> +<dt><b>lstat</b></dt> +<dd>get information about a symbolic link</dd> +<dt><b>glob</b></dt> +<dd>perform filename globbing</dd> +<dt><b>fnmatch</b></dt> +<dd>match strings with filename globbing patterns</dd> +<dt><b>more</b></dt> +<dd>turn the pager on or off</dd> +<dt><b>gammaln</b></dt> +<dd>alias for lgamma</dd> +</dl></li> +<li>New audio functions from Andreas Weingessel: +<dl> +<dt><b>lin2mu</b></dt> +<dd>linear to mu-law encoding</dd> +<dt><b>loadaudio</b></dt> +<dd>load an audio file to a vector</dd> +<dt><b>mu2lin</b></dt> +<dd>mu-law to linear encoding</dd> +<dt><b>playaudio</b></dt> +<dd>play an audio file</dd> +<dt><b>record</b></dt> +<dd>record sound and store in vector</dd> +<dt><b>saveaudio</b></dt> +<dd>save a vector as an audio file</dd> +<dt><b>setaudio</b></dt> +<dd>executes mixer shell command</dd> +</dl></li> +<li>New plotting functions from Vinayak Dutt. Ones dealing with + multiple plots on one page require features from gnuplot 3.6beta + (or later). +<dl> +<dt><b>bottom_title</b></dt> +<dd>put title at the bottom of the plot</dd> +<dt><b>mplot</b></dt> +<dd>multiplot version of plot</dd> +<dt><b>multiplot</b></dt> +<dd>switch multiple-plot mode on or off</dd> +<dt><b>oneplot</b></dt> +<dd>return to one plot per page</dd> +<dt><b>plot_border</b></dt> +<dd>put a border around plots</dd> +<dt><b>subplot</b></dt> +<dd>position multiple plots on a single page</dd> +<dt><b>subwindow</b></dt> +<dd>set subwindow position for next plot</dd> +<dt><b>top_title</b></dt> +<dd>put title at the top of the plot</dd> +<dt><b>zlabel</b></dt> +<dd>put a label on the z-axis</dd> +</dl></li> +<li>New string functions +<dl> +<dt><b>bin2dec</b></dt> +<dd>convert a string of ones and zeros to an integer</dd> +<dt><b>blanks</b></dt> +<dd>create a string of blanks</dd> +<dt><b>deblank</b></dt> +<dd>delete trailing blanks</dd> +<dt><b>dec2bin</b></dt> +<dd>convert an integer to a string of ones and zeros</dd> +<dt><b>dec2hex</b></dt> +<dd>convert an integer to a hexadecimal string</dd> +<dt><b>findstr</b></dt> +<dd>locate occurrences of one string in another</dd> +<dt><b>hex2dec</b></dt> +<dd>convert a hexadecimal string to an integer</dd> +<dt><b>index</b></dt> +<dd>return position of first occurrence a string in another</dd> +<dt><b>rindex</b></dt> +<dd>return position of last occurrence a string in another</dd> +<dt><b>split</b></dt> +<dd>divide one string into pieces separated by another</dd> +<dt><b>str2mat</b></dt> +<dd>create a string matrix from a list of strings</dd> +<dt><b>strrep</b></dt> +<dd>replace substrings in a string</dd> +<dt><b>substr</b></dt> +<dd>extract a substring</dd> +</dl> +<p> The following functions return a matrix of ones and zeros. + Elements that are nonzero indicate that the condition was true for + the corresponding character in the string array. +<dl> +<dt><b>isalnum</b></dt> +<dd>letter or a digit</dd> +<dt><b>isalpha</b></dt> +<dd>letter</dd> +<dt><b>isascii</b></dt> +<dd>ascii</dd> +<dt><b>iscntrl</b></dt> +<dd>control character</dd> +<dt><b>isdigit</b></dt> +<dd>digit</dd> +<dt><b>isgraph</b></dt> +<dd>printable (but not space character)</dd> +<dt><b>islower</b></dt> +<dd>lower case</dd> +<dt><b>isprint</b></dt> +<dd>printable (including space character)</dd> +<dt><b>ispunct</b></dt> +<dd>punctuation</dd> +<dt><b>isspace</b></dt> +<dd>whitespace</dd> +<dt><b>isupper</b></dt> +<dd>upper case</dd> +<dt><b>isxdigit</b></dt> +<dd>hexadecimal digit</dd> +</dl> +<p> These functions return new strings. +<dl> +<dt><b>tolower</b></dt> +<dd>convert to lower case</dd> +<dt><b>toupper</b></dt> +<dd>convert to upper case</dd> +</dl></li> +<li>New function, fgetl. Both fgetl and fgets accept an optional + second argument that specifies a maximum number of characters to + read, and the function fgets is now compatible with Matlab.</li> +<li>Printing in hexadecimal format now works (format hex). It is also + possible to print the internal bit representation of a value + (format bit). Note that these formats are only implemented for + numeric values.</li> +<li>Additional structure features: +<ul> +<li>Name completion now works for structures.</li> +<li>Values and names of structure elements are now printed by + default. The new built-in variable `struct_levels_to_print' + controls the depth of nested structures to print. The default + value is 2.</li> +<li>New functions: +<dl> +<dt><b>struct_contains (S, NAME)</b></dt> +<dd>returns 1 if S is a structure with element NAME; otherwise returns 0.</dd> +<dt><b>struct_elements (S)</b></dt> +<dd>returns the names of all elements of structure S in an array of + strings.</dd> +</dl></li> +</ul></li> +<li>New io/subprocess functions: +<dl> +<dt><b>fputs</b></dt> +<dd>write a string to a file with no formatting</dd> +<dt><b>popen2</b></dt> +<dd>start a subprocess with 2-way communication</dd> +<dt><b>mkfifo</b></dt> +<dd>create a FIFO special file</dd> +<dt><b>popen</b></dt> +<dd>open a pipe to a subprocess</dd> +<dt><b>pclose</b></dt> +<dd>close a pipe from a subprocess</dd> +<dt><b>waitpid</b></dt> +<dd>check the status of or wait for subprocesses</dd> +</dl></li> +<li>New time functions: +<dl> +<dt><b>asctime</b></dt> +<dd>format time structure according to local format</dd> +<dt><b>ctime</b></dt> +<dd>equivalent to `asctime (localtime (TMSTRUCT))'</dd> +<dt><b>gmtime</b></dt> +<dd>return time structure corresponding to UTC</dd> +<dt><b>localtime</b></dt> +<dd>return time structure corresponding to local time zone</dd> +<dt><b>strftime</b></dt> +<dd>print given time structure using specified format</dd> +<dt><b>time</b></dt> +<dd>return current time</dd> +</dl> +<p> The `clock' and `date' functions are now implemented in M-files + using these basic functions.</li> +<li>Access to additional Unix system calls: +<dl> +<dt><b>dup2</b></dt> +<dd>duplicate a file descriptor</dd> +<dt><b>exec</b></dt> +<dd>replace current process with a new process</dd> +<dt><b>fcntl</b></dt> +<dd>control open file descriptors</dd> +<dt><b>fork</b></dt> +<dd>create a copy of the current process</dd> +<dt><b>getpgrp</b></dt> +<dd>return the process group id of the current process</dd> +<dt><b>getpid</b></dt> +<dd>return the process id of the current process</dd> +<dt><b>getppid</b></dt> +<dd>return the process id of the parent process</dd> +<dt><b>getuid</b></dt> +<dd>return the real user id of the current process</dd> +<dt><b>getgid</b></dt> +<dd>return the real group id of the current process</dd> +<dt><b>geteuid</b></dt> +<dd>return the effective user id of the current process</dd> +<dt><b>getegid</b></dt> +<dd>return the effective group id of the current process</dd> +<dt><b>pipe</b></dt> +<dd>create an interprocess channel</dd> +</dl></li> +<li>Other new functions: +<dl> +<dt><b>commutation_matrix</b></dt> +<dd>compute special matrix form</dd> +<dt><b>duplication_matrix</b></dt> +<dd>compute special matrix form</dd> +<dt><b>common_size.m</b></dt> +<dd>bring arguments to a common size</dd> +<dt><b>completion_matches</b></dt> +<dd>perform command completion on string</dd> +<dt><b>tilde_expand</b></dt> +<dd>perform tilde expansion on string</dd> +<dt><b>meshgrid</b></dt> +<dd>compatible with Matlab's meshgrid function</dd> +<dt><b>tmpnam</b></dt> +<dd>replaces octave_tmp_file_name</dd> +<dt><b>atexit</b></dt> +<dd>register functions to be called when Octave exits</dd> +<dt><b>putenv</b></dt> +<dd>define an environment variable</dd> +<dt><b>bincoeff</b></dt> +<dd>compute binomial coefficients</dd> +<dt><b>nextpow2</b></dt> +<dd>compute the next power of 2 greater than a number</dd> +<dt><b>detrend</b></dt> +<dd>remove a best fit polynomial from data</dd> +<dt><b>erfinv</b></dt> +<dd>inverse error function</dd> +<dt><b>shift</b></dt> +<dd>perform a circular shift on the elements of a matrix</dd> +<dt><b>pow2</b></dt> +<dd>compute 2 .^ x</dd> +<dt><b>log2</b></dt> +<dd>compute base 2 logarithms</dd> +<dt><b>diff</b></dt> +<dd>compute differences of matrix elements</dd> +<dt><b>vech</b></dt> +<dd>stack columns of a matrix below the diagonal</dd> +<dt><b>vec</b></dt> +<dd>stack columns of a matrix to form a vector</dd> +<dt><b>xor</b></dt> +<dd>compute exclusive or</dd> +</dl></li> +<li>Functions for getting info from the password database on Unix systems: +<dl> +<dt><b>getpwent</b></dt> +<dd>read entry from password-file stream, opening if necessary</dd> +<dt><b>getpwuid</b></dt> +<dd>search for password entry with matching user ID</dd> +<dt><b>getpwnam</b></dt> +<dd>search for password entry with matching username</dd> +<dt><b>setpwent</b></dt> +<dd>rewind the password-file stream</dd> +<dt><b>endpwent</b></dt> +<dd>close the password-file stream</dd> +</dl></li> +<li>Functions for getting info from the group database on Unix systems: +<dl> +<dt><b>getgrent</b></dt> +<dd>read entry from group-file stream, opening if necessary</dd> +<dt><b>getgrgid</b></dt> +<dd>search for group entry with matching group ID</dd> +<dt><b>getgrnam</b></dt> +<dd>search for group entry with matching group name</dd> +<dt><b>setgrent</b></dt> +<dd>rewind the pgroup-file stream</dd> +<dt><b>endgrent</b></dt> +<dd>close the group-file stream</dd> +</dl></li> +<li>The New function octave_config_info returns a structure containing + information about how Octave was configured and compiled.</li> +<li>New function getrusage returns a structure containing system + resource usage statistics. The `cputime' function is now defined + in an M-file using getrusage.</li> +<li>The info reader is now a separate binary that runs as a + subprocess. You still need the info reader distributed with + Octave though, because there are some new command-line arguments + that are not yet available in the public release of Info.</li> +<li>There is a new built-in variable, INFO_PROGRAM, which is used as + the name of the info program to run. Its initial value is + $OCTAVE_HOME/lib/octave/VERSION/exec/ARCH/info, but that value can + be overridden by the environment variable OCTAVE_INFO_PROGRAM, or + the command line argument --info-program NAME, or by setting the + value of INFO_PROGRAM in a startup script.</li> +<li>There is a new built-in variable, EXEC_PATH, which is used as + the list of directories to search when executing subprograms. Its + initial value is taken from the environment variable + OCTAVE_EXEC_PATH (if it exists) or PATH, but that value can be + overridden by the the command line argument --exec-path PATH, or + by setting the value of EXEC_PATH in a startup script. If the + EXEC_PATH begins (ends) with a colon, the directories + $OCTAVE_HOME/lib/octave/VERSION/exec/ARCH and $OCTAVE_HOME/bin are + prepended (appended) to EXEC_PATH (if you don't specify a value + for EXEC_PATH explicitly, these special directories are prepended + to your PATH).</li> +<li>If it is present, Octave will now use an `ls-R' database file to + speed up recursive path searching. Octave looks for a file called + ls-R in the directory specified by the environment variable + OCTAVE_DB_DIR. If that is not set but the environment variable + OCTAVE_HOME is set, Octave looks in $OCTAVE_HOME/lib/octave. + Otherwise, Octave looks in the directory $datadir/octave (normally + /usr/local/lib/octave).</li> +<li>New examples directory.</li> +<li>There is a new script, mkoctfile, that can be used to create .oct + files suitable for dynamic linking.</li> +<li>Many more bug fixes.</li> +<li>ChangeLogs are now kept in each subdirectory.</li></li> +</ul> + +</body> +</html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-3.2.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,398 @@ +<pre> +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_backends ezmeshc intwarning surfl + backend 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 backend is disabled by + default. You can switch to using it 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. Please note that this backend + does not yet support text objects. Obviously, this is a necessary + feature before it can be considered usable. We are looking for + volunteers to help implement this missing feature. + + ** 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. + + ** 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. sortrows now uses a more efficient algorithm, especially + in the homegeneous case. lookup 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 in 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 in 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. +</pre>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-3.4.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,485 @@ +<pre> +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.2.4 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 `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. +</pre>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-3.6.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,213 @@ +<pre> +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 +</pre>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-3.8.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,400 @@ +<pre> +Summary of important user-visible changes for version 3.8: +--------------------------------------------------------- + + ** One of the biggest new features for Octave 3.8 is a graphical user + interface. It is the one thing that users have requested most + often over the last few years and now it is almost ready. But + because it is not quite as polished as we would like, we have + decided to wait until the 4.0.x release series before making the + GUI the default interface (until then, you can use the --force-gui + option to start the GUI). + + Given the length of time and the number of bug fixes and + improvements since the last major release Octave, we also decided + against delaying the release of all these new improvements any + longer just to perfect the GUI. So please enjoy the 3.8 release of + Octave and the preview of the new GUI. We believe it is working + reasonably well, but we also know that there are some obvious rough + spots and many things that could be improved. + + WE NEED YOUR HELP. There are many ways that you can help us fix + the remaining problems, complete the GUI, and improve the overall + user experience for both novices and experts alike: + + * If you are a skilled software developer, you can help by + contributing your time to help with Octave's development. See + http://octave.org/get-involved.html for more information. + + * If Octave does not work properly, you are encouraged + report the problems you find. See http://octave.org/bugs.html + for more information about how to report problems. + + * Whether you are a user or developer, you can help to fund the + project. Octave development takes a lot of time and expertise. + Your contributions help to ensure that Octave will continue to + improve. See http://octave.org/donate.html for more details. + + We hope you find Octave to be useful. Please help us make it even + better for the future! + + ** Octave now uses OpenGL graphics by default with FLTK widgets. If + OpenGL libraries or FLTK widgets are not available when Octave is + built, gnuplot is used. You may also choose to use gnuplot for + graphics by executing the command + + graphics_toolkit ("gnuplot") + + Adding this command to your ~/.octaverc file will set the default + for each session. + + ** Printing or saving figures with OpenGL graphics requires the + gl2ps library which is no longer distributed with Octave. The + software is widely available in most package managers. If a + pre-compiled package does not exist for your system, you can find + the current sources at http://www.geuz.org/gl2ps/. + + ** 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 + + ** Line continuations inside character strings have changed. + + The sequence '...' is no longer recognized as a line continuation + inside a character string. A backslash '\' followed by a newline + character is no longer recognized as a line continuation inside + single-quoted character strings. Inside double-quoted character + strings, a backslash followed by a newline character is still + recognized as a line continuation, but the backslash character must + be followed *immediately* by the newline character. No whitespace or + end-of-line comment may appear between them. + + ** Backslash as a continuation marker outside of double-quoted strings + is now deprecated. + + Using '\' as a continuation marker outside of double quoted strings + is now deprecated and will be removed from a future version of + Octave. When that is done, the behavior of + + (a \ + b) + + will be consistent with other binary operators. + + ** 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) + + ** Octave now has limited support for named exceptions + + The following syntax is now accepted: + + try + statements + catch exception-id + statements + end + + The exception-id is a structure with the fields "message" and + "identifier". For example + + try + error ("Octave:error-id", "error message"); + catch myerr + printf ("identifier: %s\n", myerr.identifier); + printf ("message: %s\n", myerr.message); + end_try_catch + + When classdef-style classes are added to Octave, the exception-id + will become an MException object. + + ** 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. + + ** Warning IDs renamed: + + Octave:array-as-scalar => Octave:array-to-scalar + Octave:array-as-vector => Octave:array-to-vector + + ** '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 escape sequences in single-quoted pattern + strings. In addition, the regexprep function now processes backslash + escapes in single-quoted replacement strings. For example, + + regexprep (str, '\t', '\n') + + would search the variable str for a TAB character (escape sequence \t) + and replace it with a NEWLINE (escape sequence \n). Previously the + expression would have searched for a literal '\' followed by 't' and + replaced the two characters with the sequence '\', 'n'. + + ** A TeX parser has been implemented for the FLTK toolkit and is the default + for any text object including titles and axis labels. The TeX parser is + supported only for display on a monitor, not for printing. + + A quick summary of features: + + Code Feature Example Comment + ----------------------------------------------------------------- + _ subscript H_2O formula for water + ^ exponent y=x^2 formula for parabola + \char symbol \beta Greek symbol beta + \fontname font \fontname{Arial} set Arial font + \fontsize fontsize \fontsize{16} set fontsize 16 + \color[rgb] fontcolor \color[rgb]{1 0 1} set magenta color + \bf bold \bfBold Text bold font + \it italic \itItalic Text italic font + \sl slanted \slOblique Text slanted font + \rm normal \bfBold\rmNormal normal font + {} group {\bf Bold}Normal group objects + e^{i*\pi} = -1 group objects + + ** The m-files in the plot directory have been overhauled. + + The plot functions now produce output that is nearly visually compatible + with Matlab. Plot performance has also increased, dramatically for some + functions such as comet and waitbar. Finally, the documentation for most + functions has been updated so it should be clearer both how to use a + function and when a function is appropriate. + + ** The m-files in the image directory have been overhauled. + + The principal benefit is that Octave will now no longer automatically + convert images stored with integers to doubles. Storing images as uint8 + or uint16 requires only 1/8 or 1/4 the memory of an image stored using + doubles. For certain operations, such as fft2, the image must still be + converted to double in order to work. + + Other changes include fixes to the way indexed images are read from a + colormap depending on the image class (integer images have a -1 offset to + the colormap row number). + + ** The imread and imwrite functions have been completely rewritten. + + The main changes relate to the alpha channel, support for reading and + writing of floating point images, implemented writing of indexed images, + and appending images to multipage image files. + + The issues that may arise due to backwards incompatibility are: + + * imwrite no longer interprets a length of 2 or 4 in the third dimension + as grayscale or RGB with alpha channel (a length of 4 will be saved + as a CMYK image). Alpha channel must be passed as separate argument. + + * imread will always return the colormap indexes when reading an indexed + image, even if the colormap is not requested as output. + + * transparency values are now inverted from previous Octave versions + (0 is for completely transparent instead of completely opaque). + + In addition, the function imformats has been implemented to expand + reading and writing of images of different formats through imread + and imwrite. + + ** 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. + + ** strsplit has been modified to be compatible with Matlab. There + are two instances where backward compatibility is broken. + + (1) Delimiters are now string vectors, not scalars. + + Octave's legacy behavior + + strsplit ("1 2, 3", ", ") + ans = + { + [1,1] = 1 + [1,2] = 2 + [1,3] = + [1,4] = 3 + } + + Matlab compatible behavior + + strsplit ("1 2, 3", ", ") + ans = + { + [1,1] = 1 2 + [1,2] = 3 + } + + (2) By default, Matlab treats consecutive delimiters as a single + delimiter. By default, Octave's legacy behavior was to return an + empty string for the part between the delmiters. + + Where legacy behavior is desired, the call to strsplit() may be + replaced by ostrsplit(), which is Octave's original implementation of + strsplit(). + + ** 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 error function and its derivatives has been extended to accept complex + arguments. The following functions now accept complex inputs: + + erf erfc erfcx + + In addition two new error functions erfi (imaginary error function) and + dawson (scaled imaginary error function) have been added. + + ** The glpk function has been modified to reflect changes in the GLPK + library. The "round" and "itcnt" options have been removed. The + "relax" option has been replaced by the "rtest" option. The numeric + values of error codes and of some options have also changed. + + ** The kurtosis function has changed definition to be compatible with + Matlab. It now returns the base kurtosis instead of the "excess kurtosis". + The old behavior can be had by changing scripts to normalize with -3. + + "excess kurtosis" = kurtosis (x) - 3 + + ** The moment function has changed definition to be compatible with + Matlab. It now returns the central moment instead of the raw moment. + The old behavior can be had by passing the type argument "r" for raw. + + ** The default name of the Octave crash dump file is now + "octave-workspace" instead of "octave-core". The exact name can + always be customized with the octave_core_file_name function. + + ** A citation command has been added to display information on how to + cite Octave and packages in publications. The package system will + look for and install CITATION files from packages. + + ** The java package from Octave Forge is now part of core Octave. The + following new functions are available for interacting with Java + directly from Octave: + + debug_java java_matrix_autoconversion + isjava java_unsigned_autoconversion + java2mat javaaddpath + javaArray javaclasspath + javaMethod javamem + javaObject javarmpath + usejava + + In addition, the following functions that use the Java interface + are now available (provided that Octave is compiled with support for + Java enabled): + + helpdlg listdlg questdlg + inputdlg msgbox warndlg + + ** Other new functions added in 3.8.0: + + atan2d erfi lines + base64_decode expint linsolve + base64_encode findfigs missing_component_hook + betaincinv flintmax polyeig + built_in_docstrings_file fminsearch prefdir + cmpermute gallery preferences + cmunique gco readline_re_read_init_file + colorcube hdl2struct readline_read_init_file + copyobj history_save rgbplot + dawson imformats save_default_options + dblist importdata shrinkfaces + desktop isaxes splinefit + doc_cache_create iscolormap stemleaf + ellipj isequaln strjoin + ellipke jit_debug struct2hdl + erfcinv jit_enable tetramesh + jit_startcnt waterfall + + ** Deprecated functions. + + The following functions were deprecated in Octave 3.4 and have been + removed from Octave 3.8. + + autocor dispatch is_global setstr + autocov fstat krylovb strerror + betai gammai perror values + 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): + + default_save_options java_new + gen_doc_cache java_set + interp1q java_unsigned_conversion + isequalwithequalnans javafields + java_convert_matrix javamethods + java_debug re_read_readline_init_file + java_get read_readline_init_file + java_invoke saving_history + + + 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) + + The internal class Octave_map has 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). Replacement classes are octave_map + (struct array) or octave_scalar_map for a single structure. +</pre>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-3.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,222 @@ +<!doctype html public "-//IETF//DTD HTML Strict//EN"> +<html> +<head> +<title>Notable Changes in Octave version 3</title> +<link rel="stylesheet" type="text/css" href="octave.css" /> +</head> + +<body> +<div id="title"><h1>News for Octave Version 3</h1></div> + +<ul> +<li>Compatibility with Matlab graphics is much better. We now + have some graphics features that work like Matlab's Handle + Graphics (tm): +<ul> +<li> You can make a subplot and then use the print function to + generate file with the plot.</li> + +<li> RGB line colors are supported if you use gnuplot 4.2. Octave + can still use gnuplot 4.0, but there is no way to set arbitrary + line colors with it when using the Matlab-style plot functions. + There never was any way to do this reliably with older versions + of gnuplot (whether run from Octave or not) since it only + provided a limited set to choose from, and they were terminal + dependent, so choosing color 1 with the X11 terminal would be + different from color 1 with the PostScript terminal. Valid RGB + colors for gnuplot 4.0 are the eight possible combinations of 0 + and 1 for the R, G and B values. Invalid values are all mapped + to the same color. +<p> + This also affects patch objects used in the bar, countour, meshc + and surfc functions, where the bars and contours will be + monochrome. A workaround for this is to type "colormap gmap40" + that loads a colormap that in many cases will be adequate for + simple bar and contour plots.</li> + +<li> You can control the width of lines using (for example): +<pre> + line (x, y, "linewidth", 4, "color", [1, 0, 0.5]); +</pre> + (this also shows the color feature).</li> + +<li> With gnuplot 4.2, image data is plotted with gnuplot and may be + combined with other 2-d plot data.</li> + +<li> Lines for contour plots are generated with an Octave function, so + contour plots are now 2-d plots instead of special 3-d plots, and + this allows you to plot additional 2-d data on top of a contour + plot.</li> + +<li> With the gnuplot "extended" terminals the TeX interpreter is + emulated. However, this means that the TeX interpreter is only + supported on the postscript terminals with gnuplot 4.0. Under + gnuplot 4.2 the terminals aqua, dumb, png, jpeg, gif, pm, windows, + wxt, svg and x11 are supported as well.</li> + +<li> The following plot commands are now considered obsolete and will + be removed from a future version of Octave: +<pre> + __gnuplot_set__ + __gnuplot_show__ + __gnuplot_plot__ + __gnuplot_splot__ + __gnuplot_replot__ +</pre> + Additionally, these functions no longer have any effect on plots + created with the Matlab-style plot commands + (<tt>plot</tt>, <tt>line</tt>, <tt>mesh</tt>, <tt>semilogx</tt>, + etc.). + +<li> Plot property values are not extensively checked. Specifying + invalid property values may produce unpredictible results.</li> + +<li> Octave now sends data over the same pipe that is used to send + commands to gnuplot. While this avoids the problem of + cluttering /tmp with data files, it is no longer possible to use + the mouse to zoom in on plots. This is a limitation of gnuplot, + which is unable to zoom when the data it plots is not stored in + a file. Some work has been done to fix this problem in newer + versions of gnuplot (> 4.2.2). See for example, + <a href="http://www.nabble.com/zooming-of-inline-data-tf4357017.html#a12416496">this thread</a> on the gnuplot development list. +</ul></li> + + +<li>The way Octave handles search paths has changed. Instead of + setting the built-in variable <tt>LOADPATH</tt>, you must + use <tt>addpath</tt>, <tt>rmpath</tt>, or <tt>path</tt> to + manipulate the function search path. These functions will + maintain <tt>"."</tt> at the head of the path, for compatibility + with Matlab. +<p> + Leading, trailing or doubled colons are no longer special. + Now, all elements of the search path are explicitly included in + the path when Octave starts. To display the path, use + the <tt>path</tt> function. +<p> + Path elements that end in <tt>//</tt> are no longer searched recursively. + Instead, you may use addpath and the genpath function to add an + entire directory tree to the path. For example, +<pre> + addpath (genpath ("~/octave")); +</pre> + will add ~/octave and all directories below it to the head of the + path.</li> + + +<li>Previous versions of Octave had a number of built-in variables to + control warnings (for example, <tt>warn_divide_by_zero</tt>). These + variables have been replaced by warning identifiers that are used + with the warning function to control the state of warnings. +<p> + For example, instead of writing +<pre> + warn_divide_by_zero = false; +</pre> + to disable divide-by-zero warnings, you should write +<pre> + warning ("off", "Octave:divide-by-zero"); +</pre> + You may use the same technique in your own code to control + warnings. For example, you can use +<pre> + warning ("My-package:phase-of-the-moon", + "the phase of the moon could cause trouble today"); +</pre> + to allow users to control this warning using the + <tt>"My-package:phase-of-the-moon"</tt> warning identifier. +<p> + You may also enable or disable all warnings, or turn them into + errors: +<pre> + warning ("on", "all"); + warning ("off", "all"); + warning ("error", "Octave:divide-by-zero"); + warning ("error", "all"); +</pre> + You can query the state of current warnings using +<pre> + warning ("query", ID) + warning ("query") +</pre> + (only those warning IDs which have been explicitly set are + returned). +<p> + A partial list and description of warning identifiers is available + using +<pre> + help warning_ids +</pre></li> + + +<li>All built-in variables have been converted to functions. This + change simplifies the interpreter and allows a consistent + interface to internal variables for user-defined packages and the + core functions distributed with Octave. In most cases, code that + simply accesses internal variables does not need to change. Code + that sets internal variables will change. For example, instead of + writing +<pre> + PS1 = ">> "; +</pre> + you will need to write +<pre> + PS1 (">> "); +</pre> + If you need write code that will run in both old and new versions + of Octave, you can use something like +<pre> + if (exist ("OCTAVE_VERSION") == 5) + ## New: + PS1 (">> "); + else + ## Old: + PS1 = ">> "; + endif +</pre></li> + + +<li>For compatibility with Matlab, the output order of Octave's + <tt>"system"</tt> function has changed from +<pre> + [output, status] = system (cmd); +</pre> + to +<pre> + [status, output] = system (cmd); +</pre></li> + + +<li>For compatibility with Matlab, <tt>normcdf</tt>, <tt>norminv</tt>, + <tt>normpdf</tt>, and <tt>normrnd</tt> have been modified to + compute distributions using the standard deviation instead of the + variance.</li> + + +<li>For compatibility with Matlab, the output of Octave's fsolve + function has been changed from +<pre> + [x, info, msg] = fsolve (...); +</pre> + to +<pre> + [x, fval, info] = fsolve (...); +</pre></li> + + +<li>For compatibility with Matlab, <tt>normcdf</tt>, <tt>norminv</tt>, + <tt>normpdf</tt>, and <tt>normrnd</tt> have been modified to + compute distributions using the standard deviation instead of the + variance.</li> + + +<li>For compatibility with + Matlab, <tt>gamcdf</tt>, <tt>gaminv</tt>, <tt>gampdf</tt>, + <tt>gamrnd</tt>, <tt>expcdf</tt>, <tt>expinv</tt>, <tt>exppdf</tt> + and <tt>exprnd</tt> have been modified to compute the + distributions using the standard scale factor rather than one over + the scale factor. +</ul> + +</body> +</html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/NEWS-4.0.html Thu Oct 13 17:41:24 2016 +0200 @@ -0,0 +1,339 @@ +<pre> +Summary of important user-visible changes for version 4.0: +--------------------------------------------------------- + + ** A graphical user interface is now the default when running Octave + interactively. The start-up option --no-gui will run the familiar + command line interface, and still allows use of the GUI dialogs and + qt plotting toolkit. The option --no-gui-libs runs a minimalist + command line interface that does not link with the Qt libraries and + uses the fltk toolkit for plotting. + + ** Octave now uses OpenGL graphics with Qt widgets by default. If OpenGL + libraries are not available when Octave is built, gnuplot is used. + You may choose to use the fltk or gnuplot toolkit for graphics by + executing the command + + graphics_toolkit ("fltk") + OR + graphics_toolkit ("gnuplot") + + Adding such a command to your ~/.octaverc file will set the default + for each session. + + ** A new syntax for object oriented programming termed classdef has been + introduced. See the manual for more extensive documentation of the + classdef interface. + + New keywords: + + classdef endclassdef + enumeration endenumeration + events endevents + methods endmethods + properties endproperties + + ** New audio functions and classes: + + audiodevinfo audioread sound + audioinfo audiorecorder soundsc + audioplayer audiowrite + + ** Other new classes in Octave 4.0: + + audioplayer inputParser + audiorecorder + + ** Optional stricter Matlab compatibility for ranges, diagonal matrices, + and permutation matrices. + + Octave has internal optimizations which use space-efficient storage + for the three data types above. Three new functions have been added + which control whether the optimizations are used (default), or whether + the data types are stored as full matrices. + + disable_range disable_diagonal_matrix disable_permutation_matrix + + All three optimizations are disabled if Octave is started with the + --braindead command line option. + + ** The preference + + do_braindead_shortcircuit_evaluation + + is now enabled by default. + + ** The preference + + allow_noninteger_range_as_index + + is now enabled by default and the warning ID + + Octave:noninteger-range-as-index + + is now set to "on" by default instead of "error" by default and "on" + for --traditional. + + ** The "backtrace" warning option is now enabled by default. This change + was made for Matlab compatibility. + + ** For compatibility with Matlab, the "ismatrix (x)" function now only checks + the dimension of "x". The old behaviour of "ismatrix" is obtained by + "isnumeric (x) || islogical (x) || ischar (x)". + + ** The nextpow2 function behaviour has been changed for vector inputs. + Instead of computing `nextpow2 (length (x))', it will now compute + nextpow2 for each element of the input. This change is Matlab compatible, + and also prevents bugs for "vectors" of length 1. + + ** polyeig now returns a row vector of eigenvalues rather than a matrix + with the eigenvalues on the diagonal. This change was made for Matlab + compatibility. + + ** Interpolation function changes for Matlab compatibility + + The interpolation method 'cubic' is now equivalent to 'pchip' + for interp1, interp2, and interp3. Previously, 'cubic' was equivalent + to 'spline' for interp2. This may produce different results as 'spline' + has continuous 1st and 2nd derivatives while 'pchip' only has a continuous + 1st derivative. The methods 'next' and 'previous' have been added to + interp1 for compatibility. + + ** The delaunay function has been extended to accept 3-D inputs for + Matlab compatibility. The delaunay function no longer plots the + triangulation if no output argument is requested, instead, the + triangulation is always returned. The delaunay3 function which + handles 3-D inputs has been deprecated in favor of delaunay. + + ** The trigonometric functions asin and acos return different phase values + from previous versions of Octave when the input is outside the principal + branch ([-1, 1]). If the real portion of the input is greater than 1 then + the limit from below is taken. If the real portion is less than 1 then the + limit from above is taken. This criteria is consistent with several other + numerical analysis software packages. + + ** The hyperbolic function acosh now returns values with a phase in the range + [-pi/2, +pi/2]. Previously Octave returned values in the range [0, pi]. + This is consistent with several other numerical analysis software packages. + + ** strfind changes when using empty pattern ("") for Matlab compatibility + + strfind now returns an empty array when the pattern itself is empty. + In previous versions of Octave, strfind matched at every character + location when the pattern was empty. + + NEW + strfind ("abc", "") => [] + OLD + strfind ("abc", "") => [1, 2, 3, 4] + + ** Integer formats used in the printf family of functions now work for + 64-bit integers and are more compatible with Matlab when printing + non-integer values. Now instead of truncating, Octave will switch + the effective format to '%g' in the following circumstances: + + * the value of an integer type (int8, uint32, etc.) value exceeds + the maximum for the format specifier. For '%d', the limit is + intmax ('int64') and for '%u' it is intmax ('uint64'). + + * round(x) != x or the value is outside the range allowed by the + integer format specifier. + + There is still one difference: Matlab switches to '%e' and Octave + switches to '%g'. + + ** The functions intersect, setdiff, setxor, and union now return a + column vector as output unless the input was a row vector. This change + was made for Matlab compatibility. + + ** The inpolygon function now returns true for points that are within + the polygon OR on it's edge. This change was made for Matlab + compatibility. + + ** The archive family of functions (bzip2, gzip, zip, tar) and their + unpacking routines (bunzip2, gunzip, unzip, untar, unpack) have + been recoded. Excepting unpack, the default is now to place files + in the same directory as the archive (on unpack) or as the original + files (on archiving). + + ** Qt and FLTK graphics toolkits now support offscreen rendering on Linux. + In other words, print will work even when the figure visibility is "off". + + ** Z-order stacking issues with patches, grid lines, and line object + plot markers for on screen display and printing have all been resolved. + For 2-D plots the axis grid lines can be placed on top of the plot + with set (gca, "layer", "top"). + + ** The patch graphic object has been overhauled. It now produces visual + results equivalent to Matlab even for esoteric combinations of + faces/vertices/cdata. + + ** The polar() plot function now draws a circular theta axis and + radial rho axis rather than using a rectangular x/y axis. + + ** linkprop has been completely re-coded for performance and Matlab + compatibility. It now returns a linkprop object which must be stored + in a variable for as long as the graphic objects should remain linked. + To unlink properties use 'clear hlink' where hlink is the variable + containing the linkprop object. + + ** isprime has been extended to operate on negative and complex inputs. + + ** xor has been extended to accept more than two arguments in which case + it performs cumulative XOR reduction. + + ** The following functions now support N-dimensional arrays: + + fliplr flipud rot90 rectint + + ** The new warning ID "Octave:data-file-in-path" replaces the three + previous separate warning IDs "Octave:fopen-file-in-path", + "Octave:load-file-in-path", and "Octave:md5sum-file-in-path". + + ** The warning ID Octave:singular-matrix-div has been replaced by + Octave:nearly-singular-matrix and Octave:singular-matrix. + + ** The warning ID Octave:matlab-incompatible has been replaced by + Octave:language-extension to better reflect its meaning. + + ** The warning ID Octave:broadcast has been removed. Instead automatic + broadcasting will throw an Octave:language-extension warning. This + warning ID is used for broadcasting as well as other features not + available in Matlab. + + ** Other new functions added in 4.0: + + annotation + bandwidth + cubehelix + dir_in_loadpath + flip + frame2im + get_home_directory + hgload + hgsave + ichol + ilu + im2frame + isbanded + isdiag + isstudent + istril + istriu + javachk + jit_failcnt + linkaxes + lscov + metaclass + numfields + open + ordschur + pan + qmr + rotate + rotate3d + sylvester + unsetenv + validateattributes + zoom + + ** inline() scheduled for eventual deprecation by Matlab + + Functions created through the use of inline are scheduled for deprecation + by Matlab. When this occurs Octave will continue to support inline + functions for an indeterminate amount of time before also removing support. + All new code should use anonymous functions in place of inline functions. + + ** Deprecated functions. + + The following functions have been deprecated in Octave 4.0 and will + be removed from Octave 4.4 (or whatever version is the second major + release after 4.0): + + Function | Replacement + ---------------------|------------------ + bicubic | interp2 + delaunay3 | delaunay + dump_prefs | individual preference get/set routines + find_dir_in_path | dir_in_loadpath + finite | isfinite + fmod | rem + fnmatch | glob or regexp + loadaudio | audioread + luinc | ilu or ichol + mouse_wheel_zoom | mousewheelzoom axes property + nfields | numfields + octave_tmp_file_name | tempname + playaudio | audioplayer + saveaudio | audiowrite + syl | sylvester + usage | print_usage + + allow_noninteger_range_as_index + do_braindead_shortcircuit_evaluation + setaudio + + ** The following functions were deprecated in Octave 3.8 and will be + removed from Octave 4.2 (or whatever version is the second major + release after 3.8): + + default_save_options java_new + gen_doc_cache java_unsigned_conversion + interp1q javafields + isequalwithequalnans javamethods + java_convert_matrix re_read_readline_init_file + java_debug read_readline_init_file + java_invoke saving_history + + ** The following functions were deprecated in Octave 3.6 and have been + removed from Octave 4.0. + + cut polyderiv + cor shell_cmd + corrcoef studentize + __error_text__ sylvester_matrix + error_text + + ** The following keywords were deprecated in Octave 3.8 and have been + removed from Octave 4.0 + + static + + ** The following configuration variables were deprecated in Octave 3.8 + and have been removed from Octave 4.0 + + CC_VERSION (now GCC_VERSION) + CXX_VERSION (now GXX_VERSION) + + ** The internal function atan2 of the sparse matrix class has been deprecated + in Octave 4.0 and will be removed from Octave 4.4 (or whatever version is + the second major release after 4.0). Use the Fatan2 function with sparse + inputs as a replacement. + + ** The internal class Octave_map was deprecated in Octave 3.8 and has + been removed from Octave 4.0. Replacement classes are + octave_map (struct array) or octave_scalar_map for a single structure. + + ** The configure option --enable-octave-allocator has been removed. + The internal class octave_allocator declared in oct-alloc.h has + been removed. The header remains, but is deprecated. The macros to + access the class (DECLARE_OCTAVE_ALLOCATOR, DEFINE_OCTAVE_ALLOCATOR, + and DEFINE_OCTAVE_ALLOCATOR2) are now unconditionally defined to be + empty. + + ** Octave now has OpenMP enabled by default if the system provides a + working OpenMP implementation. This allows oct-file modules to take + advantage of OpenMP if desired. This can be disabled when building + Octave with the configure option --disable-openmp. + + ** Octave now automatically truncates intermediate calculations done with + floating point values to 64 bits. Some hardware math co-processors, such + as the x87, maintain extra precision, but this leads to disagreements in + calculations when compared to reference implementations in software using + the IEEE standard for double precision. There was no measurable + performance impact to this change, but it may be disabled with the + configure option --disable-float-truncate. MinGW and Cygwin platforms, + as well as GCC compilers >= 5.0 require this feature. Non-x87 hardware, + or hardware using SSE options exclusively, can disable float truncation + if desired. +</pre>