Projects: Difference between revisions

Jump to navigation Jump to search

Projects (edit)

Revision as of 01:31, 16 September 2020

4,048 bytes removed ,  16 September 2020
→‎Marketing and Community
m (→‎Interpreter: Update mailing-list URL.)
(45 intermediate revisions by 9 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 addition in sum() to mitigate against numerical errors without substantial performance penalty (https://en.wikipedia.org/wiki/Pairwise_summation).
 
*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 29: Line 34:
*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 44:
* 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 56:
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 77:
* 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
* <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/index.php?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.
** References
***[https://savannah.gnu.org/bugs/?func=detailitem&item_id=55905 tracker post about memory allocation]  
***[https://computing.llnl.gov/projects/sundials/release-history SUNDIALS release history]
* Implement Matlab compatible versions of "deval".
* Implement Matlab compatible versions of "deval".
* Complete transition of ode23s into core Octave
** [https://savannah.gnu.org/bugs/?57309 Bug tracker entry discussing ode23s]


== High Precision Arithmetic Computation ==
== High Precision Arithmetic Computation ==
Line 88: Line 99:
=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).
* Create a better (G)UI for the {{manual|profile|profiler}}. This may be done with Qt, but not necessarily.
 
== Implement a Qt widget for manipulating plots ==


Octave has had for some time a native OpenGL plotter. The plotter requires some user interaction for manipulating the plots, and it's been using fltk for quite some time. We want to replace this with Qt, so it fits better with the overall GUI look-and-feel and is easier to extend in the future.
== GUI Variable Editor and Property Inspector ==


[https://github.com/goffioul/QtHandles QtHandles] is a current work in progress integrating the octave OpenGL renderer plus good support for GUI elements (uicontrol, uimenu, uitoolbar...). This project may initially consists of integrating the existing QtHandles code base into Octave. Then if time permits, further improvements can be made to QtHandles.
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.


== Create a better (G)UI for the profiler ==
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.


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.
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 pkg) ==
== 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 113: Line 122:
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


*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 <code>a = sprandn (1e6, 1e6, 1e-6); a(a<1) = 0;</code> won't cause a memory overflow.
 
*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
== 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 253: Line 259:


*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 287: Line 291:
* 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 297: Line 299:
* 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.


* Create a "getframe" function that receives a  a graphics handle and returns a 3D matrix from the graphics window associated with that handle.
* 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 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 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.
 
* 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,
 
:<pre>\alpha \approx \beta_0 + \gamma^\chi</pre>


:Would be rendered as,
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.
:&alpha; &asymp; &beta;<sub>0</sub> + &gamma;<sup>&chi;</sup>
* 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++.
: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 351: Line 328:
*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.
 
*<strike> The docs should mention something about efficiency and that using array operations is almost always a good idea for speed. </strike>
 
*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.
 
*<strike> Clean up help stuff. </strike>


*Demo files.
* Makefile changes:
** eliminate for loops
** define shell commands or eliminate them
** consolidate targets


*Document C++ sources, to make it easier for newcomers to get into writing code.
* Create a docs-only distribution?


*Flesh out this wiki
=Documentation=
:''See [[Project - Documentation]].''


=Tests=
=Tests=
Line 394: Line 344:
**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 414: Line 365:


=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 444: Line 391:
*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 470: Line 422:
=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 [http://octave.sourceforge.net/ Octave-Forge] to [http://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 ==
* Make it easier for newcomers to contribute.


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.
* For marketing ideas, see the [https://openoffice.apache.org/orientation/intro-marketing.html Apache Open Office Introduction to Marketing]


In response to this, a website started to form, [http://agora.octave.org/ Agora Octave].
* Help design a user or a [https://www.openoffice.org/marketing/ooocon2006/presentations/wednesday_c10.pdf developer survey]


This should be relatively easy webdev in Python using [http://en.wikipedia.org/wiki/Django_%28web_framework%29 Django].
* Help prepare and deliver presentations and [[Publications about Octave]] at colleges and universities.
 
Things to be considered when working on this:
 
* [http://octave-forge.blogspot.ie/2012/08/octconf2012-agora-and-pkg.html discussion of Agora during OctConf2012]
* [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]]


== Improve Windows binary packaging ==
== Improve Windows binary packaging ==
Line 504: Line 438:
'''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 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]?).


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]?).
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 512: Line 448:
=Performance=
=Performance=


*A profiler for Octave would be a very useful tool. And now we have one! But it really needs a better interface.
* 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=
=Packaging=
Line 556: Line 493:
=Bugs=
=Bugs=


There are always bugs to fix. The [http://savannah.gnu.org/bugs/?group=octave bug tracker] is a good place to find tasks needing a hand. See also [[Short projects#Bugs]].
There are always bugs to fix. The [https://savannah.gnu.org/bugs/?group=octave bug tracker] is a good place to find tasks needing a hand. See also [[Short projects#Bugs]].


= Matlab compatibility =
= Matlab compatibility =
Line 566: Line 503:
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 [http://hg.savannah.gnu.org/hgweb/octave/file/default/scripts/help/__unimplemented__.m#l547].
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 [http://hg.savannah.gnu.org/hgweb/octave/file/default/scripts/help/__unimplemented__.m#l547].


Lists are also kept for the [[Image package|Image]], [[Mapping package|Mapping]], [[Optimization package|Optimization]], [[Signal package|Signal]], and [[Statistics package|Statistics]] packages.
Lists are also kept for [[:Category:Missing functions|several packages]].


It is also possible to look at existing [[Wikipedia:Free and open-source software|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 [[Wikipedia:Free software|free software]]!
It is also possible to look at existing [[Wikipedia:Free and open-source software|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 [[Wikipedia:Free software|free software]]!
Retrieved from "https://wiki.octave.org/Special:MobileDiff/10584...13336"

Navigation menu