Fix reciprocal vector calculation in Laplacian.

Attempt to fix SPAM3 iteration.

Ignore negative frequencies on converting from reciprocal to psinc.

Work around weird Fortran unary operator handling.

Fortran dislikes unary plus or minus on right right hand side of
an arithmetic operator.

Correctly scale inner product integral.

Add matrix element assignment.

Generate SPAM3 iteration code.

Start work on assignment iteration.

Rename ProducerStatement to IteratedStatement.

Add nodes on ONETEP's matrix and function distribution.

Add code generation for inner product.

Add min and max intrinsics to code generator.

Handle origin of fields.

Add field scaling operator.

Add conversion from reciprocal to psinc space.

Implement application of laplacian operator.

Generate code to transform into reciprocal space.

Generate calls for copying PPD data to FFT-box.

Initial FunctionSignature implementation.

Work on converting to reciprocal space.

Add array allocation/deallocation statements.

Skeleton for fragment-based code generation.

More work on tree generation.

Start work on pattern matching.

Build back-end independent DSL representation.

Start work on different composition strategy.

Work on index binding.

Don't use wrappers to bind indices.

Move IndexBindings into separate file.

Ignore composition issues for now.

It's unclear how to correctly compose the code fragments generated by
the various operands. Instead, let's just have everything create
ProducerStatements and merge them.

Work on SpatialRestriction consumer/producer.

Add if statement generation.

Add tightbox centres to indices from PPDFunctionSet.

Switch back to "fftbox" not taking an index parameter.

Move public fields into OnetepTypes.

Re-enable construction of SpatialRestriction node.

The SpatialRestriction node corresponds to a FFT-box. We need to
specify where the FFT-box is to be constructed, so we have to pass an
index variable to "fftbox" as well. This is ugly, but we can just about
handle it in our current parser.

Add index binding operators to expression tree.

Include indexing in trivial test input.

Have PPDFunctionSet generate indices.

Calculate x, y, z & data value in PPDFunctionSet.

Implement Fortran line wrapping.

Fix so generated code compiles (except for long lines).

Generate variable declarations.

Make expressions and variables carry their types.

Implement precedence-based expression bracketing.

Finally get control flow nesting right in ProducerStatement.

Enable topological sorting with priority function.

Switch to new sorting code in ProducerStatement.

Move queue implementations into new file.

Add priority queue wrapper.

Add graph implementation including topological sort.

Move more PPD-related expressions into new symbols.

Use better control-flow nesting in ProduderStatement.

When we do not have any dependencies between a loops, a predicates and
expressions, place expressions outside loops, but both loops and
expressions inside predicates.

Generate basic loop structures.

Reimplement transitive closure for better reuse.

Compute dependencies between constructs in ProducerStatement.

Add skeleton for Fortran generation.

Initial work on re-enabling tree builder and code generator.

Construct PPDFunctionSet producer iteration space.

Work on typing expressions.

More work on PPDFunctionSet.

Add ternary operator class.

Calculate PPD locations (in PPD co-ordinate system).

More work on characterising producers.

Random notes on consumers and producers.

Add incoherent thoughts about DSL operator semantics.

Replace array ranges with iteration symbols.

Ignore Vim swap files and only top-level build dir.

Work on expression representation.

Work on building types for code generation.

Disable most of existing code generation framework.

Remove old Python implementation.

Ignore generated files.

Fix typo in file name.

Add report on implementation issues.

Add some more work on the expression evaluation strategy.

Add notes on expression strategy.

Add some notes on allocation.

Rename Tree.scala to prevent ant always rebuilding.

Re-work tree rendering code.

Work on buffer placement.

Add trivial SpatialRestriction consumer.

Fix generated code so it compiles.

Move multiple IterationSpace classes into new files.

Generate something resembling PPD iteration code.

Work on producer/consumer model of transforms.

Beautify some debug output.

Improve tree rendering.

Construct sorted and fused loop hierarchy.

New index fusion implementation.

Generate loop headers and footers.

More work on fixing loop hierarchy.

Generate (rather flawed loop hierarchy).

Initial work on generating loop hierarchy.

Handle external indices differently.

Minor changes to index handling.

More updates to notes.

Extend notes.

More work on iteration generation.

Work on generating loop declarations.