    Octave PROJECTS                                          -*- text -*-
    ===============

    Check with bug-octave@bevo.che.wisc.edu for a possibly more current
    copy.  Also, if you start working steadily on a project, please let
    bug-octave@bevo.che.wisc.edu know.  We might have information that
    could help you; we'd also like to send you the GNU coding standards.

    This list is not exclusive -- there are many other things that might
    be good projects, but it might instead be something we already have,
    so check with bug-octave@bevo.che.wisc.edu before you start.

    ---------
    Numerical:
    ---------

      * Improve logm, and sqrtm.

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

      * Handle complex values in fread and fwrite.

      * Support for lp_solve for linear programming problems.

      * Free QP solver.

      * Free NLP solver.

      * Support for sparse matrices.

      * Fix CollocWt to handle Laguerre polynomials.  Make it easy to
        extend it to other polynomial types.

      * Make filter faster (perhaps by calling BLAS functions).

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

      * Implement the following functions:
        -- ppval    -- cross    -- dot

      * When constructing NLConst (and other) objects, make sure that
        there are sufficient checks to ensure that the dimensions all
        conform.

      * Allow parameters to be passed through the call to fsolve() to the
        user-supplied function for Matlab compatibility.  Don't place an
        upper limit on the number of arguments.

      * Check matrix classes for proper handling of empty matrices.

      * Make operations with empty matrices produce empty matrices, for
        compatibility with Matlab (but only if Matlab 5 still does things
        this way). For example:  [1, 2] * [] ==> [].

      * Improve design of ODE, DAE, classes.

      * Extend meaning of .* to include v .* M or M .* v (where v is a
        column vector with the same number of rows as M) to scale rows of
        M by elements of v.  Similarly, if w is a row vector with as many
        columns as M, then either w .* M or M .* w scales the columns of
        M.

      * Given two vectors x and y of length m and n, implement a function
        outer (x, y, f) that returns an m-by-n matrix with entries
        f (x(i), y(j)).  If f is omitted, multiplication is the default.
        Should probably work for any vectors, not just if x is a column
        vector and y is a row vector.

      * Make it possible to solve b = L \ x efficiently, either by
        providing an explicit function call, or by automatically
        determining that L is triangular.  If it is done automatically,
        provide some means for determining whether Octave has actually
        detected that the matrix is triangular.

      * The polyfit function uses the economy QR factorization, but even
        that can take a lot of time for large datasets.  Consider an
        option to compute the result with inv (A' * A) * A' * y or some
        other faster method.d  Possibly just switch to this method if the
        dataset is larger than some value.

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

      * Consider making the behavior of the / and \ operators for
        non-square systems compatible with Matlab.  Currently, they return
        the minimum norm solution from DGELSS, which behaves differently.

    --------
    Graphics:
    --------

      * Make plotting with plplot work.

      * Fix interface with gnuplot to wait for gnuplot to output any text
        before octave returns a prompt.  Possible by implementing two
        way communication between gnuplot and Octave.

      * Handle gnuplot ranges correctly for parametric modes (accept 3
        ranges for 2d plots and 5 ranges for 3d plots).

      * Make gsave (and possibly gload) work.  Implement gsave by having it
        also alter the plot command to not use temporary files (perhaps
        with some user-specified template for naming them) and then
        sending a `save' command to gnuplot.

      * It would be nice to be able to check that a plot is currently
        being displayed.

      * Implement clf, gcf, get, set, orient, print, close, etc. in
        Matlab-compatible ways.

      * Make it possible to check the current graphics terminal type.

      * If possible, pass data to gnuplot without using temporary files.

      * If possible, pass binary data to gnuplot to speed things up.

      * If using gnuplot, consider setting a smaller default for the
        `zero' value (e.g., set zero sqrt (realmin) or something).

    -------
    Strings:
    -------

      * Improve performance of string functions, particularly for
        searching and replacing.

      * Provide some regex matching functions.

      * Convert string functions to work on string arrays.

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

      * Consider making ["test", []] ==> "test", for compatibility with
        Matlab, at least when some set of preferences are set.

    ----------------
    Other Data Types:
    ----------------

      * New types (char, short, etc.).

      * 3d matrix stuff.

      * Template functions for mixed-type ops.

      * Stuff for arithmetic using charMatrix, intMatrix, etc.

    ------------------------
    Graphical User Interface:
    ------------------------

      * In an X11 or other windowing environment, allow the user to pop up
        windows for menus and other purposes.  A good place to start might
        be Tk, as long as Tcl is avoided.

      * Add a way to handle events, like alarms, mouse clicks, etc.

    ------------
    Input/Output:
    ------------

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

      * Make load and save work for structures.

      * Make load and save look for .mat if only given .

        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.

      * Fix the parser so that

          if (expr) 'this is a string' end

        is parsed as IF expr STRING END.

      * Consider grouping all preference variables in a structure instead
        of further polluting the namespace.  Maybe `Octave_options.xxx'?

      * Rewrite functions in input.cc to do the right thing in all cases
        of using readline, forced interactive behavior, echoing of input,
        etc.

      * Consider making linspace() and logspace() return the value
        corresponding to the first argument if the number of requested
        points is 1.

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

      * Allow `octave -c STRING' to execute commands from STRING then
        exit.

      * Make the interpreter run faster.

      * Make it possible to disable or enable all warnings on an
        individual basis from the command line or via some built-in
        structure variable.

      * 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 tree_constant 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?

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

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

      * Handle arrays with more than two dimensions.

      * 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?

      * print_usage() should set error_state in most cases?

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

      * Make whos report total memory used by variables (and functions?).

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

      * Make whos work for structure elements:

          prot  type               rows   cols  name
          ====  ====               ====   ====  ====
          wd   matrix                m      n   struct.field

      * Allow who to return information as a list of strings.

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

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

      * Fix history problems -- core dump if multiple processes are
        writing to the same history file?

    ------------------------------
    Configuration and Installation:
    ------------------------------

      * Add an --enable-pathsearch option to configure to make it possible
        to configure and run without kpathsea.

      * 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:
    	   o fortran-style indexing
    	   o zero-one indexing
    	   o assignment of empty matrix as well as values
    	   o 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 format to match standards everywhere.

      * Use STL stuff instead of libg++ lists, maps, and stacks.

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

    				--30--