
Release 0.1 
  Appetizer
  Lagrange elements of general order on triangles 
  Lagrange elements of general order on tetrahedra 
  Integration on general triangles 
  Integration on general tetrahedra 
  Poisson element matrices on general triangles 
  Poisson element matrices on general tetrahedra 
  Simple regression testing 
  Barycentric coordinates  
  Bezier coordinates  
  Degrees of freedom 
  Document the current features  
  Clean up

Release 0.2 
  Bernstein polynomials (ok)
  RaviartThomas (ok in 2D) 
  Stokes element matrices on general triangles (ok)
  Python support by using SWIG and SWIGiNaC  (ok) 
  Simple unit square mesh for academic testing of new methods (ok)
  Global matrices and dofs on the academic mesh (ok) 
  Make the example with the nonlinear PDE and the computed Jacobian clean
  Document the current features  
  Clean up

Release 0.3 
  Legendre polynomials (ok)
  Code generation of element basis functions and  element matrices for Dolfin og Diffpack (ok) 
  The Nedelec element (ok)  
  The Hermite element (ok)
  Employ linear algebra packages, e.g., Trilinos (ok) 
  Document the current features  

Release 0.4 
  Improve consistens and safety checks. 
  Employ other mesh packages, e.g., NetGen, DUNE. 
  Implement the equivalent to Legendre polynomials on triangles and tetrahedrons
  Clean up the 1D factory and make a FSI test
  Make a user-defined matrix factory 
  More complicated element methods, like the newly introduced 
    elements for the mixed formulation of elasticity problems
  Employ Instant for inlining in Python
  Clean up toex/eval (ok) 
  Autoconf regression testing/or move the running of tests to Python ? 

Release 0.5 
  Implement exterior calculus 
  Document the current features  



Random comments: 

  Could make templates for matrix element computations,
  matrix insertion, and grid traversal, i.e. :   

    compute_matrix <grid_iterator, element_matrix_calculator, global_matrix> 

  an instance might then look like 
   
    compute_matrix <dolfin_iterator, mass_elm_matrix, epetra_matrix> 

    1. dolfin_iterator is a small layer on top of a Dolfin mesh
    2. mass_elm_matrix is provided by SyFi 
    3. the loc2glob mapping is provided by SyFi in DofT 
    4. epetra_matrix is a small layer on top of the Epetra matrix and DofT 


  
  


  Implement classes that for vectors and sums of expressions  ? 
  Optimization of code generation based on tree traversal ?


Ways to go from elements/element matrices to global matrices: 
  1. Generate code for the finite elements.  
     This would be natural in connection with e.g. Diffpack or deal.II
     This should be fairly easy. 
  2. Generate code for the basis functions, their derivatives,
     element matrices etc. in quadrature points.  
     This is natural in connection with dolphin. 
  3. Optimize the expression for the global element matrices.  
     Then it is simply a matter of running through the grid
     to find the coordinates. 
  4. Optimize the Poisson eksample such that it is comparable
     with e.g. Diffpack.   

  


Should the basis functions etc. be ex or ex&  ? 


namespace: should I use GiNaC::ex or just ex ? 
This question comes into play when using SWIG and Swiginac
Stick to GiNaC::ex for now.  Document this!!

GiNaC has --real-- trouble with an 18x18 matrix. How to deal with
it ?   

Slicing of lst ? 

Symbol factory is needed. Have just wasted several hours!  
A symbol factory is also a bit dangerous.  

Should the order of the nodes in the Polygon constructor matter or
should the Polygon's determine the order themselves. In the latter
case a mapping must be stored.

The Poisson matrix maker should probably be a class ? 
This will make sure that doxygen generates documentation

Check the code that is supposed to fix the comparison of ex. 

Check if it is possible to take integrate*2 and then eval_integ*2 (it is with tree traversal)  



Design:  
      1. What should be the basic vector structure ? 
         lst and exvector does not provide +-/* etc. 
	 matrix does and is more general, but slightly
	 inelegant 

      2. Error handling

