GNU Octave

Software Screenshot:
GNU Octave
Software Details:
Version: 4.4.0 updated
Upload Date: 22 Jun 18
Developer: John W. Eaton
Distribution Type: Freeware
Downloads: 262

Rating: 2.7/5 (Total Votes: 3)

GNU Octave is an open source and freely distributed command-line software project that aims to provide a powerful, easy-to-use and extensible high-level language that can be used for handling numerical computations.

Can be used to numerically solve linear and nonlinear problems

The software can be used to numerically solve both linear and nonlinear problems, as well as to perform various numerical experiments. It is compatible with Matlab, a multi-paradigm numerical computing environment, and can be used as a batch-oriented language.

In addition, GNU Octave offers various utilities that allow you to solve common numerical linera algebra problems, manipulate polynomials, integrate ordinary functions, discover the roots of nonlinear equations, as well as to integrate ordinary differential-algebraic and differential equations.

You can use dynamically loaded modules or user-defined functions to extend GNU Octave. These can be written in Octave’s own programming language or in C, C++, Fortran, etc.

Getting started with GNU Octave

Two methods are available for installing GNU Octave on a GNU/Linux operating system. The first one is the easiest and involves searching the “octave” package in the Software Center app (e.g. Synaptic Package Manager) of your distribution.

The second method will help you install the latest version of the product, but it involves executing commands in a terminal emulator. If you're down with that, download the latest source package from Softoware or from the project’s official homepage (see link at the end of the article), save it on your PC and unpack it.

Open a terminal emulator app, run the ‘cd’ command followed by the path to the location of the extracted archive files (e.g. cd /home/softoware/octave-3.8.2), run the ‘./configure && make’ command to configure and compile the program, and then run the ‘sudo make install’ command to install it. Use it from the command-line interface by running the ‘octave’ command.

Under the hood

Taking a look under the hood of the GNU Octave program, we can notice that it is written entirely in the C++ programming language. We’ve installed it in several distributions of GNU/Linux, including Arch Linux and Ubuntu using the instruction provided in the above section. The software is compatible with 32-bit and 64-bit computer platforms.

What is new in this release:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version :

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 4.2.0:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 4.0.3:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 4.0.1:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 4.0.0:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 3.8.2:

  • One of the biggest new features for the Octave 3.8.x release series 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).

What is new in version 3.8.0:

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

What is new in version 3.4.0:

  • 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 (, =) 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.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.

What is new in version 3.2.3:

  • Octave 3.2.3 is a bug-fixing release

What is new in version 3.0.4:

  • Octave 3.0.4 is a bug-fixing release. Most bugs reported since the release of version 3.0.3 have been fixed. Please note that Octave 3.0 is significantly different from Octave 2.1.x, particularly with regard to graphics, path handling, and built-in variables.

Similar Software

ADP
ADP

17 Feb 15

Darning
Darning

20 Feb 15

Other Software of Developer John W. Eaton

Octave
Octave

2 Jun 15

Comments to GNU Octave

Comments not found
Add Comment
Turn on images!