Octave Projects

Graphical User Interface

Input/Output

• Make fread and fopen look in LOADPATH for files.

• Make load and save look for <file>.mat if only given <file>.

  Potential sticky points:

  • For load, if both foo and foo.mat exist, should it prefer foo or foo.mat? Should the preference depend on the arguments to load? I think it should only prefer .mat files if the -mat-binary option is supplied, or if the file foo.mat exists but the file foo does not.
  • For save, should it prefer to create foo or foo.mat? Should the preference depend on the arguments to save? Should the default_save_format imply a default preference? I think it should only create .mat files if it is writing Matlab compatible files.
• Move some pr-output stuff to liboctave.
• Make the cutoff point for changing to packed storage a user-preference variable with default value 8192.
• Make it possible to load other image formats (ppm, pbm, etc. would probably be best since there are already filters to convert to these formats from others.)
• 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.

Interpreter

• Allow customization of the debug prompt.
• For the keyboard function, parse return (or quit) more intelligently so that something like debug> x = 1; return will work as expected.
• Handle multi-line input at the keyboard/debug prompt correctly.
• Fix the parser so that if (expr) 'this is a string' end is parsed as IF expr STRING END.
• 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.
• Warn about complex comparisons? Could just use double_value() or matrix_value() instead of explicit conversions to real types. For this to really be useful, some additional information must be available to point to the location of the code that triggers the warning.
• 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.
• Is it necessary for do_binary_op and do_unary_op to be friends of the octave_value class.
• 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

  .
• What should is_global() return when called for built-in variables?
• Fix all function files to check for invalid inputs (wrong number or types of input arguments, wrong number of output arguments).
• Reduce the memory and time required to parse very large matrix lists.
• 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?
• Add a command that works like bash's builtin command.
• Handle end-of-line comments correctly in parse trees for use with the type command.
• Clean up eye, eval, feval, keyboard, input, ones, zeros.
• It would be nice to have an interactive debugger.
• 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.
• Provide a built-in function for applying a scalar function to an array. Be sure to note in the manual that this is not the preferred way to write a function that can handle vector/matrix arguments because there is a significant overhead for function calls. If you are really looking to make a function work for vector/matrix arguments and you want it to run fast, you should write it in terms of the existing vector/matrix operators as much as possible.
• 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.

History

• 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.
• Add an option to include information about the Octave session in the history list. Possibly a time/date stamp and the current Octave line number, appended as a comment (users should probably be able to control the ).
• 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

• Makefile changes:
  • eliminate for loops
  • define shell commands or eliminate them
  • verify distclean
  • consolidate targets
• Make it possible to configure so that installed binaries and shared libraries are stripped.
• Create a docs-only distribution?

Documentation and On-Line Help

• Document new features.
  • history-search-{back,for}ward.
  • Other stuff mentioned in the NEWS file.
• 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.
• Texinfo documentation for the C++ classes.
• Support multiple info files, perhaps allowing one or more in each directory in the LOADPATH, so that local collections of M-files could be documented with Info.
• Improve help messages for operators and keywords in help.cc.
• Make index entries more consistent to improve behavior of help -i.
• Make help -i try to find a whole word match first.
• Allow help for local additions to be accessible with help -i.
• Clean up help stuff.
• Demo files.

• As the number of m-files with octave grows perhaps a Contents.m file for each toolbox (directory) would be appropriate so one knows exactly what functions are in a toolbox with a quick look. It would be best to generate information for each function directly from the M-files, so that the information doesn't have to be duplicated, and will remain current if the M-files change. It would also be best to do as much of this as possible in an M-file, though I wouldn't mind adding some basic support for listing the names of all the directories in the LOADPATH, and the names of all the M-files in a given directory if that is needed.

  Also make it possible to recursively search for Contents files: help dir -- Contents from dir help dir// -- Contents from dir and all its subdirectories help dir1/dir2 -- Contents from dir2 which is under dir1

• Some sort of blurb (2-3 pages) describing Octave in a reasonably coherent way, where to get it etc., perhaps formatted pretty, i.e. not just text. Maybe start with the latest Announce file.

Tests

• Improved set of tests:
  • Tests for various functions. Would be nice to have a test file corresponding to every function.
  • 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.

Programming

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

Miscellaneous

• Implement some functions for interprocess communication: bind, accept, connect, gethostbyname, etc.
• The installation process should also install octave.el. This needs to detect the appropriate Emacs binary to use to byte-compile the .el file. Following GNU Emacs philosophy, installation would be into $(prefix)/share/emacs/site-lisp by default, but it should be selectable.

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

  Perhaps this can be done entirely with a library of M-files.

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

• Add a definition to lgrind so that it supports Octave. (See http://www.tex.ac.uk/tex-archive/support/lgrind/ for more information about lgrind.)

Always

• Squash bugs.