Hi Daniel,

Here's some GSoC suggestions for core.matrix. I'm happy to mentor any one 
of these.

NDArray Implementation in Clojure

*Brief explanation:* core.matrix provides a general purpose API for vector 
/ matrix computation in Clojure. A key innovation is support for multiple 
back-end implementations (e.g. optimised native libraries or various 
existing Java libraries). However, there would be considerable value in 
having a N-Dimensional array (NDArray) implementation as part of 
core.matrix itself. This would likely become the de-facto standard 
implementation for numerical computing in Clojure.

*Expected results: *A working NDArray implementation merged into 
core.matrix, with relevant documentation and tests. The implementation 
should support the full core.matrix API (i.e. it should work as a fully 
functioning, general purpose N-dimensional matrix implementation), and have 
good efficiency / performance characteristics.

*Knowledge prerequisites:* Linear Algebra, Experience of Clojure (including 
protocols and macros)

*Difficulty: *Medium / Hard

*Mentor:* Mike Anderson (core.matrix maintainer)


Incanter Integration with core.matrix

*Brief explanation:* core.matrix provides a general purpose API for vector 
/ matrix computation in Clojure. Incanter is a Clojure-based R-like 
platform for statistical computing and graphics. Historically these have 
developed separately, but there would be considerable value in extending 
core.matrix so that it supports everything Incanter needs and converting 
Incanter to use core.matrix directly, rather than it's own custom matrix 
wrapper functionality. This combination would offer substantial new 
capabilities to users, and harmonise two of the major numerical computing 
projects in the Clojure ecosystem.

*Expected results: *core.matrix extended to provide full support for all 
Incanter functionality, and Incanter patched to use core.matrix. Ideally 
the Incanter changes would be merged into the next release of Incanter 
(subject to agreement of Incanter project leads)

*Knowledge prerequisites:* Linear Algebra, Statistics, Experience of Clojure

*Difficulty: *Medium 

*Mentor:* Mike Anderson (core.matrix maintainer), TBC (Incanter maintainer 
/ mentor)



Algebraic Expressions

*Brief explanation:* core.matrix provides a general purpose API for vector 
/ matrix computation in Clojure. There would be considerable value to 
creating a module that is able to represent algebraic expressions 
containing matrix computations, and optimise these for execution using 
core.matrix. Logic Programming (via core.logic) could be used to perform 
manipulation / simplification of expressions (e.g. using tree rewriting 
rules). An obvious application of this module would be to create numerical 
equation solvers in Clojure. Some experimental ideas exist in the 
repository: https://github.com/clojure-numerics/expresso

*Expected results: *A system of expressing algebraic expressions, 
transforming these into optimised forms and executing these on core.matrix. 
This should be supported by a documented sample application that 
demonstrates applying this system to an example problem.

*Knowledge prerequisites:* Advanced Linear Algebra / Theorem Proving, Logic 
Programming (ideally core.logic), Experience of Clojure

*Difficulty: *Hard 

*Mentor:* Mike Anderson (core.matrix maintainer)


API Contract Validation

*Brief explanation:* core.matrix provides a general purpose API for vector 
/ matrix computation in Clojure. A key innovation is support for multiple 
back-end implementations (e.g. optimised native libraries or various Java 
libraries). However, it is necessary for testing and correctness purposes 
to validate that the implementations conform to the contracts represented 
in the core.matrix API. This validation is complicated by the fact that 
different implementations may support a different subset of core.matrix 
features (e.g. only supporting 1D and 2D arrays, double types vs. int 
types, support for mutability etc.)

*Expected results: *A validation framework that is able to represent the 
contracts in the core.matrix API, and validate these against any 
core.matrix implementation. Successful validation should be demonstrated 
against all the standard implementations present in core.matrix itself, and 
against at least one external implementation (e.g. vectorz-clj). 

*Knowledge prerequisites:* API Design, Design by Contract methodologies, 
Experience of Clojure

*Difficulty: *Medium/Hard

*Mentor:* Mike Anderson (core.matrix maintainer)



On Tuesday, 26 March 2013 22:02:24 UTC+8, Daniel Solano Gómez wrote:
>
> Hello, all, 
>
> There are just three days left to prepare our application for GSoC 2013. 
> Although we have a number of really good ideas up on our Project Ideas 
> page <http://dev.clojure.org/display/community/Project+Ideas>, we really 
> need to do a lot more in order to strengthen our application. 
>
> By submitting ideas to the project page, you needn't commit to being a 
> mentor.  The most important thing is to put together a great list so 
> that Clojure can participate in this year's GSoC. 
>
> Thank you for your help. 
>
> Sincerely, 
>
> Daniel 
>

-- 
-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.


Reply via email to