Make combine2 work with selectors

Move selectors to the backend where they belong

Fiddle with enum*Each functions

Needs the -rtsopts

Add vector version of quickhull to Makefile

Add parallel vector version of quickhull

Don't measure time to create input vector in quickhull vector version (duh)

Added Data.Seq version to QuickHull.hs benchmark

More delaunay optimisations

Optimise delaunay a bit

Remove repeatc*

Optimise vectorised versions of not, (||) and (&&)

Add indexedP and friends

Add inline pragmas

Parallel list version using 'par'

Start on Vector version of quickhull

Add benchmarking version of delaunay

Fix bug in delaunay

Add missing files and svg generation to list delaunay

First attempt at Delaunay triangulation (doesn't work correctly yet)

Add updateP and bpermuteP to the prelude

Add updatePA and bpermutePA

Add updatePR and friends

Optimise bpermutePR<PArray a> slightly

Fix strictness bug in replicateUP

Add traces

Implement slicePA_l

Fix bad bug in replicatePA_l

Add interleave{U|UP}

Fiddle with tracing functions

Wibbles to C quickhull for Solaris

Add C version of quickhull

Add some optimisation rules

Add seq rules

Add support for loading data from file to SVG QH

Fix test data generation for QH

Add tracing support to TH generators

Add a couple of traceFn

Remove dead code

Fix applPR<PArray a>

Add plusSegd

Fix bug in bpermutePR<PArray a>

Add import

Derive Show for EitherS and MaybeS

Test data generator for Quickhull

Slight optimisation in Quickhull

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