jsr166z.forkjoin
Class ParallelIntArray

java.lang.Object
  extended by jsr166z.forkjoin.ParallelIntArray

public class ParallelIntArray
extends java.lang.Object

An array of ints supporting parallel operations. This class provides methods supporting the same operations as ParallelArray, but specialized for scalar integers. It additionally provides a few methods specific to numerical values.


Nested Class Summary
static class ParallelIntArray.WithBounds
          A restriction of parallel array operations to apply only within a given range of indices.
static class ParallelIntArray.WithDoubleMapping
          A modifier for parallel array operations to apply to mappings of elements to doubles, not to the elements themselves
static class ParallelIntArray.WithFilter
          A restriction of parallel array operations to apply only to elements for which a selector returns true
static class ParallelIntArray.WithIntMapping
          A modifier for parallel array operations to apply to mappings of elements to ints, not to the elements themselves
static class ParallelIntArray.WithLongMapping
          A modifier for parallel array operations to apply to mappings of elements to longs, not to the elements themselves
static class ParallelIntArray.WithMapping<U>
          A modifier for parallel array operations to apply to mappings of elements, not to the elements themselves
 
Constructor Summary
ParallelIntArray(ForkJoinExecutor executor, int size)
          Creates a new ParallelIntArray using the given executor and an array of the given size.
ParallelIntArray(ForkJoinExecutor executor, int[] handoff)
          Creates a new ParallelIntArray using the given executor and array.
ParallelIntArray(ForkJoinExecutor executor, int size, int[] sourceToCopy)
          Creates a new ParallelIntArray using the given executor and an array of the given size, initially holding copies of the given source truncated or padded with zero to obtain the specified length.
 
Method Summary
 void apply({int=>void} procedure)
          Applies the given procedure to elements
 ParallelIntArray combine(int[] other, {int,int=>int} combiner)
          Returns a ParallelArray containing results of applying combine(thisElement, otherElement) for each element.
 ParallelIntArray combine(ParallelIntArray other, {int,int=>int} combiner)
          Returns a ParallelArray containing results of applying combine(thisElement, otherElement) for each element.
 void cumulate({int,int=>int} reducer, int base)
          Replaces each element with the running cumulation of applying the given reducer.
 void cumulateSum()
          Replaces each element with the running sum
 int get(int i)
          Returns the element of the array at the given index
 int[] getArray()
          Returns the underlying array used for computations
 ForkJoinExecutor getExecutor()
          Returns the executor used for computations
 int indexOfMax()
          Returns the index of the greatest element , or -1 if empty assuming that all elements are Comparables
 int indexOfMax({int,int=>int} comparator)
          Returns the index of the greatest element , or -1 if empty
 int indexOfMin()
          Returns the index of the least element , or -1 if empty assuming that all elements are Comparables
 int indexOfMin({int,int=>int} comparator)
          Returns the index of the least element , or -1 if empty
 int max()
          Returns the maximum element, or Integer.MIN_VALUE if empty assuming that all elements are Comparables
 int max({int,int=>int} comparator)
          Returns the maximum element, or Integer.MIN_VALUE if empty
 int min()
          Returns the minimum element, or Integer.MAX_VALUE if empty, assuming that all elements are Comparables
 int min({int,int=>int} comparator)
          Returns the minimum element, or Integer.MAX_VALUE if empty
 ParallelIntArray newArray()
          Returns a new ParallelArray holding elements
 int precumulate({int,int=>int} reducer, int base)
          Replaces each element with the cumulation of applying the given reducer to all previous values, and returns the total reduction.
 int precumulateSum()
          Replaces each element with its prefix sum
 void randomFill()
          Sets each element to a uniform random value having the same properties as Random.nextInt()
 void randomFill(int bound)
          Sets each element to a uniform random value having the same properties as Random.nextInt(int)
 int reduce({int,int=>int} reducer, int base)
          Returns reduction of elements
 void replaceWithCombination(int[] other, {int,int=>int} combiner)
          Replaces elements with results of applying combine(thisElement, otherElement)
 void replaceWithCombination(ParallelIntArray other, {int,int=>int} combiner)
          Replaces elements with results of applying combine(thisElement, otherElement)
 void replaceWithGeneratedValue({=>int} generator)
          Replaces elements with the results of applying the given generator.
 void replaceWithMappedIndex({int=>int} mapper)
          Replaces elements with the results of applying the given mapper to their indices.
 void replaceWithTransform({int=>int} mapper)
          Replaces elements with the results of applying the given mapper to their current values.
 void replaceWithValue(int value)
          Replaces elements with the given value.
 void set(int i, int x)
          Sets the element of the array at the given index to the given value
 int size()
          Returns the length of the underlying array
 void sort()
          Sorts the array, using natural comparator.
 void sort({int,int=>int} comparator)
          Sorts the array
 int sum()
          Returns the sum of elements
 ParallelIntArray.WithBounds withBounds(int firstIndex, int upperBound)
          Returns an operation prefix that causes a method to operate only on the elements of the array between firstIndex (inclusive) and upperBound (exclusive).
 ParallelIntArray.WithFilter withFilter({int=>boolean} selector)
          Returns an operation prefix that causes a method to operate only on the elements of the array for which the given selector returns true
 ParallelIntArray.WithDoubleMapping withMapping({int=>double} mapper)
          Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.
 ParallelIntArray.WithIntMapping withMapping({int=>int} mapper)
          Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.
 ParallelIntArray.WithLongMapping withMapping({int=>long} mapper)
          Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.
<U> ParallelIntArray.WithMapping<U>
withMapping({int=>U} mapper)
          Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

ParallelIntArray

public ParallelIntArray(ForkJoinExecutor executor,
                        int[] handoff)
Creates a new ParallelIntArray using the given executor and array. In general, the handed off array should not be used for other purposes once constructing this ParallelIntArray.

Parameters:
executor - the executor
handoff - the array

ParallelIntArray

public ParallelIntArray(ForkJoinExecutor executor,
                        int size,
                        int[] sourceToCopy)
Creates a new ParallelIntArray using the given executor and an array of the given size, initially holding copies of the given source truncated or padded with zero to obtain the specified length.

Parameters:
executor - the executor
size - the array size
sourceToCopy - the source of initial elements

ParallelIntArray

public ParallelIntArray(ForkJoinExecutor executor,
                        int size)
Creates a new ParallelIntArray using the given executor and an array of the given size.

Parameters:
executor - the executor
size - the array size
Method Detail

getExecutor

public ForkJoinExecutor getExecutor()
Returns the executor used for computations

Returns:
the executor

getArray

public int[] getArray()
Returns the underlying array used for computations

Returns:
the array

size

public int size()
Returns the length of the underlying array

Returns:
the length of the underlying array

get

public int get(int i)
Returns the element of the array at the given index

Parameters:
i - the index
Returns:
the element of the array at the given index

set

public void set(int i,
                int x)
Sets the element of the array at the given index to the given value

Parameters:
i - the index
x - the value

apply

public void apply({int=>void} procedure)
Applies the given procedure to elements

Parameters:
procedure - the procedure

reduce

public int reduce({int,int=>int} reducer,
                  int base)
Returns reduction of elements

Parameters:
reducer - the reducer
base - the result for an empty array
Returns:
reduction

newArray

public ParallelIntArray newArray()
Returns a new ParallelArray holding elements

Returns:
a new ParallelArray holding elements

combine

public ParallelIntArray combine(int[] other,
                                {int,int=>int} combiner)
Returns a ParallelArray containing results of applying combine(thisElement, otherElement) for each element.

Parameters:
other - the other array
combiner - the combiner
Returns:
the array of mappings
Throws:
java.lang.ArrayIndexOutOfBoundsException - if other array is shorter than this array.

combine

public ParallelIntArray combine(ParallelIntArray other,
                                {int,int=>int} combiner)
Returns a ParallelArray containing results of applying combine(thisElement, otherElement) for each element.

Parameters:
other - the other array
combiner - the combiner
Returns:
the array of mappings
Throws:
java.lang.ArrayIndexOutOfBoundsException - if other array is not the same length as this array.

replaceWithTransform

public void replaceWithTransform({int=>int} mapper)
Replaces elements with the results of applying the given mapper to their current values.

Parameters:
mapper - the mapper

replaceWithMappedIndex

public void replaceWithMappedIndex({int=>int} mapper)
Replaces elements with the results of applying the given mapper to their indices.

Parameters:
mapper - the mapper

replaceWithGeneratedValue

public void replaceWithGeneratedValue({=>int} generator)
Replaces elements with the results of applying the given generator.

Parameters:
generator - the generator

randomFill

public void randomFill()
Sets each element to a uniform random value having the same properties as Random.nextInt()


randomFill

public void randomFill(int bound)
Sets each element to a uniform random value having the same properties as Random.nextInt(int)

Parameters:
bound - the upper bound of each random value
Throws:
java.lang.IllegalArgumentException - if bound less than or equal to zero

replaceWithValue

public void replaceWithValue(int value)
Replaces elements with the given value.

Parameters:
value - the value

replaceWithCombination

public void replaceWithCombination(ParallelIntArray other,
                                   {int,int=>int} combiner)
Replaces elements with results of applying combine(thisElement, otherElement)

Parameters:
other - the other array
combiner - the combiner
Throws:
java.lang.ArrayIndexOutOfBoundsException - if other array has fewer elements than this array.

replaceWithCombination

public void replaceWithCombination(int[] other,
                                   {int,int=>int} combiner)
Replaces elements with results of applying combine(thisElement, otherElement)

Parameters:
other - the other array
combiner - the combiner
Throws:
java.lang.ArrayIndexOutOfBoundsException - if other array has fewer elements than this array.

indexOfMin

public int indexOfMin({int,int=>int} comparator)
Returns the index of the least element , or -1 if empty

Parameters:
comparator - the comparator
Returns:
the index of least element or -1 if empty.

indexOfMax

public int indexOfMax({int,int=>int} comparator)
Returns the index of the greatest element , or -1 if empty

Parameters:
comparator - the comparator
Returns:
the index of greatest element or -1 if empty.

indexOfMin

public int indexOfMin()
Returns the index of the least element , or -1 if empty assuming that all elements are Comparables

Returns:
the index of least element or -1 if empty.

indexOfMax

public int indexOfMax()
Returns the index of the greatest element , or -1 if empty assuming that all elements are Comparables

Returns:
the index of greatest element or -1 if empty.

min

public int min({int,int=>int} comparator)
Returns the minimum element, or Integer.MAX_VALUE if empty

Parameters:
comparator - the comparator
Returns:
minimum element, or Integer.MAX_VALUE if empty

min

public int min()
Returns the minimum element, or Integer.MAX_VALUE if empty, assuming that all elements are Comparables

Returns:
minimum element, or Integer.MAX_VALUE if empty

max

public int max({int,int=>int} comparator)
Returns the maximum element, or Integer.MIN_VALUE if empty

Parameters:
comparator - the comparator
Returns:
maximum element, or Integer.MIN_VALUE if empty

max

public int max()
Returns the maximum element, or Integer.MIN_VALUE if empty assuming that all elements are Comparables

Returns:
maximum element, or Integer.MIN_VALUE if empty

sum

public int sum()
Returns the sum of elements

Returns:
the sum of elements

cumulate

public void cumulate({int,int=>int} reducer,
                     int base)
Replaces each element with the running cumulation of applying the given reducer. For example, if the contents are the numbers 1, 2, 3, and the reducer operation adds numbers, then after invocation of this method, the contents would be 1, 3, 6 (that is, 1, 1+2, 1+2+3);

Parameters:
reducer - the reducer
base - the result for an empty array

precumulate

public int precumulate({int,int=>int} reducer,
                       int base)
Replaces each element with the cumulation of applying the given reducer to all previous values, and returns the total reduction. For example, if the contents are the numbers 1, 2, 3, and the reducer operation adds numbers, then after invocation of this method, the contents would be 0, 1, 3 (that is, 0, 0+1, 0+1+2, and the return value would be 6 (that is, 1+2+3);

Parameters:
reducer - the reducer
base - the result for an empty array
Returns:
the total reduction

cumulateSum

public void cumulateSum()
Replaces each element with the running sum


precumulateSum

public int precumulateSum()
Replaces each element with its prefix sum

Returns:
the total sum

sort

public void sort({int,int=>int} comparator)
Sorts the array

Parameters:
comparator - the comparator to use

sort

public void sort()
Sorts the array, using natural comparator.


withBounds

public ParallelIntArray.WithBounds withBounds(int firstIndex,
                                              int upperBound)
Returns an operation prefix that causes a method to operate only on the elements of the array between firstIndex (inclusive) and upperBound (exclusive).

Parameters:
firstIndex - the lower bound (inclusive)
upperBound - the upper bound (exclusive)
Returns:
operation prefix

withFilter

public ParallelIntArray.WithFilter withFilter({int=>boolean} selector)
Returns an operation prefix that causes a method to operate only on the elements of the array for which the given selector returns true

Parameters:
selector - the selector
Returns:
operation prefix

withMapping

public <U> ParallelIntArray.WithMapping<U> withMapping({int=>U} mapper)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.

Parameters:
mapper - the mapper
Returns:
operation prefix

withMapping

public ParallelIntArray.WithDoubleMapping withMapping({int=>double} mapper)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.

Parameters:
mapper - the mapper
Returns:
operation prefix

withMapping

public ParallelIntArray.WithLongMapping withMapping({int=>long} mapper)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.

Parameters:
mapper - the mapper
Returns:
operation prefix

withMapping

public ParallelIntArray.WithIntMapping withMapping({int=>int} mapper)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given mapper.

Parameters:
mapper - the mapper
Returns:
operation prefix