From Octave
Revision as of 19:50, 28 March 2014 by Mtmiller (talk | contribs) (→‎Tests: Add coverage tool project idea)
Jump to navigation Jump to search

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 know. We might have information that could help you. You should also read the Contributing Guidelines chapter in the Octave manual.

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 before you start working on some large project.

Summer of Code students, please also see SoC Project Ideas.

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


  • 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.
  • 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.
  • Fix eig to also be able to solve the generalized eigenvalue problem, and to solve for eigenvalues and eigenvectors without performing a balancing step first.
  • Move rand, eye, xpow, xdiv, etc., functions to the matrix classes.
  • Use octave_allocator for memory management in Array classes once g++ supports static member templates.
  • 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 (which has C code with interface to R). (This is now partly implemented in the lssa package.)


See also: Summer of Code Project Ideas#GUI
  • 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).

Sparse Matrices

  • 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
  • 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
    • symmmd (Superseded by symamd)
    • colmmd (Superseded by colamd)
    • cholinc (or ichol) (This is also topic for this GSOC project proposal)
    • luinc (or ilu) (This is also topic for this GSOC project proposal)
    • bicg Moved into octave-core
    • gmresMoved into octave-core
    • lsqr
    • minres
    • qmr
    • symmlq


  • Make find work for strings.
  • 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

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


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


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

would be equivalent to

       function f ()
          save_prefer_column_vectors = prefer_column_vectors;
             prefer_column_vectors = something;
              prefer_column_vectors = save_prefer_column_vectors;

  • 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?
  • 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...
  • Is Matrix::fortran_vec() really necessary?
  • 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.
  • Start the development of classdef (already underway)


  • 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 JHandles. This needs to be ported/re-implement/re-engineered/optimized in the C++ OpenGL renderer of octave.
  • 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.
  • Create a "getframe" function that receives a a graphics handle and returns a 3D matrix from the graphics window associated with that handle.


  • 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

  • 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.
  • Makefile changes:
    • eliminate for loops
    • define shell commands or eliminate them
    • consolidate targets
  • Make it possible to configure so that installed binaries and shared libraries are stripped.
  • Create a docs-only distribution?
  • Better binary packaging and distribution, especially on Windows.
  • Octave Emacs mode needs maintenance.

Documentation and On-Line Help

  • Document new features.
  • 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.
  • The docs should mention something about efficiency and that using array operations is almost always a good idea for speed.
  • Doxygen documentation for the C++ classes.
  • Make index entries more consistent to improve behavior of `help -i'.
  • Make `help -i' try to find a whole word match first.
  • Clean up help stuff.
  • Demo files.
  • Document C++ sources, to make it easier for newcomers to get into writing code.
  • Flesh out this wiki


  • 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: + - .* ./ .\ .^ | & < <= == >= > != !
    • 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.

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 Jan 2014, 243 of 834 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.

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, and that is a whole other project.

See also Continuous Build#Coverage Report.


  • Add support for listeners (addlistener, dellistener, etc) on the C++ side.
  • C++ namespace for Octave library functions.
  • Better error messages for missing operators?
  • Eliminate duplicate enums in,, and
  • 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.


  • 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 <> 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 <> 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(:,50:250)=zeros(100,200), and then store it back into the memory of my c code.
  • 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

  • Make the website prettier. Maybe a new design, maybe a more "corporate" design (if we're heading down the "paid support for Octave" path.
  • Agora -- website for rapid collaboration related to GNU Octave. Talk to Jordi
    • 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: It is FLOSS.
    • ScipyCentral, has all the features we need and is also free software.
  • Help design a user or a developer survey [2]
  • Help prepare and deliver presentations about Octave at colleges and universities.


  • A profiler for Octave would be a very useful tool. And now we have one! But it really needs a better interface.


  • 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
  • make pkg a little more like apt-get
  • 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


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"
  • 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"
  • 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.
  • A preference group for printing can include preferences for the default printer, the ghostscript command, and possibly other parameters like orientation, and resolution.
  • Searching the m-files for use of persistent should turn up other opportunities to use preferences.


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

Matlab compatibility

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.

Missing functions

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 [3].

Lists are also kept for the Image, Mapping, Optimization, and Signal packages.

It is also possible to look at existing FLOSS 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!