This is a high level list of projects involving ndarrays that still need to get done organized by topics. For an overview of what is currently available check out:

• ndarray
• ndarray-tutorial

Already kind of possible using ndarray-hash and ndarray-segment, but we need more sparse formats and better routines for working with them and converting between them

cwise should be able to exploit run length encoded and sparse matrices. This is very important for voxel.js

Similar to cwise, would be nice if we could use code generation to get fast generic tensor operations on ndarrays. This would let us generate modules for arbitrary expressions in Einstein summation and possibly other situations

A common pattern with ndarrays is to use lazy just-in-time code generation that generates an optimized routine based on pattern matching types. It would be nice if we could encode this somehow into JavaScript using some sort of meta language/module so that it would be easier to explain and modify these sorts of routines. More work would be necessary to figure out how this could be done though

Might be nice to have inspectors/logging tools for investigating ndarrays. Maybe have some options for bounds checking that can be turned on.

Currently little progress in this area so far. If someone wants to take up the banner and lead onward, here is a list of projects:

• Should take into account striding, use JIT code generation

• Sparse products should be blazing fast, need to figure out the best solution for how to handle this.

• Same deal as above. For tricky non-aligned case use divide-and-conquer.

• Question: Is Strassen-type iteration worth it?

• Question: Should sparse matrix products be supported?

• Dense version is kind of easy

• Sparse is pretty hard, could try to port some native code with emscripten

• Mainly useful with sparse matrices, already have some arly work

• Again, pretty straightforward. Same concept as above

• Sparse stuff should be done with Lanczos algorithm/arnoldi method

• Dense somewhat easy

• Sparse requires hard work

• Should be easy given svd, maybe don't even need separate module

• Maybe not necessary to use ndarrays here

• Cholesky
• LU
• etc.

Possibly using emscripten

• Must have, could probably implement a couple of different algorithms

• Also must have. The current quadprog on npm works, but is a kind of crappy port of some R code and is very slow. A better version is clearly needed.

• Could try out a couple of methods, bfs, push-relabel, etc.

• Side effect of network flow

• CPLEX
• CERES
• UMFPACK
• ..?

Can use dual contouring/surface nets. Should work for arbitrary dimensions. This is already mostly there, but will take a bit more work to get it to work on general ndarrays. Would also be nice to exploit sparsity when possible.

Have raymarch, but it needs a lot more work. Should also try to figure out how to make this more modular.

Basically a dimension independent voxelize

Maybe connect with d3.js somehow?

• Maybe pipe plots to streams or render to ndarrays?

• Minecraft schematics
• ...?