Projects: Difference between revisions

From Octave
Jump to navigation Jump to search
(→‎Missing functions: link to category)
 
(53 intermediate revisions by 10 users not shown)
Line 1: Line 1:
The list below summarizes features or bug fixes we would like to see in Octave. if you start working steadily on a project, please let octave-maintainers@octave.org know. We might have information that could help you. You should also read the [[Contribution guidelines |Contributing Guidelines]].
The list below summarizes features or bug fixes we would like to see in Octave. This list is not exclusive -- there are many other things that might be good projects, but it might instead be something we already have. Also, some of the following items may not actually be considered good ideas now.


This list is not exclusive -- there are many other things that might be good projects, but it might instead be something we already have. Also, some of the following items may not actually be considered good ideas now. So please check with octave-maintainers@octave.org before you start working on some large project.
{{Note|If you never contributed to Octave before, we suggest to start with our [[Developer FAQ]].}}


Summer of Code students, please also see [[SoC Project Ideas]].
* Summer of Code students, please also see [[Summer of Code - Getting Started]].
* If you're looking for small project, see [[short projects]].


If you're looking for small project, something more suited to start getting involved with Octave development or to fill a boring evening, see [[short projects]]
=Numerical=


=Numerical=
* Use C++11 <random> libraries for random number generation.  Write link between Octave functions (rand, randi, randn, rande) and C++ API.  Implement RandStream objects as Matlab does.


*Improve logm, and sqrtm (see this thread: http://octave.1599824.n4.nabble.com/matrix-functions-td3137935.html)
*Improve logm, and sqrtm (see this thread: http://octave.1599824.n4.nabble.com/matrix-functions-td3137935.html)


*Improve complex mapper functions. See W. Kahan, ``Branch Cuts for Complex Elementary Functions, or Much Ado About Nothing's Sign Bit (in The State of the Art in Numerical Analysis, eds. Iserles and Powell, Clarendon Press, Oxford, 1987) for explicit trigonometric formulae.
*Use pairwise or block addition in sum() to mitigate against numerical errors without substantial performance penalty (https://en.wikipedia.org/wiki/Pairwise_summation), see bug {{bug|61143}} for prior discussion.
 
*Review implementing algorithm in this 2009 paper (https://epubs.siam.org/doi/pdf/10.1137/080738490) for xsum (sum with extra accuracy).  The existing implementation uses a 2005 paper.
 
*Improve complex mapper functions. See W. Kahan, ``Branch Cuts for Complex Elementary Functions, or Much Ado About Nothing's Sign Bit (in The State of the Art in Numerical Analysis, eds. Iserles and Powell, Clarendon Press, Oxford, 1987) for explicit trigonometric formulae. See {{patch|8172}} for a previous attempt.


*Make functions like gamma() return the right IEEE Inf or NaN values for extreme args or other undefined cases.
*Make functions like gamma() return the right IEEE Inf or NaN values for extreme args or other undefined cases.
Line 24: Line 29:


*Improve design of ODE, DAE, classes.
*Improve design of ODE, DAE, classes.
*Make QR more memory efficient for large matrices when not all the columns of Q are required (apparently this is not handled by the lapack code yet).


*Evaluate harmonics and cross-correlations of unevenly sampled and nonstationary time series, as in http://www.jstatsoft.org/v11/i02 (which has C code with interface to R). (This is now partly implemented in the [http://octave.sourceforge.net/lssa/index.html lssa] package.)
*Evaluate harmonics and cross-correlations of unevenly sampled and nonstationary time series, as in http://www.jstatsoft.org/v11/i02 (which has C code with interface to R). (This is now partly implemented in the [http://octave.sourceforge.net/lssa/index.html lssa] package.)


== General purpose Finite Element library ==
<!-- == General purpose Finite Element library ==


Octave-Forge already has a set of packages for discretizing Partial Differential operators by Finite Elements and/or Finite Volumes,
Octave-Forge already has a set of packages for discretizing Partial Differential operators by Finite Elements and/or Finite Volumes,
Line 39: Line 42:
* create new functions specifically suited for Octave
* create new functions specifically suited for Octave
* improve the efficiency of the code
* improve the efficiency of the code
The main goal for the fem-fenics package is ultimately to be merged with the FEnics project itself, so that it can remain in-sync with the main library development.
The main goal for the fem-fenics package is ultimately to be merged with the FEnics project itself, so that it can remain in-sync with the main library development. -->


== Implement solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D ==
== Implement solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D ==
Line 51: Line 54:
Details on the methods to be implemented can be found in [http://dx.doi.org/10.1145/502800.502801 this paper] on bvp4c and [http://www.jnaiam.net/new/uploads/files/014dde86eef73328e7ab674d1a32aa9c.pdf this paper] on bvp5c. Further details are available in [http://books.google.it/books/about/Nonlinear_two_point_boundary_value_probl.html?id=s_pQAAAAMAAJ&redir_esc=y this book].
Details on the methods to be implemented can be found in [http://dx.doi.org/10.1145/502800.502801 this paper] on bvp4c and [http://www.jnaiam.net/new/uploads/files/014dde86eef73328e7ab674d1a32aa9c.pdf this paper] on bvp5c. Further details are available in [http://books.google.it/books/about/Nonlinear_two_point_boundary_value_probl.html?id=s_pQAAAAMAAJ&redir_esc=y this book].


== Geometric integrators for Hamiltonian Systems ==
<!-- == Geometric integrators for Hamiltonian Systems ==


[http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration Geometric (AKA Symplectic) integrators] are useful for  
[http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration Geometric (AKA Symplectic) integrators] are useful for  
Line 72: Line 75:
* SHAKE, see [http://en.wikipedia.org/wiki/Constraint_algorithm here] or [http://dx.doi.org/10.1016/0021-9991(77)90098-5 here]
* SHAKE, see [http://en.wikipedia.org/wiki/Constraint_algorithm here] or [http://dx.doi.org/10.1016/0021-9991(77)90098-5 here]
* RATTLE, see [http://dx.doi.org/10.1016/0021-9991(83)90014-1 here] or [http://dx.doi.org/10.1002/jcc.540161003 here]
* RATTLE, see [http://dx.doi.org/10.1016/0021-9991(83)90014-1 here] or [http://dx.doi.org/10.1002/jcc.540161003 here]
-->


== Matlab-compatible ODE solvers in core-Octave ==
== Matlab-compatible ODE solvers in core-Octave ==


* <strike> Adapt "odeset" and "odeget" from the odepkg package so that the list of supported options is more Matlab-compatible, in the sense that all option names that are supported by Matlab should be available. On the other hand, Matlab returns an error if an option which is not in the list of known options is passed to "odeset", but we would rather make this a warning in order to allow for special extensions, for example for symplectic integrators. </strike>
* Improve handling of sparse Jacobians in IDE/DAE solvers '''(2021-01-21 Still an issue?  See bug {{bug|55905}}.)'''
* <strike> Adapt the interface of "ode45" in odepkg to be completely Matlab compatible, fix its code and documentation style and move it to Octave-core. </strike>
** Currently, in the IDA wrapper function __ode15__ an over conservative guess for the amount of memory to be allocated when assembling a sparse jacobian is used, essentially allocating enough space for a full jacobian then freeing the excess memory, an initial patch for fixing this has been posted on the tracker, for integrating this into Octave it must be generalized to support prior versions of SUNDIALS
* <strike> Build Matlab compatible versions of "ode15s" and "ode15i". jwe has prototype implementations [https://savannah.gnu.org/patch/?8102 here] of these built as wrappers to "dassl" and "daspk". An initial approach could be to just improve these wrappers, but eventually it would be better to have wrappers for "IDA" from the sundials library. </strike>
** Currently Jacobians passed by the user in Octave's sparse matrix format are copied into SUNDIALS own sparse matrix format. Newer versions of SUNDIALS (5.x or higher) support letting the user take care of the linear algebra data structures and methods thus removing the need for the copy. Taking advantage of this feature would improve the solver performance both in terms of memory footprint and speed.
** See also [https://computing.llnl.gov/projects/sundials/release-history SUNDIALS release history].
* Implement Matlab compatible versions of "deval".
* Implement Matlab compatible versions of "deval".


Line 85: Line 90:


The architecture consists of an Octave class interface implementing "mp" (multi-precision) objects. Arithmetic operations are forwarded to MPL using MEX files. This is totally transparent to the end user, except when displaying numbers. This implementation needs to be ported and tested under Octave.
The architecture consists of an Octave class interface implementing "mp" (multi-precision) objects. Arithmetic operations are forwarded to MPL using MEX files. This is totally transparent to the end user, except when displaying numbers. This implementation needs to be ported and tested under Octave.
== Improve logm, sqrtm, funm ==
The goal here is to implement some missing Matlab functions related to matrix functions like the [https://en.wikipedia.org/wiki/Matrix_exponential matrix exponential]. There is [https://octave.1599824.n4.nabble.com/matrix-functions-td3137935.html a general discussion] of the problem and [https://octave.1599824.n4.nabble.com/Re-GSOC-16-Improvements-to-sqrtm-logm-and-funm-td4675180.html a thread on a GSOC project that never took off] (together with [https://github.com/RickOne16/matrix working funm.m code]). A good starting point for available algorithms and open-source implementations is Higham and Deadman's  [http://eprints.maths.manchester.ac.uk/2102/1/catalog.pdf "A Catalogue of Software for Matrix Functions"].
== Improve iterative methods for sparse linear systems ==
GNU Octave currently has the following Krylov subspace methods for sparse linear systems: pcg (spd matrices) and pcr (Hermitian matrices), bicg,
bicgstab, cgs, gmres, and qmr (general matrices). The description of some of them (pcr, qmr) and their error messages are not aligned. Moreover, they have similar blocks of code (input check for instance) which can be written once and for all in common functions. The first step in this project could be a revision and a synchronization of the codes, starting from the [https://socis16octave-improveiterativemethods.blogspot.com/ SOCIS2016] project, which is already merged into Octave (cset {{cset|6266e321ef22}}).
In Matlab, some additional methods are available: minres and symmlq (symmetric matrices), bicgstabl (general matrices), lsqr (least
squares). The second step in this project could be the implementation of some of these missing functions.
The [https://www-users.cs.umn.edu/~saad/IterMethBook_2ndEd.pdf reference book by Yousef Saad] is available online.


=GUI/IDE=
=GUI/IDE=


:''See also: [[Summer of Code Project Ideas#GUI]]''
*Søren Hauberg has suggested that we need C++ code that can:
*Søren Hauberg has suggested that we need C++ code that can:
**Determine if a line of code could be fully parsed, i.e. it would return true for "plot (x, y);", but false for "while (true)".
**Determine if a line of code could be fully parsed, i.e. it would return true for "plot (x, y);", but false for "while (true)".
**Evaluate a line of code and return the output as a string (it would be best if it could provide three strings: output, warnings and errors).
**Evaluate a line of code and return the output as a string (it would be best if it could provide three strings: output, warnings and errors).
**Query defined variables, i.e. get a list of currently defined variables. Bonus points if it could tell you if anything had changed since the last time you checked the variables (could also be done with signals).
**Query defined variables, i.e. get a list of currently defined variables. Bonus points if it could tell you if anything had changed since the last time you checked the variables (could also be done with signals).
**Make the links in the "Experimental GUI info" dialog box (the one that appears when the button "More Info" is pressed) clickable. They are not clickable in the 3.8.2-2 version (at least not on Windows 7).
*Allow side-by-side editing
**Allow multiple Editor windows, so source files can be edited side-by-side within the GUI.
**Add a vertical window splitter to the Editor so you can see the initialization code at the top while you type at the bottom.
**Ensure that any particular file is only open in one tab at a time!


== Create a better (G)UI for the profiler ==
== GUI Variable Editor and Property Inspector ==


During GSoC 2011, Daniel Kraft successfully implemented a profiler for Octave. It needs a better interface and a way to generate reports. This may be done with Qt, but not necessarily, and HTML reports might also be good.
Octave has a preliminary implementation of a Variable Editor: a spreadsheet-like tool for quickly editing and visualizing variables. The initial phase of the project will be learning how the implementation was done.


== Sisotool. Create a graphical design tool for tuning closed loop control system (control pkg) ==
With the knowledge gained, the second part of the project will be to implement a Property Inspector.  This is a spreadsheet like interface to the many, many graphics properties that exist and are different on a per-object basis.  The goal would be not only the concise-display of the existing properties, but a reasonable user interface to change them.  As examples, Boolean properties should be able to be toggled with a double-click; Radio properties should have a drop-down list of only the supported options; Other properties that can be modified should have the constraints built-in (for example, Linewidth must be a scalar, while Position must be a 1x4 vector).  It would also be important to have easy access to the documentation of a property.
 
For reference, Matlab has a similar Property Inspector (https://www.mathworks.com/help/matlab/ref/inspect.html).
 
== Sisotool. Create a graphical design tool for tuning closed loop control system ([[Control package]])==


When tuning a SISO feedback system it is very helpful to be able to grab a pole or a zero and move them by dragging them with the mouse. As they are moving the software must update all the plotted lines. There should be the ability to display various graphs rlocuse, bode, step, impulse etc. and have them all change dynamically as the mouse is moving. The parameters of the compensator must be displayed and updated.
When tuning a SISO feedback system it is very helpful to be able to grab a pole or a zero and move them by dragging them with the mouse. As they are moving the software must update all the plotted lines. There should be the ability to display various graphs rlocuse, bode, step, impulse etc. and have them all change dynamically as the mouse is moving. The parameters of the compensator must be displayed and updated.
Recently, some implementation was done during [[Summer_of_Code#GSoC_2018|GSoC 2018]], see https://eriveltongualter.github.io/GSoC2018/final.html for details.


=Sparse Matrices=
=Sparse Matrices=
Line 107: Line 133:
The paper by [http://arxiv.org/abs/cs.MS/0604006 Bateman & Adler] is good reading for understanding the sparse matrix implementation.
The paper by [http://arxiv.org/abs/cs.MS/0604006 Bateman & Adler] is good reading for understanding the sparse matrix implementation.


*Improve QR factorization functions, using idea based on CSPARSE cs_dmsol.m
*Improve Matlab compatibility for {{manual|sprandsym}}.


*Improve QR factorization by replacing CXSPARSE code with SPQR code, and make the linear solve return 2-norm solutions for ill-conditioned matrices based on this new code
*Sparse logical indexing in idx_vector class so that something like <code>a = sprandn (1e6, 1e6, 1e-6); a(a<1) = 0;</code> won't cause a memory overflow.
 
*Implement fourth argument to the sprand and sprandn, and addition arguments to sprandsym that the leading brand implements.
 
*Sparse logical indexing in idx_vector class so that something like 'a=sprandn(1e6,1e6,1e-6); a(a<1) = 0' won't cause a memory overflow.


*Other missing Functions
*Other missing Functions
**<strike>symmmd</strike> (Superseded by symamd)
**<strike>colmmd</strike> (Superseded by colamd)
**<strike>cholinc (or ichol)</strike>
**<strike>luinc (or ilu)</strike>
**<strike>bicg</strike> Moved into octave-core
**<strike>gmres</strike>Moved into octave-core
**lsqr
**lsqr
**minres
**minres
**qmr (see [https://savannah.gnu.org/patch/?8569 Savannah Patch Tracker])
**symmlq
**symmlq
* Enable automatically broadcasting operators to work with sparse matrices that currently require the use of bsxfun.
== SPQR Interface ==
Octave implements QR factorization for sparse matrices, but it does so with an older "CXSPARSE" library.  This has caused fundamental issues, including segfaults as recorded here (bugs {{bug|51950}} and {{bug|57033}}).  The goal of this project is to program an interface to the API for the SQPR library (http://faculty.cse.tamu.edu/davis/suitesparse.html).  This is the same library that Matlab uses for this purpose.
*Improve QR factorization functions, using idea based on CSPARSE cs_dmsol.m
*Improve QR factorization by replacing CXSPARSE code with SPQR code, and make the linear solve return 2-norm solutions for ill-conditioned matrices based on this new code


=Strings=
=Strings=
Line 157: Line 182:
* write {{codeline|xmlread}} and {{codeline|xmlwrite}}. This could be done using [http://xerces.apache.org/xerces-c/ Xerces C++ interface] which apparently is what [http://octave.1599824.n4.nabble.com/xml-in-octave-td4663034.html Matlab uses].
* write {{codeline|xmlread}} and {{codeline|xmlwrite}}. This could be done using [http://xerces.apache.org/xerces-c/ Xerces C++ interface] which apparently is what [http://octave.1599824.n4.nabble.com/xml-in-octave-td4663034.html Matlab uses].


* Implement hdf5 for .mat files (see [http://octave.1599824.n4.nabble.com/Reading-Matlab-td4650158.html this thread]).
* Implement hdf5 for .mat files (see [http://octave.1599824.n4.nabble.com/Reading-Matlab-td4650158.html this thread]), likely a necessary step to enable saving of classdef classes.


=Interpreter=
=Interpreter=
Line 247: Line 272:


*Use nanosleep instead of usleep if it is available? Apparently nanosleep is to be preferred over usleep on Solaris systems.
*Use nanosleep instead of usleep if it is available? Apparently nanosleep is to be preferred over usleep on Solaris systems.
*<strike>Per the following discussion, allow bsxfun style singleton dimension expansion as the default behavior for the builtin element-wise operators: http://octave.1599824.n4.nabble.com/Vector-approach-to-row-margin-frequencies-tp1636361p1636367.html</strike> This is done. <strike>Now [[User:JordiGH|I]] just have to document it.</strike> This is done too!


== Improve JIT compiling ==
== Improve JIT compiling ==
Line 281: Line 304:
* Implement one-to-many (Broadcast, Scatter), many-to-one (Reduce, Gather), and many-to-many (All Reduce, Allgather) communication routines
* Implement one-to-many (Broadcast, Scatter), many-to-one (Reduce, Gather), and many-to-many (All Reduce, Allgather) communication routines


=Graphics=
= Graphics =
 
*Correctly handle case where DISPLAY is unset. Provide --no-window-system or --nodisplay (?) option. Provide --display=DISPLAY option? How will this work with gnuplot (i.e., how do we know whether gnuplot requires an X display to display graphics)?


* Implement transparency and lighting in OpenGL backend(s). A basic implementation was available in [http://octave.svn.sourceforge.net/viewvc/octave/trunk/octave-forge/extra/jhandles/ JHandles]. This needs to be ported/re-implement/re-engineered/optimized in the C++ OpenGL renderer of octave.
* Correctly handle case where DISPLAY is unset. Provide --no-window-system or --nodisplay (?) option. Provide --display=DISPLAY option? How will this work with gnuplot (i.e., how do we know whether gnuplot requires an X display to display graphics)?


* Implement a Cairo-based renderer for 2D-only graphics, with support for PS/PDF/SVG output (for printing).
* Implement a Cairo-based renderer for 2D-only graphics, with support for PS/PDF/SVG output (for printing).
Line 291: Line 312:
* On 'imagesc' plots, report the matrix values also based on the mouse position, updating on mouse moving.
* On 'imagesc' plots, report the matrix values also based on the mouse position, updating on mouse moving.


* Add map-creating capabilities similar to the Matlab [http://www.mathworks.com/help/map/functionlist.html Mapping toolbox] for inclusion in the Octave Forge [https://sourceforge.net/p/octave/mapping mapping package].
* Add map-creating capabilities similar to the Matlab [https://www.mathworks.com/help/map/functionlist.html Mapping toolbox] for inclusion in the Octave Forge [https://sourceforge.net/p/octave/mapping mapping package].


* Add data cursor to trace data values in figure.
* Add data cursor to trace data values in figure.
== Lighting ==
Implement transparency and lighting in OpenGL backend(s). A basic implementation is available in [http://octave.svn.sourceforge.net/viewvc/octave/trunk/octave-forge/extra/jhandles/ JHandles]. This needs to be ported/re-implement/re-engineered/optimized in the C++ OpenGL renderer of Octave.
== Object selection in OpenGL renderer ==
This project is about the implementation of a selection method of graphics elements within the OpenGL renderer [http://glprogramming.com/red/chapter13.html]


== Non-OpenGL renderer ==
== Non-OpenGL renderer ==


Besides the original gnuplot backend, Octave also contains an OpenGL-based renderer for advanced and more powerful 3D plots. However, OpenGL is not perfectly suited for 2D-only plots where other methods could result in better graphics. The purpose of this project is to implement an alternate graphics renderer for 2D only plots (although 3D is definitely not the focus, extending the new graphics renderer to support basic 3D features should also be taken into account). There is no particular toolkit/library that must be used, but natural candidates are:
Besides the original gnuplot backend, Octave also contains an OpenGL-based renderer for advanced and more powerful 3D plots. However, OpenGL is not perfectly suited for 2D-only plots where other methods could result in better graphics. The purpose of this project is to implement an alternate graphics renderer for 2D only plots (although 3D is definitely not the focus, extending the new graphics renderer to support basic 3D features should also be taken into account). There is no particular toolkit/library that must be used, but natural candidates are:
* [http://qt.nokia.com Qt]: the GUI is currently written in Qt and work is also in progress to provide a Qt/OpenGL based backend [https://github.com/goffioul/QtHandles]
* [http://qt.nokia.com Qt]: the GUI is currently written in Qt
* [http://en.wikipedia.org/wiki/Cairo_%28software%29 Cairo]: this library is widely used and known to provides high-quality graphics with support for PS/PDF/SVG output.
* [http://en.wikipedia.org/wiki/Cairo_%28software%29 Cairo]: this library is widely used and known to provides high-quality graphics with support for PS/PDF/SVG output.


== TeX/LaTeX markup ==
== LaTeX markup ==


Text objects in plots (like titles, labels, texts...) in the OpenGL renderer only support plain text mode without any formatting possibility. Support for TeX and/or LaTeX formatting needs to be added.
Text objects in plots (like titles, labels, texts...) in the OpenGL renderer only support plain text and TeX. The latter consists of a very limited subset of the TeX language. On the other hand, the LaTeX formatting support is expected to provide full LaTeX capabilities. There are various approaches that can be used:
 
* Use an external LaTeX engine: this is the most straightforward, but it requires users to install a LaTeX distribution and setup Octave to use it.
* The TeX formatting support actually only consists of a very limited subset of the TeX language. This can be implemented directly in C++ into Octave by extending the existing text engine, avoiding to add a dependency on a full TeX system. Essentially, support for Greek letters, super/sub-scripts, and several mathematical symbols needs to be supported.  For example,
* Use an external library that supports LaTeX syntax, e.g. [https://github.com/opencollab/jlatexmath JLaTeXMath] a Java API to display LaTeX code, [https://github.com/nathancarter/qtmathjax qtmathjax] a Qt based library that executes MathJax in a background web page.
 
* Implement our own LaTeX parser and renderer. The matplotlib project [http://matplotlib.sourceforge.net/users/usetex.html has already done this in Python] and might be used as an example of how to do this in Octave. There is also [https://github.com/jkriege2/JKQtPlotter JKQtPlotter], a Qt based plotting application which implements its own LaTeX parser/renderer in C++.
:<pre>\alpha \approx \beta_0 + \gamma^\chi</pre>
 
:Would be rendered as,
 
:&alpha; &asymp; &beta;<sub>0</sub> + &gamma;<sup>&chi;</sup>
 
:This is analogous to how special characters may be included in a wiki using html.
 
:<pre>&amp;alpha; &amp;asymp; &amp;beta;<sub>0</sub> + &amp;gamma;<sup>&amp;chi;</sup></pre>
 
:The text object's {{Codeline|extent}} for the rendered result needs to be calculated and the text placed the location specified by the text object's {{Codeline|position}} property.  An itemized list of a text objects properties can be found [http://www.gnu.org/software/octave/doc/interpreter/Text-Properties.html here].
 
* On the other hand, the LaTeX formatting support is expected to provide full LaTeX capabilities. This will require to use an external LaTeX system to produce text graphics in some format (to be specified) that is then integrated into Octave plots.
 
:The matplotlib project [http://matplotlib.sourceforge.net/users/usetex.html has already done this in Python] and might be used as an example of how to do this in Octave.  Mediawiki has also also done [http://en.wikipedia.org/wiki/Wikipedia:Texvc something similar]. There is also [http://forge.scilab.org/index.php/p/jlatexmath/ JLaTeXMath], a Java API to display LaTeX code in mathematical mode.


=History=
=History=
Line 343: Line 341:
*Fix history problems — core dump if multiple processes are writing to the same history file?
*Fix history problems — core dump if multiple processes are writing to the same history file?


=Configuration and Installation=
= Configuration and Installation =
 
*<strike> Split config.h into a part for Octave-specific configuration things (this part can be installed) and the generic HAVE_X type of configure information that should not be installed. </strike>  Now config.h and octave-config.h.
 
*Makefile changes:
**eliminate for loops
**define shell commands or eliminate them
**consolidate targets
 
*Create a docs-only distribution?
 
*<strike> Better binary packaging and distribution, especially on Windows. </strike>  Now done by MXE
 
*<strike> Octave Emacs mode needs maintenance. </strike>
 
*<strike> Convert build system to a non-recursive Automake setup. See how Makefile.am files currently include module.mk files in subdirectories, extend this concept to the entire project so there is only one top-level Makefile.am. </strike> Done, except for special dir libgnu which is the only SUBDIRS listed in configure.ac.
 
=Documentation and On-Line Help=
 
*<strike> Document new features. </strike>


*Improve the Texinfo Documentation for the interpreter. It would be useful to have lots more examples, to not have so many forward references, and to not have very many simple lists of functions.
* Makefile changes:
** eliminate for loops
** define shell commands or eliminate them
** consolidate targets


*<strike> The docs should mention something about efficiency and that using array operations is almost always a good idea for speed. </strike>
* Create a docs-only distribution?


*Doxygen documentation for the C++ classes.
=Documentation=
 
:''See [[Project - Documentation]].''
*Make index entries more consistent to improve behavior of `help -i'.
 
*Make `help -i' try to find a whole word match first.
 
*<strike> Clean up help stuff. </strike>
 
*Demo files.
 
*Document C++ sources, to make it easier for newcomers to get into writing code.
 
*Flesh out this wiki


=Tests=
=Tests=
Line 386: Line 357:
**Tests for various functions. Would be nice to have a test file corresponding to every function (see below)
**Tests for various functions. Would be nice to have a test file corresponding to every function (see below)
**Tests for element by element operators: + - .* ./ .\ .^ | & < <= == >= > != !
**Tests for element by element operators: + - .* ./ .\ .^ | & < <= == >= > != !
*** thorough tests for power operator including corner cases and strange combinations such as complex .^ range.
**Tests for boolean operators: && ||
**Tests for boolean operators: && ||
**Tests for other operators: * / \ ' .'
**Tests for other operators: * / \ ' .'
Line 396: Line 368:


* Implement a coverage tool for collecting coverage data and generating code coverage reports on m-file functions and scripts. This would be very useful for Octave development as well as for users who want a code coverage report for their own functions and scripts.
* Implement a coverage tool for collecting coverage data and generating code coverage reports on m-file functions and scripts. This would be very useful for Octave development as well as for users who want a code coverage report for their own functions and scripts.
* Implement test for plotting and graphics functions that might currently only have basic input checking and/or demos for human inspection.  Possibly create tests that probe properties of the handles created and returned by most such functions, such that test plots can be checked for correct feature size/location, etc.


We are far from even having one test for every function, so focus should be on getting the breadth of coverage first before trying to get the depth of 100% statement coverage.  As of Dec 2015, 202 of 1020 m-files have no tests.  Some of these will be plotting functions which have demos instead, but that leaves enough functions to be an interesting project.  As of Dec 2015, there are 485 instances of C++ functions which need tests.
We are far from even having one test for every function, so focus should be on getting the breadth of coverage first before trying to get the depth of 100% statement coverage.  As of Dec 2015, 202 of 1020 m-files have no tests.  Some of these will be plotting functions which have demos instead, but that leaves enough functions to be an interesting project.  As of Dec 2015, there are 485 instances of C++ functions which need tests.
Line 406: Line 380:


=Programming=
=Programming=
*<strike> Add support for listeners (addlistener, dellistener, etc) on the C++ side. </strike>
*<strike> C++ namespace for Octave library functions. </strike>


*Better error messages for missing operators?
*Better error messages for missing operators?
Line 436: Line 406:
*Use non-empty identifiers in all warnings and errors issued by Octave, see [[Easy projects#Miscellaneous]].
*Use non-empty identifiers in all warnings and errors issued by Octave, see [[Easy projects#Miscellaneous]].


*Reduce the amount of datatypes in liboctave [[Project liboctave 4.2]]
*Reduce the amount of datatypes in liboctave.
 
*Re-implement operators using templates and modern C++.  Current system evolved before templates and makes extensive use of macros to define interactions between scalar<->scalar, scalar<->matrix, scalar<->float, etc., etc.
**In liboctave, the directory to work on is liboctave/operators
**In libinterp, the directory to work on is libinterp/operators
**In libinterp, there is also xpow.cc, xdiv.cc in libinterp/corefcn


=Miscellaneous=
=Miscellaneous=
Line 462: Line 437:
=Marketing and Community=
=Marketing and Community=


*Make the website prettier. Maybe a new design, maybe a more "corporate" design (if we're heading down the "paid support for Octave" path.
* Make the Octave website/[[Project Infrastructure]] easier to maintain.
 
** FusionForge's "Submit a Snippet" and "Create A Package" would seem to be directly usable for Agora's "Post a Snippet" and "Share your Code", respectively: https://alioth.debian.org/snippet/.  It is FLOSS.
** ScipyCentral, http://scipy-central.org/ has all the features we need and is also free software.
 
*Move [https://octave.sourceforge.io/ Octave-Forge] to [https://savannah.gnu.org/projects/octave/ Savannah] so everything is hosted in the same place.
 
*For ideas, see the [http://openoffice.apache.org/orientation/intro-marketing.html Apache Open Office Introduction to Marketing]
 
* Help design a user or a developer survey [http://www.openoffice.org/marketing/ooocon2006/presentations/wednesday_c10.pdf]
 
* Help prepare and deliver presentations about Octave at colleges and universities.
 
== Finish the Agora website ==
 
In 2009, the Mathworks decided to restrict the terms of use Matlab Central, a place dedicated to Matlab collaboration. The Mathworks forbade copyleft licenses and using the "free" code found in Matlab central on anything other than Mathworks products (e.g. forbidding from using it on Octave, even if the authors of the code wanted to allow this). Thus Octave users have no place to centrally, quickly, and conveniently share Octave code. See the [[FAQ#Why_can.27t_I_use_code_from_File_Exchange_in_Octave.3F_It.27s_released_under_a_BSD_license.21|FAQ]] for more details.
 
In response to this, a website started to form, [http://agora.octave.org/ Agora Octave].


This should be relatively easy webdev in Python using [http://en.wikipedia.org/wiki/Django_%28web_framework%29 Django].
* Make it easier for newcomers to contribute.


Things to be considered when working on this:
* For marketing ideas, see the [https://openoffice.apache.org/orientation/intro-marketing.html Apache Open Office Introduction to Marketing]


* [http://octave-forge.blogspot.ie/2012/08/octconf2012-agora-and-pkg.html discussion of Agora during OctConf2012]
* Help design a user or a [https://www.openoffice.org/marketing/ooocon2006/presentations/wednesday_c10.pdf developer survey]
* [http://scipy-central.org/ Scipy Central] - a website with the same objective as Agora for Scipy. Their [https://github.com/scipy/SciPyCentral Code] is released under a BSD license. Might be useful to reuse some parts.


Most of the basic functionality of Agora is already in, but there are many ways in which it could be improved, such as implementing comment threads, giving it an email interface, or a ReSTful API which could be used from Octave for package management. See also [[Agora]]. Talk to [[User:JordiGH|Jordi]]
* Help prepare and deliver presentations and [[Publications about Octave]] at colleges and universities.


== Improve Windows binary packaging ==
== Improve Windows binary packaging ==
Line 496: Line 453:
'''Skills Required''': Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. No m-scripting or C++ necessary, beyond understanding [http://david.rothlis.net/c/compilation_model/ the C++ compilation model].
'''Skills Required''': Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. No m-scripting or C++ necessary, beyond understanding [http://david.rothlis.net/c/compilation_model/ the C++ compilation model].


== Improve Mac OS X binary packaging ==
== Improve macOS binary packaging ==


We would like to be able to easily generate binary packages for Mac OS X. Right now, it's difficult and tedious to do so. Most OS X users install Octave using one of the source-based package managers such as Homebrew or MacPorts. Any way to help us build a binary package would be appreciated. Required knowledge is understanding how building binaries in Mac OS X works. Our current approach to building binaries for Windows is to cross-compile from a GNU system using [http://mxe.cc/ MXE], something similar may be possible for OS X ([http://lilypond.org/gub/ GUB]?).
We would like to be able to easily generate binary packages for macOS. Right now, it's difficult and tedious to do so. Most OS X users install Octave using one of the source-based package managers such as Homebrew or MacPorts. Any way to help us build a binary package would be appreciated. Required knowledge is understanding how building binaries in macOS works. Our current approach to building binaries for Windows is to cross-compile from a GNU system using [http://mxe.cc/ MXE], something similar may be possible for OS X ([http://lilypond.org/gub/ GUB]?).
 
There is a third-party project called [http://octave-app.org "Octave.app"] that creates and distributes macOS builds of Octave as a Mac app bundle. It is built on top of Homebrew and a set of custom Octave-related Homebrew formuale.


'''Skills Required''': Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. If you choose to work on GUB, Python will be required. No m-scripting or C++ necessary, beyond understanding [http://david.rothlis.net/c/compilation_model/ the C++ compilation model].
'''Skills Required''': Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. If you choose to work on GUB, Python will be required. No m-scripting or C++ necessary, beyond understanding [http://david.rothlis.net/c/compilation_model/ the C++ compilation model].
Line 504: Line 463:
=Performance=
=Performance=


*A profiler for Octave would be a very useful tool. And now we have one! But it really needs a better interface.
* Having {{Codeline|parfor}} functioning would speed code development and execution now that multicore architectures are widespread. See [http://octave.1599824.n4.nabble.com/Parfor-td4630575.html here] and [http://stackoverflow.com/questions/24970519/how-to-use-parallel-for-loop-in-octave-or-scilab here]. Existing code from the [[Parallel package | parallel]] and [http://octave.sourceforge.net/mpi/index.html mpi] packages could perhaps be adapted for this.
*Having {{Codeline|parfor}} functioning would speed code development and execution now that multicore architectures are widespread. See [http://octave.1599824.n4.nabble.com/Parfor-td4630575.html here] and [http://stackoverflow.com/questions/24970519/how-to-use-parallel-for-loop-in-octave-or-scilab here]. Existing code from the [[Parallel package | parallel]] and [http://octave.sourceforge.net/mpi/index.html mpi] packages could perhaps be adapted for this.
* Develop a performance benchmark for Octave (interpreter, load/save, plotting, etc., but not simply tests of underlying libraries such as BLAS or LAPACK).  This benchmark could be run periodically to make sure that changes during development do not introduce regressions in performance.


=Packaging=
= Octave Package management =
 
[[Packages]] are extensions for Octave.  To get those extension to work with Octave, there is a single function, {{manual|pkg}}, which does pretty much everything.
This function has a few limitations which are hard to implement with the current codebase, and will most likely require a full rewrite.
A major step forward for a rewritten package manager is the [https://github.com/apjanke/octave-packajoozle/ "packajoozle" project] by Andrew Janke.
 
The planned improvements are:
 
* install and update from repositories (hg and git)
* automatic handling of dependencies
* easily load, update or check specific package versions
* management of tests and demos in C++ sources of packages
* more flexibility on dependencies, e.g., dependent on specific Octave build options or being dependent in one of multiple packages
* support for multiple version packages
* support for multiple Octave installs
* support for system-wide and user installed packages
* testing packages (<code>pkg test <package-name></code>)
* improved metadata acquisition (<code>pkg list -forge</code>) from https://octave.sourceforge.io/


* create a system that allows packages to deprecate functions as in core. Possibilities are:
* create a system that allows packages to deprecate functions as in core. Possibilities are:
Line 520: Line 496:
** subdirectories with makefiles and top level make command of: cd <subdir> && ${MAKE}... ok as a substitute?
** subdirectories with makefiles and top level make command of: cd <subdir> && ${MAKE}... ok as a substitute?
* make pkg able to supply extra configure and make flags, useful for distributions, including -j for make (pkg now passes --jobs=N automatically, CFLAGS and CXXFLAGS environment variables are already respected, what's missing?)
* make pkg able to supply extra configure and make flags, useful for distributions, including -j for make (pkg now passes --jobs=N automatically, CFLAGS and CXXFLAGS environment variables are already respected, what's missing?)
The main objective of this project is to make {{manual|pkg}} more user friendly and to make it a tool to foster third party participation in Octave.
However, the current {{manual|pkg}} also performs some maintenance functions which it probably should not.
Instead a package for developers should be created with such tools.
To do this enhancement effectively, a refactoring of the current {{codeline|pkg}} code will be needed (see [https://github.com/apjanke/octave-packajoozle/ "packajoozle" project]).
Many of these problems have been solved in other languages.
Familiarity with how other languages handle this problem will be useful to come up with elegant solutions.
In some cases, there are standards to follow.
For example, there are specifications published by freedesktop.org about where files should go ([http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html base directory spec]), and Windows seems to have its own standards.
See bugs {{bug|36477}} and {{bug|40444}} for more details.
In addition, package names may start to collide very easily.
One horrible way to work around this by is choosing increasingly complex package names that give no hint on the package purpose.
An option is providing an "Authority" category like Perl 6 does.
Nested packages is also an easy way to provide packages for specialized subjects (think {{codeline|image::morphology}}).
A new {{manual|pkg}} would think all this things now, or allow their implementation at a later time.
Read the [[OEP:pkg|unfinished plan]] for more details.


=Preferences=
=Preferences=
Line 545: Line 539:
** RESOLUTION
** RESOLUTION
* Searching the m-files for use of {{Codeline|persistent}} should turn up other opportunities to use preferences.
* Searching the m-files for use of {{Codeline|persistent}} should turn up other opportunities to use preferences.
=Profiler Enhancement=
Octave has a built in {{manual|profile|profiler}} thanks to a [[Summer of Code#GSoC 2011 |  successful 2011 GSOC project by Daniel Kraft]].  But it really could use:
* Better granularity:
** It aggregates all calls to a function within at each level of the code, providing no way to know which call to a function might be more 'expensive'.
** It aggregates all non-function-call overhead into time spent on 'self' without further detail to the user on what might be causing that overhead.
** Associating time spent/function call count to line number would be a big plus.
* A better interface. 
** The current CLI tool is good at determining time spent on function calls, providing both a summary output with {{manual|profshow}} and an interactive prompt that lets you dive down levels in the code with {{manual|profexplore}}. But this suffers from the aggregation limits mentioned above.
** The profiler was written before the stable Octave GUI was released with Octave 4.0. This GUI now includes a built in editor with hooks to the interpreter. Better integration of the profiler output to the Octave GUI would be a significant functional improvement. (Current GUI integration is limited to an indicator light that shows the profiler is running.)
** Enhancements are not strictly limited to using the current Octave GUI/Editor. Whatever helps users connect execution time to code location would be good.


=Bugs=
=Bugs=

Latest revision as of 22:42, 28 June 2023

The list below summarizes features or bug fixes we would like to see in Octave. This list is not exclusive -- there are many other things that might be good projects, but it might instead be something we already have. Also, some of the following items may not actually be considered good ideas now.

Info icon.svg
If you never contributed to Octave before, we suggest to start with our Developer FAQ.

Numerical[edit]

  • Use C++11 <random> libraries for random number generation. Write link between Octave functions (rand, randi, randn, rande) and C++ API. Implement RandStream objects as Matlab does.
  • Improve complex mapper functions. See W. Kahan, ``Branch Cuts for Complex Elementary Functions, or Much Ado About Nothing's Sign Bit (in The State of the Art in Numerical Analysis, eds. Iserles and Powell, Clarendon Press, Oxford, 1987) for explicit trigonometric formulae. See #8172 for a previous attempt.
  • Make functions like gamma() return the right IEEE Inf or NaN values for extreme args or other undefined cases.
  • Improve sqp.
  • Fix CollocWt? to handle Laguerre polynomials. Make it easy to extend it to other polynomial types.
  • Add optional arguments to colloc so that it's not restricted to Legendre polynomials.
  • Move rand, eye, xpow, xdiv, etc., functions to the matrix classes.
  • Improve design of ODE, DAE, classes.
  • Evaluate harmonics and cross-correlations of unevenly sampled and nonstationary time series, as in http://www.jstatsoft.org/v11/i02 (which has C code with interface to R). (This is now partly implemented in the lssa package.)


Implement solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D[edit]

The project will deliver a solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D similar to Matlab's function pdepe. A good starting point is the method of lines for which you can find more details here and here, whereas an example implementation can be found here. In addition, this page provides some useful material.

Implement solver for 1D nonlinear boundary value problems[edit]

The project will complete the implementation of the bvp4c solver that is already available in an initial version in the odepkg package by adding a proper error estimator and will implement a matlab-compatible version of the bvp5c solver. Details on the methods to be implemented can be found in this paper on bvp4c and this paper on bvp5c. Further details are available in this book.


Matlab-compatible ODE solvers in core-Octave[edit]

  • Improve handling of sparse Jacobians in IDE/DAE solvers (2021-01-21 Still an issue? See bug #55905.)
    • Currently, in the IDA wrapper function __ode15__ an over conservative guess for the amount of memory to be allocated when assembling a sparse jacobian is used, essentially allocating enough space for a full jacobian then freeing the excess memory, an initial patch for fixing this has been posted on the tracker, for integrating this into Octave it must be generalized to support prior versions of SUNDIALS
    • Currently Jacobians passed by the user in Octave's sparse matrix format are copied into SUNDIALS own sparse matrix format. Newer versions of SUNDIALS (5.x or higher) support letting the user take care of the linear algebra data structures and methods thus removing the need for the copy. Taking advantage of this feature would improve the solver performance both in terms of memory footprint and speed.
    • See also SUNDIALS release history.
  • Implement Matlab compatible versions of "deval".

High Precision Arithmetic Computation[edit]

The Linear Algebra Fortran libraries used by Octave make use of of single (32 bits) and double (64 bits) precision floating point numbers. Many operations are stopped when matrices condition number goes below 1e-16: such matrices are considered as ill-conditioned. There are cases where this is not enough, for instance simulations implying chemical concentrations covering the range 10^4 up to 10^34. There are a number of ways to increase the numerical resolution, like f.i. make use of 128 bits quadruple precision numbers available in GFortran. A simpler option is to build an interface over Gnu MPL arbitrary precision library, which is used internally by gcc and should be available on any platform where gcc runs. Such approach has been made available for MatLab under the name mptoolbox and is licensed under a BSD license. The author kindly provided a copy of the latest version and agreed to have it ported under Octave and re-distributed under GPL v3.0

The architecture consists of an Octave class interface implementing "mp" (multi-precision) objects. Arithmetic operations are forwarded to MPL using MEX files. This is totally transparent to the end user, except when displaying numbers. This implementation needs to be ported and tested under Octave.

Improve logm, sqrtm, funm[edit]

The goal here is to implement some missing Matlab functions related to matrix functions like the matrix exponential. There is a general discussion of the problem and a thread on a GSOC project that never took off (together with working funm.m code). A good starting point for available algorithms and open-source implementations is Higham and Deadman's "A Catalogue of Software for Matrix Functions".

Improve iterative methods for sparse linear systems[edit]

GNU Octave currently has the following Krylov subspace methods for sparse linear systems: pcg (spd matrices) and pcr (Hermitian matrices), bicg, bicgstab, cgs, gmres, and qmr (general matrices). The description of some of them (pcr, qmr) and their error messages are not aligned. Moreover, they have similar blocks of code (input check for instance) which can be written once and for all in common functions. The first step in this project could be a revision and a synchronization of the codes, starting from the SOCIS2016 project, which is already merged into Octave (cset 6266e321ef22).

In Matlab, some additional methods are available: minres and symmlq (symmetric matrices), bicgstabl (general matrices), lsqr (least squares). The second step in this project could be the implementation of some of these missing functions.

The reference book by Yousef Saad is available online.

GUI/IDE[edit]

  • Søren Hauberg has suggested that we need C++ code that can:
    • Determine if a line of code could be fully parsed, i.e. it would return true for "plot (x, y);", but false for "while (true)".
    • Evaluate a line of code and return the output as a string (it would be best if it could provide three strings: output, warnings and errors).
    • Query defined variables, i.e. get a list of currently defined variables. Bonus points if it could tell you if anything had changed since the last time you checked the variables (could also be done with signals).
  • Allow side-by-side editing
    • Allow multiple Editor windows, so source files can be edited side-by-side within the GUI.
    • Add a vertical window splitter to the Editor so you can see the initialization code at the top while you type at the bottom.
    • Ensure that any particular file is only open in one tab at a time!

GUI Variable Editor and Property Inspector[edit]

Octave has a preliminary implementation of a Variable Editor: a spreadsheet-like tool for quickly editing and visualizing variables. The initial phase of the project will be learning how the implementation was done.

With the knowledge gained, the second part of the project will be to implement a Property Inspector. This is a spreadsheet like interface to the many, many graphics properties that exist and are different on a per-object basis. The goal would be not only the concise-display of the existing properties, but a reasonable user interface to change them. As examples, Boolean properties should be able to be toggled with a double-click; Radio properties should have a drop-down list of only the supported options; Other properties that can be modified should have the constraints built-in (for example, Linewidth must be a scalar, while Position must be a 1x4 vector). It would also be important to have easy access to the documentation of a property.

For reference, Matlab has a similar Property Inspector (https://www.mathworks.com/help/matlab/ref/inspect.html).

Sisotool. Create a graphical design tool for tuning closed loop control system (Control package)[edit]

When tuning a SISO feedback system it is very helpful to be able to grab a pole or a zero and move them by dragging them with the mouse. As they are moving the software must update all the plotted lines. There should be the ability to display various graphs rlocuse, bode, step, impulse etc. and have them all change dynamically as the mouse is moving. The parameters of the compensator must be displayed and updated. Recently, some implementation was done during GSoC 2018, see https://eriveltongualter.github.io/GSoC2018/final.html for details.

Sparse Matrices[edit]

The paper by Bateman & Adler is good reading for understanding the sparse matrix implementation.

  • Sparse logical indexing in idx_vector class so that something like a = sprandn (1e6, 1e6, 1e-6); a(a<1) = 0; won't cause a memory overflow.
  • Other missing Functions
    • lsqr
    • minres
    • symmlq
  • Enable automatically broadcasting operators to work with sparse matrices that currently require the use of bsxfun.

SPQR Interface[edit]

Octave implements QR factorization for sparse matrices, but it does so with an older "CXSPARSE" library. This has caused fundamental issues, including segfaults as recorded here (bugs #51950 and #57033). The goal of this project is to program an interface to the API for the SQPR library (http://faculty.cse.tamu.edu/davis/suitesparse.html). This is the same library that Matlab uses for this purpose.

  • Improve QR factorization functions, using idea based on CSPARSE cs_dmsol.m
  • Improve QR factorization by replacing CXSPARSE code with SPQR code, and make the linear solve return 2-norm solutions for ill-conditioned matrices based on this new code

Strings[edit]

  • Consider making octave_print_internal() print some sort of text representation for unprintable characters instead of sending them directly to the terminal. (But don't do this for fprintf!)
  • Consider changing the default value of `string_fill_char' from SPC to NUL.

Other Data Types[edit]

  • Template functions for mixed-type ops.
  • Convert other functions for use with the floating point type including quad, dasrt, daspk, etc.

Input/Output[edit]

  • Make fread and fwrite work for complex data. Iostreams based versions of these functions would also be nice, and if you are working on them, it would be good to support other size specifications (integer*2, etc.).
  • Move some pr-output stuff to liboctave.
  • Make the cutoff point for changing to packed storage a user-preference variable with default value 8192.
  • Complain if there is not enough disk space available (I think there is simply not enough error checking in the code that handles writing data).
  • Make it possible to tie arbitrary input and output streams together, similar to the way iostreams can be tied together.
  • Expand imwrite options. This shouldn't be too hard to implement, since it's wrapped around GraphicsMagick.
  • Extend Octave functions to work on stored arrays that are too big to fit in RAM, similar to available R packages.
  • Implement hdf5 for .mat files (see this thread), likely a necessary step to enable saving of classdef classes.

Interpreter[edit]

The interpreter is written in C++, undocumented. There are many possible projects associated with it.

Required skills: Very good C and C++ knowledge, possibly also understanding of GNU bison and flex. Understanding how compilers and interpreters are made plus being able to understand how to use a profiler and a debugger will probably be essential skills.

  • Allow customization of the debug prompt.
  • Fix the parser so that
  if (expr) 'this is a string' end

is parsed as IF expr STRING END. (see this post on the mailing list)

  • Clean up functions in input.cc that handle user input (there currently seems to be some unnecessary duplication of code and it seems overly complex).
  • Consider allowing an arbitrary property list to be attached to any variable. This could be a more general way to handle the help string that can currently be added with `document'.
  • Allow more command line options to be accessible as built-in variables (--echo-commands, etc.).
  • Make the interpreter run faster.
  • Allow arbitrary lower bounds for array indexing.
  • Improve performance of recursive function calls.
  • Improve the way ignore_function_time_stamp works to allow selecting by individual directories or functions.
  • Add a command-line option to tell Octave to just do syntax checking and not execute statements.
  • Clean up symtab and variable stuff.
  • Input stream class for parser files -- must manage buffers for flex and context for global variable settings.
  • make parser do more semantic checking, continue after errors when compiling functions, etc.
  • Make LEXICAL_ERROR have a value that is the error message for parse_error() to print?
  • Add a run-time alias mechanism that would allow things like alias fun function_with_a_very_long_name so that `function_with_a_very_long_name' could be invoked as `fun'.
  • Allow local changes to variables to be written more compactly than is currently possible with unwind_protect. For example,
      function f ()
          local prefer_column_vectors = something;
          ...
      endfunction

would be equivalent to

       function f ()
          save_prefer_column_vectors = prefer_column_vectors;
          unwind_protect
             prefer_column_vectors = something;
             ...
          unwind_protect_cleanup
              prefer_column_vectors = save_prefer_column_vectors;
          end_unwind_protect
       endfunction


  • Fix all function files to check for bogus inputs (wrong number or types of input arguments, wrong number of output arguments).
  • Handle options for built-in functions more consistently.
  • Too much time is spent allocating and freeing memory. What can be done to improve performance?
 Use move constructors rather than copy constructors for things like dim_vectors which are repeatedly created just to initialize Array or Matrix objects.
  • Error output from Fortran code is ugly. Something should be done to make it look better.
  • It would be nice if output from the Fortran routines could be passed through the pager.
  • Attempt to recognize common subexpressions in the parser.
  • Consider making it possible to specify an empty matrix with a syntax like [](e1, e2). Of course at least one of the expressions must be zero...
  • Rewrite whos and the symbol_record_info class. Write a built-in function that gives all the basic information, then write who and whos as M-files.
  • On systems that support matherr(), make it possible for users to enable the printing of warning messages.
  • Make it possible to mark variables and functions as read-only.
  • Make it possible to write a function that gets a reference to a matrix in memory and change one or more elements without generating a second copy of the data.
  • Use nanosleep instead of usleep if it is available? Apparently nanosleep is to be preferred over usleep on Solaris systems.

Improve JIT compiling[edit]

Octave's interpreter is very slow on some loops. Recently, thanks to Max Brister's work, an initial implementation of a just-in-time compiler (JITC) in LLVM for GSoC 2012. This project consists in understanding Max's current implementation and extending it so that functions and exponents (e.g. 2^z) compile with the JITC. This requires knowledge of compilers, C++, LLVM, and the Octave or Matlab languages. A capable student who demonstrates the ability to acquire this knowledge quickly may also be considered. Max himself will mentor this project. Here is Max's OctConf 2012 presentation about his current implementation. See also JIT.

Improve memory management[edit]

From profiling the interpreter, it appears that a lot of time is spending allocating and deallocating memory. A better memory management algorithm might provide some improvement.

Implement classdef classes[edit]

Matlab has two kinds of classes: old style @classes and new style classdef. Octave has only fully implemented the old style. There is partial support for classdef classes in version 4.0, refer to the classdef status page for what is not yet implemented. There is irregular work here, and classdef is a very complicated thing to fully implement. A successful project would be to implement enough of classdef for most basic usages. Familiarity with Matlab's current classdef support would be a huge plus. Michael Goffioul and jwe can mentor this.

Although there's already a substantial classdef support in current octave code base, there are still many areas that are unimplemented or need improvements. The main ones that come to my mind are:

  • support for events
  • support for enums
  • support for "import" (this requires good understanding of octave internals, especially the symbol table)
  • improving multiple inheritance and method resolution
  • honoring and computing "Sealed" attribute
  • support for function handle to methods

Improve MPI package[edit]

Octave Forge's MPI package is a wrapper for basic MPI functions for parallel computing. It is implemented by wrapping MPI function calls in simple DLD functions that map Octave's Datataypes to MPI Derived Datatypes. The proposed project deals with improving and extending the Octave MPI package, for example:

  • Octave MPI applications can currently be only run in batch mode, add the ability to launch parallel jobs and collect their output in an interactive Octave session.
  • Implement functions for non-blocking communication (MPI_Isend, MPI_Irecv)
  • Implement one-to-many (Broadcast, Scatter), many-to-one (Reduce, Gather), and many-to-many (All Reduce, Allgather) communication routines

Graphics[edit]

  • Correctly handle case where DISPLAY is unset. Provide --no-window-system or --nodisplay (?) option. Provide --display=DISPLAY option? How will this work with gnuplot (i.e., how do we know whether gnuplot requires an X display to display graphics)?
  • Implement a Cairo-based renderer for 2D-only graphics, with support for PS/PDF/SVG output (for printing).
  • On 'imagesc' plots, report the matrix values also based on the mouse position, updating on mouse moving.
  • Add data cursor to trace data values in figure.

Non-OpenGL renderer[edit]

Besides the original gnuplot backend, Octave also contains an OpenGL-based renderer for advanced and more powerful 3D plots. However, OpenGL is not perfectly suited for 2D-only plots where other methods could result in better graphics. The purpose of this project is to implement an alternate graphics renderer for 2D only plots (although 3D is definitely not the focus, extending the new graphics renderer to support basic 3D features should also be taken into account). There is no particular toolkit/library that must be used, but natural candidates are:

  • Qt: the GUI is currently written in Qt
  • Cairo: this library is widely used and known to provides high-quality graphics with support for PS/PDF/SVG output.

LaTeX markup[edit]

Text objects in plots (like titles, labels, texts...) in the OpenGL renderer only support plain text and TeX. The latter consists of a very limited subset of the TeX language. On the other hand, the LaTeX formatting support is expected to provide full LaTeX capabilities. There are various approaches that can be used:

  • Use an external LaTeX engine: this is the most straightforward, but it requires users to install a LaTeX distribution and setup Octave to use it.
  • Use an external library that supports LaTeX syntax, e.g. JLaTeXMath a Java API to display LaTeX code, qtmathjax a Qt based library that executes MathJax in a background web page.
  • Implement our own LaTeX parser and renderer. The matplotlib project has already done this in Python and might be used as an example of how to do this in Octave. There is also JKQtPlotter, a Qt based plotting application which implements its own LaTeX parser/renderer in C++.

History[edit]

  • Add an option to allow saving input from script files in the history list.
  • The history command should accept two numeric arguments to indicate a range of history entries to display, save or read.
  • Avoid writing the history file if the history list has not changed.
  • Avoid permission errors if the history file cannot be opened for writing.
  • Fix history problems — core dump if multiple processes are writing to the same history file?

Configuration and Installation[edit]

  • Makefile changes:
    • eliminate for loops
    • define shell commands or eliminate them
    • consolidate targets
  • Create a docs-only distribution?

Documentation[edit]

See Project - Documentation.

Tests[edit]

  • Improved set of tests: [1]
    • Tests for various functions. Would be nice to have a test file corresponding to every function (see below)
    • Tests for element by element operators: + - .* ./ .\ .^ | & < <= == >= > != !
      • thorough tests for power operator including corner cases and strange combinations such as complex .^ range.
    • Tests for boolean operators: && ||
    • Tests for other operators: * / \ ' .'
    • Tests from bug reports.
    • Tests for indexed assignment. Need to consider the following:
      • fortran-style indexing
      • zero-one indexing
      • assignment of empty matrix as well as values resizing
    • Tests for all internal functions.
  • Implement a coverage tool for collecting coverage data and generating code coverage reports on m-file functions and scripts. This would be very useful for Octave development as well as for users who want a code coverage report for their own functions and scripts.
  • Implement test for plotting and graphics functions that might currently only have basic input checking and/or demos for human inspection. Possibly create tests that probe properties of the handles created and returned by most such functions, such that test plots can be checked for correct feature size/location, etc.

We are far from even having one test for every function, so focus should be on getting the breadth of coverage first before trying to get the depth of 100% statement coverage. As of Dec 2015, 202 of 1020 m-files have no tests. Some of these will be plotting functions which have demos instead, but that leaves enough functions to be an interesting project. As of Dec 2015, there are 485 instances of C++ functions which need tests.

After Octave is compiled, running the make check build target will run the full test suite and generate a file called test/fntests.log in the build directory with a summary of the results. At the end of the file is a list of all functions for which no tests were found. An extract is posted in the files missing tests page. If you are not building Octave yourself, the test suite can be run on an installed binary copy by executing the __run_test_suite__ command at the Octave prompt. The fntests.log file will be written in the current directory in this case.

There also need to be tests for functions written in the C++ files. See Add_BIST_tests_for_octave_functions_written_in_C++ for instructions and a list of instances.

See also Continuous Build#Coverage Report.

Programming[edit]

  • Better error messages for missing operators?
  • Eliminate duplicate enums in pt-exp.cc, pt-const.cc, and ov.cc.
  • Handle octave_print_internal() stuff at the liboctave level. Then the octave_value classes could just call on the print() methods for the underlying classes.
  • As much as possible, eliminate explicit checks for the types of octave_value objects so that user-defined types will automatically do the right thing in more cases.
  • Only include config.h in files that actually need it, instead of including it in every .cc file. Unfortunately, this might not be so easy to figure out.
  • GNU coding standards:
    • Add a `Makefile' target to the Makefiles.
    • Comments on #else and #endif preprocessor commands.
    • Change error message format to match standards everywhere.
  • Eliminate more global variables.
  • Move procstream to liboctave.
  • Use references and classes in more places.
  • Share more code among the various _options functions.
  • Reduce the amount of datatypes in liboctave.
  • Re-implement operators using templates and modern C++. Current system evolved before templates and makes extensive use of macros to define interactions between scalar<->scalar, scalar<->matrix, scalar<->float, etc., etc.
    • In liboctave, the directory to work on is liboctave/operators
    • In libinterp, the directory to work on is libinterp/operators
    • In libinterp, there is also xpow.cc, xdiv.cc in libinterp/corefcn

Miscellaneous[edit]

  • Implement some functions for interprocess communication: bind, accept, connect, gethostbyname, etc. (This functionality is already available in the octave sockets package, what is the purpose of moving it to core octave?)
  • The ability to transparently handle very large files: Juhana K Kouhia <kouhia@nic.funet.fi> wrote:
    If I have a one-dimensional signal data with the size 400 Mbytes, then what are my choices to operate with it:
    • I have to split the data
    • Octave has a virtual memory on its own and I don't have to worry about the splitting.
    If I split the data, then my easily programmed processing programs will become hard to program.
    If possible, I would like to have the virtual memory system in Octave i.e., the all big files, the user see as one big array or such. There could be several user selectable models to do the virtual memory depending on what kind of data the user have (1d, 2d) and in what order they are processed (stream or random access).
  • An interface to gdb. Michael Smolsky <fnsiguc@weizmann.weizmann.ac.il> wrote:
    I was thinking about a tool, which could be very useful for me in my numerical simulation work. It is an interconnection between gdb and octave. We are often managing very large arrays of data in our fortran or c codes, which might be studied with the help of octave at the algorithm development stages. Assume you're coding, say, wave equation. And want to debug the code. It would be great to pick some array from the memory of the code you're developing, fft it and see the image as a log-log plot of the spectral density. I'm facing similar problems now. To avoid high c-development cost, I develop in matlab/octave, and then rewrite into c. It might be so much easier, if I could off-load a c array right from the debugger into octave, study it, and, perhaps, change some [many] values with a convenient matlab/octave syntax, similar to a(:,51:250)=zeros(100,200), and then store it back into the memory of my c code.
  • Implement gdb extensions for Octave types. Octave has the etc/gdbinit file, which has some basic support for displaying the contents of Octave types. Add more extensions to make it easier to debug octave_values and other Octave types.
  • Spatial statistics, including covariogram estimation and kriging -- perhaps via an interface to gstat?
  • the units function from the miscellaneous package works by parsing the output of from a call to GNU units. This can be made much more robust by writing it in C++ and including its library "units.h"

Marketing and Community[edit]

  • Make it easier for newcomers to contribute.

Improve Windows binary packaging[edit]

We are currently able to build and provide a installer for Windows. The build process involves cross-compiling on a Linux system using a fork of the MXE project to build Octave and all of its dependencies. Any ideas for improving this process to make it easier or faster, or to improve the installer itself or the installation experience for Windows users would be appreciated.

Skills Required: Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. No m-scripting or C++ necessary, beyond understanding the C++ compilation model.

Improve macOS binary packaging[edit]

We would like to be able to easily generate binary packages for macOS. Right now, it's difficult and tedious to do so. Most OS X users install Octave using one of the source-based package managers such as Homebrew or MacPorts. Any way to help us build a binary package would be appreciated. Required knowledge is understanding how building binaries in macOS works. Our current approach to building binaries for Windows is to cross-compile from a GNU system using MXE, something similar may be possible for OS X (GUB?).

There is a third-party project called "Octave.app" that creates and distributes macOS builds of Octave as a Mac app bundle. It is built on top of Homebrew and a set of custom Octave-related Homebrew formuale.

Skills Required: Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, how to use a compiler. If you choose to work on GUB, Python will be required. No m-scripting or C++ necessary, beyond understanding the C++ compilation model.

Performance[edit]

  • Having parfor functioning would speed code development and execution now that multicore architectures are widespread. See here and here. Existing code from the parallel and mpi packages could perhaps be adapted for this.
  • Develop a performance benchmark for Octave (interpreter, load/save, plotting, etc., but not simply tests of underlying libraries such as BLAS or LAPACK). This benchmark could be run periodically to make sure that changes during development do not introduce regressions in performance.

Octave Package management[edit]

Packages are extensions for Octave. To get those extension to work with Octave, there is a single function, pkg, which does pretty much everything. This function has a few limitations which are hard to implement with the current codebase, and will most likely require a full rewrite. A major step forward for a rewritten package manager is the "packajoozle" project by Andrew Janke.

The planned improvements are:

  • install and update from repositories (hg and git)
  • automatic handling of dependencies
  • easily load, update or check specific package versions
  • management of tests and demos in C++ sources of packages
  • more flexibility on dependencies, e.g., dependent on specific Octave build options or being dependent in one of multiple packages
  • support for multiple version packages
  • support for multiple Octave installs
  • support for system-wide and user installed packages
  • testing packages (pkg test <package-name>)
  • improved metadata acquisition (pkg list -forge) from https://octave.sourceforge.io/
  • create a system that allows packages to deprecate functions as in core. Possibilities are:
    • get pkg to accept a deprecated directory inside the package and add it to the search path. Functions in those directories would have to be treated the same as the ones inside the core deprecated
    • PKG_ADD can be used to hack this. Package developers would still have to actually write the warnings on the function code but this would allow to have the functions in a separate directory so they don't foget to remove them on the next release
    • the package developer can also use something like Make to create a normal package from something that actually had a more complex structure, inclusive deprecated directories
  • get pkg to resolve dependencies automatically by downloading and installing them too
  • allow to download and install multiple versions of the same package
  • make the package just a bit more verbose by default (specifics?)
  • make pkg a little more like apt-get (what specific features of apt-get is this referring to?)
  • make pkg support more than one src directory
    • subdirectories with makefiles and top level make command of: cd <subdir> && ${MAKE}... ok as a substitute?
  • make pkg able to supply extra configure and make flags, useful for distributions, including -j for make (pkg now passes --jobs=N automatically, CFLAGS and CXXFLAGS environment variables are already respected, what's missing?)

The main objective of this project is to make pkg more user friendly and to make it a tool to foster third party participation in Octave. However, the current pkg also performs some maintenance functions which it probably should not. Instead a package for developers should be created with such tools. To do this enhancement effectively, a refactoring of the current pkg code will be needed (see "packajoozle" project).

Many of these problems have been solved in other languages. Familiarity with how other languages handle this problem will be useful to come up with elegant solutions. In some cases, there are standards to follow. For example, there are specifications published by freedesktop.org about where files should go (base directory spec), and Windows seems to have its own standards. See bugs #36477 and #40444 for more details.

In addition, package names may start to collide very easily. One horrible way to work around this by is choosing increasingly complex package names that give no hint on the package purpose. An option is providing an "Authority" category like Perl 6 does. Nested packages is also an easy way to provide packages for specialized subjects (think image::morphology). A new pkg would think all this things now, or allow their implementation at a later time. Read the unfinished plan for more details.

Preferences[edit]

Octave has several functions for managing user preferences. Many function use persistent variables instead of relying upon the preference features.

  • The function edit () contains a persistent structure used as its personal set of preferences. These can all be moved to the user preference group for the editor.
    • "EDITOR"
    • "HOME"
    • "AUTHOR"
    • "EMAIL"
    • "LICENSE"
    • "MODE"
    • "EDITINPLACE"
  • The savepath () function modifies the startup script (rcfile), ~/.octaverc and inserts commands to allow the next session to begin with the same path. Instead user preference can be created for startup items and a preference for the user specified path can be added. Perhaps two path preferences should be used. One for the elements that should precede the core path and those that should follow. A start up directory preference might also be added to allow the user to specify where Octave should begin the next session.
    • "PREPATH"
    • "POSTPATH"
    • "STARTUPDIR"
  • A preference group for plotting can also be added. A preference for the default terminal would be useful for those who want to override the default. Preferences for the default graphicstoolkit can also be added.
    • GNUPLOTTERM
    • GRAPHICSTOOLKIT
  • A preference group for printing can include preferences for the default printer, the ghostscript command, and possibly other parameters like orientation, and resolution.
    • PRINTER
    • GHOSTSCRIPTCOMMAND
    • ORIENTATION
    • RESOLUTION
  • Searching the m-files for use of persistent should turn up other opportunities to use preferences.

Profiler Enhancement[edit]

Octave has a built in profiler thanks to a successful 2011 GSOC project by Daniel Kraft. But it really could use:

  • Better granularity:
    • It aggregates all calls to a function within at each level of the code, providing no way to know which call to a function might be more 'expensive'.
    • It aggregates all non-function-call overhead into time spent on 'self' without further detail to the user on what might be causing that overhead.
    • Associating time spent/function call count to line number would be a big plus.
  • A better interface.
    • The current CLI tool is good at determining time spent on function calls, providing both a summary output with profshow and an interactive prompt that lets you dive down levels in the code with profexplore. But this suffers from the aggregation limits mentioned above.
    • The profiler was written before the stable Octave GUI was released with Octave 4.0. This GUI now includes a built in editor with hooks to the interpreter. Better integration of the profiler output to the Octave GUI would be a significant functional improvement. (Current GUI integration is limited to an indicator light that shows the profiler is running.)
    • Enhancements are not strictly limited to using the current Octave GUI/Editor. Whatever helps users connect execution time to code location would be good.

Bugs[edit]

There are always bugs to fix. The bug tracker is a good place to find tasks needing a hand. See also Short projects#Bugs.

Matlab compatibility[edit]

Missing functions[edit]

There are certain functions present in MATLAB known to be missing in Octave.

One list is provided on the source for function __unimplemented.m__, subfunction missing_functions; it can be edited in the Octave GUI or browsed at [2].

Lists are also kept for several packages.

It is also possible to look at existing FOSS implementations, from FreeMat and Scilab (for more closely compatible languages) to R or Scipy or Julia (for less compatible versions). Obviously, it is NOT OK to look at the Matlab implementation since this is not free software!

Functions under different name[edit]

Many Octave Forge functions perform the same as functions from matlab packages. However, they often exist under a different name or have incompatible API's. Often fixing this is a matter of changing their names, swap the order of their input arguments. At least, a list of this functions would be helpful.