Next: Index, Previous: How do I ...?, Up: Top
“I wrote some code for Matlab, and I want to get it running under Octave. Is there anything I should watch out for?”
or alternatively
“I wrote some code in Octave, and want to share it with Matlab users. Is there anything I should watch out for?”
which is not quite the same thing. There are still a number of differences between Octave and Matlab, however in general differences between the two are considered as bugs. Octave might consider that the bug is in Matlab and do nothing about it, but generally functionality is almost identical. If you find a difference between Octave behavior and Matlab, then you should send a description of this difference (with code illustrating the difference, if possible) to bug@octave.org.
Furthermore, Octave adds a few syntactical extensions to Matlab that might cause some issues when exchanging files between Matlab and Octave users. As both Octave and Matlab are under constant development the information in this section is subject to change at anytime.
You should also look at the page http://octave.sourceforge.net/packages.html and http://octave.sourceforge.net/doc/ that has a function reference that is up to date. You can use this function reference to see the number of octave function that are available and their Matlab compatibility.
The major differences between Octave 2.9.10 and Matlab v7.3 are:
Octave doesn't yet have nested functions. That if
function y = foo (x) y = bar(x) function y = bar (x) y = ...; end end
There was discussion in Octave of having these even prior to Matlab, and the decision was made not to have these in Octave at the time for compatibility. The above written with sub-functions functions would be
function y = foo (x) y = bar(x) end function y = bar (x) y = ...; end
Now that Matlab has recently introduced nested functions, Octave will probably have them soon as well. Till then nested functions in Octave are treated as sub-functions with the same scoping rules as sub-functions.
The authors of Octave consider the nested function scoping rules of Matlab to be more problems than they are worth as they introduce diffiult to find bugs as inadvertantly modifying a variable in a nested function that is also used in the parent is particularly easy.
There a few core Matlab syntaxes that are not accepted by Octave, these being
A large number of the Matlab core functions (ie those that are in the core and not a toolbox) are implemented, and certainly all of the commonly used ones. There are a few functions that aren't implemented, for example condest or to do with specific missing Octave functionality (gui, dll, java, activex, dde, web, and serial functions). Some of the core functions have limitations that aren't in the Matlab version. For example the interpN function can only do linear interpolation and not cubic spline, etc.. However the interp and interp2 function can.
Matlab includes a "Just-In-Time" compiler. This compiler allows the acceleration of for-loops in Matlab to almost native performance with certain restrictions. The JIT must know the return type of all functions called in the loops and so you can't include user functions in the loop of JIT optimized loops. Octave doesn't have a JIT and so to some might seem slower than Matlab. For this reason you must vectorize your code as much as possible. Matlab themselves produces a good document discussing vectorization at http://www.mathworks.com/support/tech-notes/1100/1109.html.
On a related point, there is no Octave compiler, and so you can't convert your Octave code into a binary for additional speed or distribution. There is an example of how to do this at http://www.stud.tu-ilmenau.de/~rueckn/, but this is a very early example code and would need lots of work to complete it.
Up to Octave 2.9.9 there was no support for graphic handles in Octave itself. There is in Octave 2.9.10 and later, and so the graphics between Octave and Matlab are currently in the process of converging to a common interface. Note that the basic graphic handle stuff is in place in 2.9.10, but not graphics objects like "patch", "barseries", etc.
There is no Matlab compatible GUI functions. There are a number of bindings from Octave to tcl/tk, vtk and zenity included in the octave-forge project (http://octave.sourceforge.net) for example that can be used for a GUI, but these are not Matlab compatible. This might be an issue if you intend to exchange Octave code with Matlab users.
Octave itself includes no Simulink support. Typically the simulink models lag research and are less flexible, so shouldn't really be used in a research environment. However, some Matlab users that try to use Octave complain about this lack. There is a similar package to simulink for the Octave and R projects available at http://www.scicraft.org/
Octave includes an API to the matlab MEX interface. However, as MEX is an API to the internals of Matlab and the internals of Octave differ to Matlab, there is necessarily a manipulation of the data to convert from a MEX interface to the Octave equivalent. This is notable for all complex matrices, where matlab stores complex arrays as real and imaginary parts, whereas octave respects the C99/C++ standards of co-locating the real/imag parts in memory. Also due to the way matlab allows access to the arrays passed through a pointer, the MEX interface might require that copies of arrays (even non complex ones). There were some serious memory leaks in the MEX API in Octave up to version 2.9.9, and version 2.9.10 or later should be used if posible.
Matlab recently included the possibility to have block comments. With the "%{" and "%}" markers. Octave doesn't yet have block comments, but might in the future.
There are some differences in the mat v5 file format accepted by Octave. Matlab recently introduced the "-V7.3" save option which is an hdf5 format which is particularly useful for 64-bit platforms where the standard matlab format can not correctly save variables.. Octave accepts hdf5 files, but is not yet compatible with the "-v7.3" versions produced by Matlab.
Up to version 2.9.10, Octave can't load/save the inline or function handles saved in mat-files by Matlab (though can in its own format). There is some work to fix this, but the Matlab function handle format in mat-files is undocumented and this is therefore not easy to address.
Finally, Some multi-byte unicode characters aren't yet treated in mat-files.
Octave doesn't have a profiler. Though there is a patch for a flat profiler, that might become a real profiler sometime in the future. see the thread
http://www.cae.wisc.edu/pipermail/octave-maintainers/2007-January/001685.html
for more details
Octave is a community project and so the toolboxes that exist are donated by those interested in them through the octave-forge website (http://octave.sourceforge.net). These might be lacking in certain functionality relative to the Matlab toolboxes, and might not exactly duplicate the matlab functionality or interface.
The & and | operators in Matlab short-circuit when included in an if statemant and not otherwise. Whereas in Octave only the && and || short circuit. This is due to the absence of && and || in Matlab till recently. Note that this means that
if (a | b) ... end
and
t = a | b; if t ... end
are different in Matlab. This is really a Matlab bug, but there is too much code out there that relies on this behavior to change it. Prefer the || and && operators in if statements if possible.
Note that the difference is also significant when either argument is a function with side effects or if the first argument is a scalar and the second argument is an empty matrix. For example, note the difference between
t = 1 | []; ## results in [], so... if (t) 1, end ## in if ([]), this is false.
and
if (1 | []) 1, end ## short circuits so condition is true.
Another case that is documented in the Matlab manuals is that
t = [1, 1] | [1, 2, 3]; ## error if ([1, 1] | [1, 2, 3]) 1, end ## OK
Also Matlab requires the operands of && and || to be scalar values but Octave does not (it just applies the rule that for an operand to be considered true, every element of the object must be nonzero or logically true).
Finally, note the inconsistence of thinking of the condition of an if
statement as being equivalent to all(X(:))
when X is a
matrix. This is true for all cases EXCEPT empty matrices:
if ([0, 1]) == if (all ([0, 1])) ==> i.e., condition is false. if ([1, 1]) == if (all ([1, 1])) ==> i.e., condition is true.
However,
if ([]) != if (all ([]))
because all ([]) == 1
(because, despite the name, it is really
returning true if none of the elements of the matrix are zero, and since
there are no elements, well, none of them are zero). But, somewhere
along the line, someone decided that if ([])
should be false.
Mathworks probably thought it just looks wrong to have []
be true
in this context even if you can use logical gymnastics to convince
yourself that "all" the elements of a matrix that doesn't actually have
any elements are nonzero. Octave however duplicates this behavior for if
statements containing empty matrices.
The extensions in Octave over Matlab syntax are very useful, but might cause issues when sharing with Matlab users. A list of the major extensions that should be avoided to be compatible with Matlab are
Note that using try/catch combined with rethrow(lasterror()) can not guarentee that global variables will be correctly reset, as it won't catch user interrupts with Ctrl-C. For example
global a a = 1; try _a = a; a = 2 while true end catch fprintf ('caught interrupt\n'); a = _a; rethrow (lasterror()); end
compared to
global a a = 1; unwind_protect _a = a; a = 2 while true end unwind_protect_cleanup fprintf ('caught interrupt\n'); a = _a; end
Typing Ctrl-C in the first case returns the user directly to the prompt, and the variable "a" is not reset to the save value. In the second case the variable "a" is reset correctly. Therefore matlab gives no save way of temporarily changing global variables.
sin(x)(1:10);
for example is perfectly valid
in Octave but not Matlab. To do the same in Matlab you must do
y = sin(x); y = y([1:10]);