Changes

Jump to navigation Jump to search

Projects

20,013 bytes added, 09:55, 19 September 2019
m
Add reference to Pairwise Summation
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 [http://www.gnu.org/software/octave/doc/interpreter/Contributing-Guidelines.html#Contributing-Guidelines [Contribution guidelines |Contributing Guidelines chapter] in the [http://www.gnu.org/software/octave/doc/interpreter/ 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 octave-maintainers@octave.org before you start working on some large project.
GSoC Summer of Code students, please also see [[GSoC SoC Project Ideas]].
If you're looking for small project, something more suited to start getting involved with Octave devlopment development or to fill a boring evening, see instead [[short projects]]
=Numerical=
*Improve logm, and sqrtm (see this thread: http://octave.1599824.n4.nabble.com/matrix-functions-td3137935.html)
 
*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.
*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.
*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 ==
 
Octave-Forge already has a set of packages for discretizing Partial Differential operators by Finite Elements and/or Finite Volumes,
namely the [[bim package]] which relies on the [http://octave.sf.net/msh msh package] (which is in turn based on [http://geuz.org/gmsh/ gmsh]) for creating and managing 2D triangular and 3D tetrahedral meshes and on the [http://octave.sf.net/fpl fpl package] for visualizing 2D results within Octave or exporting 2D or 3D results in a format compatible with [http://www.paraview.org Paraview] or [https://wci.llnl.gov/codes/visit/ VisIT]. These packages, though, offer only a limited choice of spatial discretization methods which are based on low degree polynomials and therefore have a low order of accuracy even for problems with extremely smooth solutions.
The [http://geopdes.sf.net GeoPDEs] project, on the other hand, offers a complete suite of functions for discretizing a wide range of
differential operators related to important physical problems and uses basis functions of arbitrary polynomial degree that allow the construction of methods of high accuracy. These latter, though, are based on the IsoGeometric Analysis Method which, although very powerful and often better performing, is less widely known and adopted than the Finite Elements Method. The implementation of a general purpose library of Finite Elements seems therefore a valuable addition to Octave-Forge. Two possible interesting choices for implementing this package exist, the first consists of implementing the most common Finite Element spaces in the [http://geopdes.sf.net GeoPDEs] framework, which is possible as IsoGeometric Analysis can be viewed as a superset of the Finite Element Method, the other is to construct Octave language bindings for the free software library [http://fenicsproject.org/documentation/ FEniCS] based on the existing C++ or Python interfaces. This second approach has been developed during the GSOC 2013 and the Octave-Forge package [http://octave.sf.net/fem-fenics fem-fenics] is now available. However, fem-fenics could be extended in many different ways:
* implement the bindings for the UFL language inside Octave
* add new functions already available with Fenics but not yet in Octave
* create new functions specifically suited for Octave
* 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.
 
== Implement solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D ==
 
The project will deliver a solver for initial-boundary value problems for parabolic-elliptic PDEs in 1D similar to Matlab's function <tt>pdepe</tt>. A good starting point is the [http://en.wikipedia.org/wiki/Method_of_lines method of lines] for which you can find more details [http://en.wikibooks.org/wiki/Partial_Differential_Equations/Method_of_Lines here] and [http://www.scholarpedia.org/article/Method_of_lines here], whereas an example implementation can be found [http://www.scholarpedia.org/article/Method_of_Lines/Example_Implementation here]. In addition, [http://www.pdecomp.net/ this page] provides some useful material.
 
== Implement solver for 1D nonlinear boundary value problems ==
 
The project will complete the implementation of the bvp4c solver that is already available in an initial version in the odepkg package
by adding a proper error estimator and will implement a matlab-compatible version of the bvp5c solver.
Details on the methods to be implemented can be found in [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 ==
 
[http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration Geometric (AKA Symplectic) integrators] are useful for
multi-dimensional classical mechanics problems and for molecular dynamics simulations.
The odepkg package has a number of solvers for ODE, DAE and DDE problems but none of them is currently
specifically suited for second order problems in general and Hamiltonian systems in particular.
Therefore a new package for geometric integrators would be a useful contribution.
This could be created as new package or added as a set of new functions for odepkg.
The function interface should be consistent throughout the package and should be modeled to follow
that of other functions in odepkg (or that of DASPK and LSODE) but will need specific extensions to accommodate for specific options that only make sense for this specific class of solvers.
An initial list of methods to be implemented includes (but is not limited to)
* Symplectic Euler methods, see [http://en.wikipedia.org/wiki/Semi-implicit_Euler_method here] and [http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration here]
* Störmer-Verlet method, see [http://en.wikipedia.org/wiki/Verlet_integration here] and [http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration here]
* Velocity Verlet method, see [http://en.wikipedia.org/wiki/Verlet_integration here] and [http://openlibrary.org/books/OL9056139M/Geometric_Numerical_Integration here]
* Symplectic partitioned Runge-Kutta methods, see [http://reference.wolfram.com/mathematica/tutorial/NDSolveSPRK.html here] or [http://dx.doi.org/10.1137/0733019 here]
* Spectral Variational Integrator methods, see [http://www3.nd.edu/~izaguirr/papers/acta_numerica.pdf here] or [http://www.math.ucsd.edu/~mleok/pdf/HaLe2012_SVI.pdf here]
 
For this latter there is an existing code which is already working but needs to be improved, posted on the patch tracker.
Furthermore, methods to implement solutions of problems with rigid constraints should be implemented, e.g.
* 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]
 
== 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>
* <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>
* <strike> Build Matlab compatible versions of "ode15s" and "ode15i". jwe has prototype implementations [https://savannah.gnu.org/patch/?8102 here] of these built as wrappers to "dassl" and "daspk". An initial approach could be to just improve these wrappers, but eventually it would be better to have wrappers for "IDA" from the sundials library. </strike>
* Implement Matlab compatible versions of "deval".
 
== High Precision Arithmetic Computation ==
 
The Linear Algebra Fortran libraries used by Octave make use of of single (32 bits) and double (64 bits) precision floating point numbers. Many operations are stopped when matrices condition number goes below 1e-16: such matrices are considered as ill-conditioned. There are cases where this is not enough, for instance simulations implying chemical concentrations covering the range 10^4 up to 10^34. There are a number of ways to increase the numerical resolution, like f.i. make use of 128 bits quadruple precision numbers available in GFortran. A simpler option is to build an interface over Gnu MPL arbitrary precision library, which is used internally by gcc and should be available on any platform where gcc runs. Such approach has been made available for MatLab under the name mptoolbox and is licensed under a BSD license. The author kindly provided a copy of the latest version and agreed to have it ported under Octave and re-distributed under GPL v3.0
 
The architecture consists of an Octave class interface implementing "mp" (multi-precision) objects. Arithmetic operations are forwarded to MPL using MEX files. This is totally transparent to the end user, except when displaying numbers. This implementation needs to be ported and tested under Octave.
=GUI/IDE=
:''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).
*There is currently Create a GUI being developedbetter (G)UI for the {{manual|profile|profiler}}. This may be done with Qt, it's in [https://savannahbut not necessarily.gnu == Sisotool.org/projects/octave/ savannahCreate 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. Further info can As they are moving the software must update all the plotted lines. There should be found on 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 [http[Summer_of_Code#GSoC_2018|GSoC 2018]], see https://octave-gsoc2012eriveltongualter.blogspotgithub.io/GSoC2018/final.com GSoC 2012 GNU Octave GUI Development blog]html for details.
=Sparse Matrices=
 
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 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 Improve Matlab compatibility for {{manual|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.
*Other missing Functions
**<strike>symmmd</strike> (Superseded by symamd)
**<strike>colmmd</strike> (Superseded by colamd)
**cholinc (or ichol) (This is also topic for [[Summer_of_Code_Project_Ideas#Incomplete_sparse_factorizations_ichol.2C_ilu|this]] GSOC project proposal)
**luinc (or ilu) (This is also topic for [[Summer_of_Code_Project_Ideas#Incomplete_sparse_factorizations_ichol.2C_ilu|this]] GSOC project proposal)
**<strike>bicg</strike> Moved into octave-core
**<strike>gmres</strike>Moved into octave-core
**lsqr
**minres
**qmr
**symmlq
=Strings=
 
*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!)
*Extend Octave functions to work on stored arrays that are too big to fit in RAM, similar to available R [http://www.bigmemory.org/ packages.]
 
* write {{codeline|xmlread}} and {{codeline|xmlwrite}}. This could be done using [http://xerces.apache.org/xerces-c/ Xerces C++ interface] which apparently is what [http://octave.1599824.n4.nabble.com/xml-in-octave-td4663034.html Matlab uses].
 
* Implement hdf5 for .mat files (see [http://octave.1599824.n4.nabble.com/Reading-Matlab-td4650158.html this thread]).
=Interpreter=
 
The interpreter is written in C++, undocumented. There are many possible projects associated with it.
 
'''Required skills''': ''Very good'' C and C++ knowledge, possibly also understanding of [http://en.wikipedia.org/wiki/Gnu_bison GNU bison] and [http://en.wikipedia.org/wiki/Flex_lexical_analyser flex]. Understanding how compilers and interpreters are made plus being able to understand how to use a profiler and a debugger will probably be essential skills.
*Allow customization of the debug prompt.
if (expr) 'this is a string' end
is parsed as IF expr STRING END.''(see [https://lists.gnu.org/archive/html/octave-maintainers/2014-03/msg00087.html this] post on the mailing list)''
*Clean up functions in input.cc that handle user input (there currently seems to be some unnecessary duplication of code and it seems overly complex).
*Too much time is spent allocating and freeing memory. What can be done to improve performance?
 
Use move constructors rather than copy constructors for things like dim_vectors which are repeatedly created just to initialize Array or Matrix objects.
*Error output from Fortran code is ugly. Something should be done to make it look better.
*<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!
* Start == Improve JIT compiling == Octave's interpreter is ''very'' slow on some loops. Recently, thanks to Max Brister's work, an initial implementation of a just-in-time compiler (JITC) in [http://llvm.org LLVM] for GSoC 2012. This project consists in understanding Max's current implementation and extending it so that functions and exponents (e.g. 2^z) compile with the JITC. This requires knowledge of compilers, C++, LLVM, and the Octave or Matlab languages. A capable student who demonstrates the ability to acquire this knowledge quickly may also be considered. Max himself will mentor this project. [http://planet.octave.org/octconf2012/jit.pdf Here] is Max's OctConf 2012 presentation about his current implementation. See also [[JIT]]. == Improve memory management == From profiling the interpreter, it appears that a lot of time is spending allocating and deallocating memory. A better memory management algorithm might provide some improvement. == Implement classdef classes == Matlab has two kinds of classes: old style @classes and new style classdef. Octave has only fully implemented the old style. There is partial support for classdef classes in version 4.0, refer to the development [[Classdef|classdef status page]] for what is not yet implemented. There is irregular work here, and classdef is [http://www.mathworks.com/help/matlab/matlab_oop/method-attributes.html a very] [http://www.mathworks.com/help/matlab/events-sending-and-responding-to-messages.html complicated] [http://www.mathworks.com/help/matlab/enumeration-classes.html thing] to fully implement. A successful project would be to implement enough of classdef for most basic usages. Familiarity with Matlab's current classdef support would be a huge plus. Michael Goffioul and jwe can mentor this. Although there's already a substantial classdef support in current octave code base, there are still many areas that are unimplemented or need improvements. The main ones that come to my mind are:* support for events* support for enums* support for "import" (this requires good understanding of octave internals, especially the symbol table)* improving multiple inheritance and method resolution* honoring and computing "Sealed" attribute* support for function handle to methods == Improve MPI package == Octave Forge's [http://octave.sourceforge.net/mpi/index.html MPI package] is a wrapper for basic MPI functions for parallel computing. It is implemented by wrapping MPI function calls in simple DLD functions that map Octave's Datataypes to MPI Derived Datatypes. The proposed project deals with improving and extending the Octave MPI package, for example:* Octave MPI applications can currently be only run in batch mode, add the ability to launch parallel jobs and collect their output in an interactive Octave session.* Implement functions for non-blocking communication (already underwayMPI_Isend, MPI_Irecv)* Implement one-to-many (Broadcast, Scatter), many-to-one (Reduce, Gather), and many-to-many (All Reduce, Allgather)communication routines
=Graphics=
* 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 Add map-creating capabilities similar to the graphics window associated with that handleMatlab [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. == 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 == 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://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 == 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. * Add mapThe 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-creating capabilities similar scripts, and several mathematical symbols needs to be supported. For example, :<pre>\alpha \approx \beta_0 + \gamma^\chi</pre> :Would be rendered as, :&alpha; &asymp; &beta;<sub>0</sub> + &gamma;<sup>&chi;</sup> :This is analogous to how special characters may be included in a wiki using html. :<pre>&amp;alpha; &amp;asymp; &amp;beta;<sub>0</sub> + &amp;gamma;<sup>&amp;chi;</sup></pre> :The text object's {{Codeline|extent}} for the rendered result needs to be calculated and the Matlab 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.mathworksgnu.comorg/software/octave/helpdoc/mapinterpreter/functionlistText-Properties.html Mapping toolboxhere] for inclusion . * 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 the some format (to be specified) that is then integrated into Octave Forge plots. :The matplotlib project [httpshttp://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/octavejlatexmath/mapping mapping packageJLaTeXMath], a Java API to display LaTeX code in mathematical mode.
=History=
=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:
**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<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, especially on Windowsexcept for special dir libgnu which is the only SUBDIRS listed in configure*Octave Emacs mode needs maintenanceac.
=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 `<code>help -i'</code>.
*Make `<code>help -i' </code> try to find a whole word match first.
*Clean up help stuff. *Demo Add more demo files. *Document C++ sources, to make it easier for newcomers to get into writing code.
*Flesh out this wiki
=Tests=
*Improved set of tests:[http://octave.1599824.n4.nabble.com/template/NamlServlet.jtp?macro=user_nodes&user=370633]
**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 all internal functions.
We are far from even having one test * Implement a coverage tool for every function, so focus should be on getting the breadth of collecting coverage first before trying to get the depth of 100% statement data and generating code coverage. As of Jan 2014, 243 of 834 reports on m-files have no testsfile functions and scripts. Some of these will This would be plotting very useful for Octave development as well as for users who want a code coverage report for their own functions which have demos instead, but that leaves enough functions to be an interesting projectand scripts.
On release 3.8.xWe are far from even having one test for every function, executing so focus should be on getting the breadth of coverage first before trying to get the __run_test_suite__ function will generate a file called fntestsdepth of 100% statement coverage.log in your current directory with a summary As of Dec 2015, 202 of the results1020 m-files have no tests. It indicate at the end the Some of these will be plotting functions for which no tests were found in filehave demos instead, but that leaves enough functions to be an interesting project. An extract is posted in the [[files missing As of Dec 2015, there are 485 instances of C++ functions which need tests]] page.
There also need to be After Octave is compiled, running the {{Codeline|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 for functions written were found. An extract is posted in the C++ [[filesmissing tests]] page. If you are not building Octave yourself, and that is a whole other projectthe test suite can be run on an installed binary copy by executing the {{Codeline|__run_test_suite__}} command at the Octave prompt. The fntests.log file will be written in the current directory in this case.
=Programming=There also need to be tests for functions written in the C++ files. See [[Add_BIST_tests_for_octave_functions_written_in_C%2B%2B]] for instructions and a list of instances.
*Add support for listeners (addlistener, dellistener, etc) on the C++ sideSee also [[Continuous Build#Coverage Report]].
*C++ namespace for Octave library functions.=Programming=
*Better error messages for missing operators?
*Share more code among the various _options functions.
 
*Use non-empty identifiers in all warnings and errors issued by Octave, see [[Easy projects#Miscellaneous]].
 
*Reduce the amount of datatypes in liboctave.
=Miscellaneous=
*: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 *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 done entirely 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 library log-log plot of Mthe 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-filesload 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 <code>a(:,51:250)=zeros(100,200)</code>, and then store it back into the memory of my c code.
*An interface to Implement gdbextensions for Octave types. Michael Smolsky Octave has the <fnsiguc@weizmann.weizmann.ac.ilcode>etc/gdbinit</code> wrote:*:I was thinking about a toolfile, which could be very useful has some basic support 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 displaying the help contents of octave at the algorithm development stages. Assume you're coding, say, wave equation. And want to debug the codeOctave types. It would be great Add more extensions to pick some array from the memory of the code you're developing, fft make 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 <code>a(:,50:250)=zeros(100,200)</code>, debug octave_values and then store it back into the memory of my c codeother Octave types.
*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.)
*Make Spatial statistics, including covariogram estimation and kriging -- perhaps via an interface to [http://www.gstat.org/ gstat]? * the website prettier[http://octave.sourceforge.net/miscellaneous/function/units. Maybe a new design, maybe html 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 "corporateunits.h" design (if we're heading down  =Marketing and Community= * Make the "paid support Octave website/[[Project Infrastructure]] easier to maintain. * Make it easier for Octave" pathnewcomers to contribute. * For marketing ideas, see the [https://openoffice.apache.org/orientation/intro-marketing.html Apache Open Office Introduction to Marketing] * Help design a user or a [https://www.openoffice.org/marketing/ooocon2006/presentations/wednesday_c10.pdf developer survey]
*Agora Help prepare and deliver presentations about Octave at colleges and universities.** [https://indico.cern.ch/event/626097/contributions/2902420/attachments/1615292/2566811/2018-03- website for rapid collaboration related to GNU 12-octave.pdf Octavetalk] at [[OctConf 2018]]. Talk to ** "What is Octave?" [[UserFile:JordiGH|JordiSlides_octconf_gdf_jgh.pdf]]([http://inversethought.com/hg/what-is-octave/ source]).
*Move [http://octave.sourceforge.net/ Octave-Forge] to [http://savannah.gnu.org/projects/octave/ Savannah] so everything is hosted in the same place.== Improve Windows binary packaging ==
*Many Octave Forge functions perform the same as functions from matlab packagesWe are currently able to build and provide a [[Windows Installer|installer for Windows]]. However, they often exist under The build process involves cross-compiling on a different name or have incompatible API's. Often fixing this is Linux system using a matter fork of changing their names, swap the order [http://mxe.cc/ MXE] project to build Octave and all of their input argumentsits dependencies. At leastAny ideas for improving this process to make it easier or faster, a list of this functions or to improve the installer itself or the installation experience for Windows users would be helpfulappreciated.
*Spatial statistics'''Skills Required''': Knowledge of GNU build systems, Makefiles, configure files, chasing library dependencies, including covariogram estimation 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 macOS binary packaging == We would like to be able to easily generate binary packages for macOS. Right now, it's difficult and kriging 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- perhaps via an interface to compile from a GNU system using [http://wwwmxe.gstatcc/ MXE], something similar may be possible for OS X ([http://lilypond.org/ gstatgub/ GUB]?).
* the '''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://octavedavid.sourceforgerothlis.net/miscellaneousc/functioncompilation_model/units.html 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++ andd including its library "unitscompilation model].h"
=Performance=
*A profiler for Octave would be a very useful tool. And now we have one! But it really needs a better interface.
*Having {{Codeline|parfor}} functioning would speed code development and execution now that multicore architectures are widespread. See [http://octave.1599824.n4.nabble.com/Parfor-td4630575.html here] and [http://stackoverflow.com/questions/24970519/how-to-use-parallel-for-loop-in-octave-or-scilab here]. Existing code from the [[Parallel package | parallel]] and [http://octave.sourceforge.net/mpi/index.html mpi] packages could perhaps be adapted for this.
=Packaging=
* get pkg to resolve dependencies automatically by downloading and installing them too
* allow to download and install multiple versions of the same package
* make the package just a bit more verbose by default(specifics?)* make pkg a little more like apt-get(what specific features of apt-get is this referring to?)
* make pkg support more than one src directory
** subdirectories with makefiles and top level make command of: cd <subdir> && ${MAKE}... ok as a substitute?
* make pkg able to supply extra configure and make flags, useful for distributions, including -j for make(pkg now passes --jobs=N automatically, CFLAGS and CXXFLAGS environment variables are already respected, what's missing?)
=Preferences=
=Bugs=
There is are always bugs to fix. See the The [httphttps://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 =
==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 [http://hg.savannah.gnu.org/hgweb/octave/file/d63878346099default/scripts/help/__unimplemented__.m#l530l547]. 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]]! == Functions under different name == 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. 
Another list is kept for the [[Image package]] and [[Mapping package]].
[[Category:Development]]
[[Category:Project Ideas]]
908

edits

Navigation menu