Add rule for zipWith/replicate

Use -rtsopts when building test cases

Add a seq/sum rule

Fix strictness of various Lifted combinators

Remove unneeded parameters from indices_s

lengthsToSegd is no longer special

Sanitise zipU and unzipU

  * unzipU now return a lazy pair instead of a strict one

  * There is an unzipU/zipU rule

  * zip3, zipWith3 and unzip3 are defined in DPH_Interface

Make packPA_l strict

Fix load balancing issue with indices_s

Fix load balancing bug in segmented sums

Add exports

Add debugging function

Rewrite test data generation in quickhull

Add a seq rule for scanlU (+) 0

This occurs quite frequently when calculating segment descriptors.
Nevertheless, it is a hack.

Implement parallel lifted append

This requires append_s and friends to take the segment descriptor of the
result as an additional parameter. This change is also propagated to the
Lifted stuff.

Implement fold1SUP

Make replicateSUP produce evenly distributed arrays

Make enumFromStepLenUP more efficient

Make foldUP more efficient at the cost of a slight change in semantics

We now make no guarantees about how often the neutral element will be used. It
really has to be neutral.

Fix implementation of repeat_c

Add a function for splitting a segment descriptor such that the data array will be evenly distributed

Add export

Change various functions to use generateD/imapD

Delay inlining unitD

Only inline zipD in phase 0 to give some rules a chance to match in phase 1

New combinators in DistST

Add RULES for zipU/joinD and zipU/splitJoinD

Completely change how mapD and friends are implemented

The basic combinators are now

generateD :: DT a => Gang -> (Int -> a) -> Dist a
imapD :: (DT a, DT b) => Gang -> (Int -> a -> b) -> Dist a -> Dist b

The Int argument is the index of the current thread. There is also

generateD_cheap :: DT a => Gang -> (Int -> a) -> Dist a

which is equivalent to generateD but just runs the computation sequentially.

Don't inline scanD

Make joinD CONLIKE

Manually eta-expand mapUP

Fix and use enumFromToEachUP

Export more stuff

Add dependency

Tracing for gangs

Add tracing facilities to Dist

Use divInt, modInt etc.

Refactoring to avoid making splitJoinD a loop breaker

Add bangs

Remove sequential gangs

Build system: Fix use of "rm" variables

Add fftS to harness

Fix bugs in FFT benchmark

You can also now say
   seq/fft check

  and it will do a 1d transform of a step function,
  with both the FFT kernel and a DFT.

Print checksums of resulting matrices in mmult examples

Add to mmult C harness
You can generate random matrices with -random, then save them
to file with -ddumpinput. Load them back up with the Haskell
version and check the output is the same.

Hacks to C mmult

Faster generation of random matrices for mmult

Start on C ver of mmult

Split useful stuff out of C version of Laplace, and add to Makefile

Add DArray versions of mmult

Add version of mmMult using traverse

Add to mmult harness

More fft

Added Any, test for fft

Add to mmult harness, it'll read matrices from file but not write them back yet

CArray version of fft

More CArray ops

Add a couple of CArray ops

Start on CArray mmult harness

'port across more stuff from DArray into CArray

Add replicateSlice

Add transpose and backpermute

Cleanup and nicer version of traverseCArray

Fix traverseCArray

Hacks to SolveCArray (makes it slower, not finished)

Moving to Slice def of paper

Changing over to Slice type family from Index

Add benchmarking code to C laplace solver

Changed DArray, ArrayExamples, DArrayExamples to work with new shape type

Use Int indexing instead of (Int, Int) in IOUArray version of Laplace benchmark
Makes it go about 2x faster.

Output compute time in laplace

Add deepSeqArray

formatting only

Add first cut version of Laplace solver using IOUArrays
It's about 3x slower than carrays atm, but I'm still working on it...

wibble to traverseCArray

Add traverseCArray and use it in Laplace benchmark

Add more laplace example data

Refactor C version of Laplace benchmark to allow non-square matrices

Make Haskell version of Laplace benchmark take PPM file of boundary conditions

New cmd line usage is like:
  laplace carray-stencil 10000 examples/laplace/data/pls-100x100.ppm out.ppm

More example data is in regularArrays/examples/laplace/data

Refactor laplace solvers slightly

Fix strictness of various functions in CArray

Save one remInt in fromIndex

seq/deepSeq stuff when constructing DArrays

Give deepSeq a fixity

Fix typo

Change shapes to use (.:) instead of (:*:)

Remove superclass constraints on Shape

Get rid of range

Add deepSeq on Ranges

Use quotRemInt instead of divMod

Use regular folds

Add replicate_rs/replicate rule

Modify and export regular folds

Add comments to SolveDArray
Converting back and forth between DArray and Array allows
the indexing function that reads the forced data at the start of
each iteration to be fused with the stencil function.

This achieves the same thing as CArray, but by using two
different array types instead of an Either.

Cleanup and add more inline pragmas

Add Laplace benchmark to Makefile

Add version of CArray that uses a flat unboxed DIM type

Add support for default to sequential execution if the gang is busy

To enable, uncomment the #define SEQ_IF_GANG_BUSY line in Gang.hs. Let's see
if this works out before making it more convenient.

Fix comment

Change Gang representation slightly