org.codehaus.gpars

groovyx.gpars.extra166y
[Java] Class ParallelArray

java.lang.Object
  AbstractParallelAnyArray.OUPap
      groovyx.gpars.extra166y.ParallelArray
All Implemented Interfaces:
java.lang.Iterable

public class ParallelArray
extends OUPap

An array supporting parallel operations.

A ParallelArray maintains a ForkJoinPool and an array in order to provide parallel aggregate operations. The main operations are to apply some procedure to each element, to map each element to a new element, to replace each element, to select a subset of elements based on matching a predicate or ranges of indices, and to reduce all elements into a single value such as a sum.

A ParallelArray is constructed by allocating, using, or copying an array, using one of the static factory methods create, createEmpty, createUsingHandoff and createFromCopy. Upon construction, the encapsulated array managed by the ParallelArray must not be shared between threads without external synchronization. In particular, as is the case with any array, access by another thread of an element of a ParallelArray while another operation is in progress has undefined effects.

The ForkJoinPool used to construct a ParallelArray can be shared safely by other threads (and used in other ParallelArrays). To avoid the overhead associated with creating multiple executors, it is often a good idea to use the defaultExecutor() across all ParallelArrays. However, you might choose to use different ones for the sake of controlling processor usage, isolating faults, and/or ensuring progress.

A ParallelArray is not a List. It relies on random access across array elements to support efficient parallel operations. However, a ParallelArray can be viewed and manipulated as a List, via method ParallelArray#asList#asList. The asList view allows incremental insertion and modification of elements while setting up a ParallelArray, generally before using it for parallel operations. Similarly, the list view may be useful when accessing the results of computations in sequential contexts. A ParallelArray may also be created using the elements of any other Collection, by constructing from the array returned by the Collection's toArray method. The effects of mutative asList operations may also be achieved directly using method setLimit along with element-by-element access methods get and set.

While ParallelArrays can be based on any kind of an object array, including "boxed" types such as Long, parallel operations on scalar "unboxed" type are likely to be substantially more efficient. For this reason, classes ParallelLongArray and ParallelDoubleArray are also supplied, and designed to smoothly interoperate with ParallelArrays. You should also use a ParallelLongArray for processing other integral scalar data (int, short, etc). And similarly use a ParallelDoubleArray for float data. (Further specializations for these other types would add clutter without significantly improving performance beyond that of the Long and Double versions.)

Most usages of ParallelArray involve sets of operations prefixed with range bounds, filters, and mappings (including mappings that combine elements from other ParallelArrays), using withBounds, withFilter, and withMapping, respectively. For example, aParallelArray.withFilter(aPredicate).all() creates a new ParallelArray containing only those elements matching the predicate. And for ParallelLongArrays a, b, and c, a.withMapping(CommonOps.longAdder(),b).withMapping(CommonOps.longAdder(),c).min() returns the minimum value of a[i]+b[i]+c[i] for all i. As illustrated below, a mapping often represents accessing some field or invoking some method of an element. These versions are typically more efficient than performing selections, then mappings, then other operations in multiple (parallel) steps. The basic ideas and usages of filtering and mapping are similar to those in database query systems such as SQL, but take a more restrictive form. Series of filter and mapping prefixes may each be cascaded, but all filter prefixes must precede all mapping prefixes, to ensure efficient execution in a single parallel step. In cases of combined mapping expressions, this rule is only dynamically enforced. For example, pa.withMapping(op, pb.withFilter(f)) will compile but throw an exception upon execution because the filter precedes the mapping.

While series of filters and mappings are allowed, it is usually more efficient to combine them into single filters or mappings when possible. For example pa.withMapping(addOne).withMapping(addOne) is generally less efficient than pa.withMapping(addTwo). Methods withIndexedFilter and withIndexedMapping may be useful when combining such expressions.

This class includes some reductions, such as min, that are commonly useful for most element types, as well as a combined version, summary, that computes all of them in a single parallel step, which is normally more efficient than computing each in turn.

The methods in this class are designed to perform efficiently with both large and small pools, even with single-thread pools on uniprocessors. However, there is some overhead in parallelizing operations, so short computations on small arrays might not execute faster than sequential versions, and might even be slower.

Sample usages. The main difference between programming with plain arrays and programming with aggregates is that you must separately define each of the component functions on elements. For example, the following returns the maximum Grade Point Average across all senior students, given a (fictional) Student class:

 import static Ops.*;
 class StudentStatistics {
   ParallelArray<Student> students = ...
   // ...
   public double getMaxSeniorGpa() {
     return students.withFilter(isSenior).withMapping(gpaField).max();
   }

   // helpers:
   static final class IsSenior implements Predicate<Student> {
     public boolean op(Student s) { return s.credits > 90; }
   }
   static final IsSenior isSenior = new IsSenior();
   static final class GpaField implements ObjectToDouble<Student> {
     public double op(Student s) { return s.gpa; }
   }
   static final GpaField gpaField = new GpaField();
 }
 


Nested Class Summary
class ParallelArray.AsList

class ParallelArray.ListIter

static class ParallelArray.ParallelArrayIterator

static interface ParallelArray.SummaryStatistics

Summary statistics for a possibly bounded, filtered, and/or mapped ParallelArray.

 
Field Summary
ParallelArray.AsList listView

Lazily constructed list view

 
Constructor Summary
protected ParallelArray(ForkJoinPool executor, java.lang.Object[] array, int limit)

Constructor for use by subclasses to create a new ParallelArray using the given executor, and initially using the supplied array, with effective size bound by the given limit.

ParallelArray(ForkJoinPool executor, java.lang.Object[] array)

Trusted internal version of protected constructor.

 
Method Summary
ParallelArray addAll(java.lang.Object[] other)

Equivalent to asList().addAll but specialized for array arguments and likely to be more efficient.

ParallelArray addAll(ParallelArrayWithMapping other)

Appends all (possibly bounded, filtered, or mapped) elements of the given ParallelArray, resizing and/or reallocating this array if necessary.

ParallelArray all()

Returns a new ParallelArray holding all elements

ParallelArray all(java.lang.Class elementType)

Returns a new ParallelArray with the given element type holding all elements

ParallelArray allNonidenticalElements()

Returns a new ParallelArray containing only the non-null unique elements of this array (that is, without any duplicates), using reference identity to test for duplication.

ParallelArray allUniqueElements()

Returns a new ParallelArray containing only the non-null unique elements of this array (that is, without any duplicates), using each element's equals method to test for duplication.

void appendElement(java.lang.Object e)

void apply(Procedure procedure)

Applies the given procedure to elements

java.util.List asList()

Returns a view of this ParallelArray as a List.

int binarySearch(java.lang.Object target)

Assuming this array is sorted, returns the index of an element equal to given target, or -1 if not present.

int binarySearch(java.lang.Object target, java.util.Comparator comparator)

Assuming this array is sorted with respect to the given comparator, returns the index of an element equal to given target, or -1 if not present.

static ParallelArray create(int size, java.lang.Class elementType, ForkJoinPool executor)

Creates a new ParallelArray using the given executor and an array of the given size constructed using the indicated base element type.

static ParallelArray createEmpty(int size, java.lang.Class elementType, ForkJoinPool executor)

Creates a new ParallelArray using the given executor and an array of the given size constructed using the indicated base element type, but with an initial effective size of zero, enabling incremental insertion via ParallelArray#asList#asList operations.

static ParallelArray createFromCopy(java.lang.Object[] source, ForkJoinPool executor)

Creates a new ParallelArray using the given executor and initially holding copies of the given source elements.

static ParallelArray createFromCopy(int size, java.lang.Object[] source, ForkJoinPool executor)

Creates a new ParallelArray using an array of the given size, initially holding copies of the given source truncated or padded with nulls to obtain the specified length.

static ParallelArray createUsingHandoff(java.lang.Object[] handoff, ForkJoinPool executor)

Creates a new ParallelArray initially using the given array and executor.

ParallelArray cumulate(Reducer reducer, java.lang.Object base)

Replaces each element with the running cumulation of applying the given reducer.

static ForkJoinPool defaultExecutor()

Returns a common default executor for use in ParallelArrays.

java.lang.Object get(int i)

Returns the element of the array at the given index

java.lang.Object[] getArray()

Returns the underlying array used for computations

ForkJoinPool getExecutor()

Returns the executor used for computations.

boolean hasAllEqualElements(ParallelArrayWithMapping other)

Returns true if all elements at the same relative positions of this and other array are equal.

boolean hasAllIdenticalElements(ParallelArrayWithMapping other)

Returns true if all elements at the same relative positions of this and other array are identical.

int indexOf(java.lang.Object target)

Returns the index of some element equal to given target, or -1 if not present

void insertElementAt(int index, java.lang.Object e)

void insertSlotsAt(int index, int len)

Makes len slots available at index.

java.util.Iterator iterator()

Returns an iterator stepping through each element of the array up to the current limit.

java.lang.Object max(java.util.Comparator comparator)

Returns the maximum element, or null if empty

java.lang.Object max()

Returns the maximum element, or null if empty assuming that all elements are Comparables

java.lang.Object min(java.util.Comparator comparator)

Returns the minimum element, or null if empty

java.lang.Object min()

Returns the minimum element, or null if empty, assuming that all elements are Comparables

java.lang.Object precumulate(Reducer reducer, java.lang.Object base)

Replaces each element with the cumulation of applying the given reducer to all previous values, and returns the total reduction.

java.lang.Object reduce(Reducer reducer, java.lang.Object base)

Returns reduction of elements

ParallelArray removeAll(Predicate selector)

Removes from the array all elements for which the given selector holds.

ParallelArray removeConsecutiveDuplicates()

Removes consecutive elements that are equal (or null), shifting others leftward, and possibly decreasing size.

ParallelArray removeNulls()

Removes null elements, shifting others leftward, and possibly decreasing size.

void removeSlotAt(int index)

void removeSlotsAt(int fromIndex, int toIndex)

void replaceElementsWith(java.lang.Object[] a)

ParallelArray replaceWithGeneratedValue(Generator generator)

Replaces elements with the results of applying the given generator.

ParallelArray replaceWithMappedIndex(IntToObject op)

Replaces elements with the results of applying the given mapping to their indices.

ParallelArray replaceWithMappedIndex(IntAndObjectToObject op)

Replaces elements with the results of applying the given mapping to each index and current element value

ParallelArray replaceWithMapping(Op op)

Replaces elements with the results of applying the given transform to their current values.

ParallelArray replaceWithMapping(BinaryOp combiner, ParallelArrayWithMapping other)

Replaces elements with results of applying op(thisElement, otherElement)

ParallelArray replaceWithMapping(BinaryOp combiner, java.lang.Object[] other)

Replaces elements with results of applying op(thisElement, otherElement)

ParallelArray replaceWithValue(java.lang.Object value)

Replaces elements with the given value.

void resizeArray(int newCap)

int seqIndexOf(java.lang.Object target)

int seqLastIndexOf(java.lang.Object target)

void set(int i, java.lang.Object x)

Sets the element of the array at the given index to the given value

void setLimit(int newLimit)

Ensures that the underlying array can be accessed up to the given upper bound, reallocating and copying the underlying array to expand if necessary.

int size()

Returns the effective size of the underlying array.

ParallelArray sort(java.util.Comparator comparator)

Sorts the array.

ParallelArray sort()

Sorts the array, assuming all elements are Comparable.

SummaryStatistics summary(java.util.Comparator comparator)

Returns summary statistics, using the given comparator to locate minimum and maximum elements.

SummaryStatistics summary()

Returns summary statistics, assuming that all elements are Comparables

java.lang.String toString()

Equivalent to asList().toString()

ParallelArrayWithBounds 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).

ParallelArrayWithFilter withFilter(Predicate 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

ParallelArrayWithFilter withFilter(BinaryPredicate selector, ParallelArrayWithMapping other)

Returns an operation prefix that causes a method to operate only on elements for which the given binary selector returns true

ParallelArrayWithFilter withIndexedFilter(IntAndObjectPredicate selector)

Returns an operation prefix that causes a method to operate only on elements for which the given indexed selector returns true

ParallelArrayWithMapping withIndexedMapping(IntAndObjectToObject mapper)

Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value.

ParallelArrayWithDoubleMapping withIndexedMapping(IntAndObjectToDouble mapper)

Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value.

ParallelArrayWithLongMapping withIndexedMapping(IntAndObjectToLong mapper)

Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value.

ParallelArrayWithMapping withMapping(Op op)

Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.

ParallelArrayWithDoubleMapping withMapping(ObjectToDouble op)

Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.

ParallelArrayWithLongMapping withMapping(ObjectToLong op)

Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.

ParallelArrayWithMapping withMapping(BinaryOp combiner, ParallelArrayWithMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithMapping withMapping(ObjectAndDoubleToObject combiner, ParallelDoubleArrayWithDoubleMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithMapping withMapping(ObjectAndLongToObject combiner, ParallelLongArrayWithLongMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithDoubleMapping withMapping(ObjectAndObjectToDouble combiner, ParallelArrayWithMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithDoubleMapping withMapping(ObjectAndDoubleToDouble combiner, ParallelDoubleArrayWithDoubleMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithDoubleMapping withMapping(ObjectAndLongToDouble combiner, ParallelLongArrayWithLongMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithLongMapping withMapping(ObjectAndObjectToLong combiner, ParallelArrayWithMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithLongMapping withMapping(ObjectAndDoubleToLong combiner, ParallelDoubleArrayWithDoubleMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

ParallelArrayWithLongMapping withMapping(ObjectAndLongToLong combiner, ParallelLongArrayWithLongMapping other)

Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.

 

Field Detail

listView

ParallelArray.AsList listView
Lazily constructed list view


 
Constructor Detail

ParallelArray

protected ParallelArray(ForkJoinPool executor, java.lang.Object[] array, int limit)
Constructor for use by subclasses to create a new ParallelArray using the given executor, and initially using the supplied array, with effective size bound by the given limit. This constructor is designed to enable extensions via subclassing. To create a ParallelArray, use create, createEmpty, createUsingHandoff or createFromCopy.
Parameters:
executor - the executor
array - the array
limit - the upper bound limit


ParallelArray

ParallelArray(ForkJoinPool executor, java.lang.Object[] array)
Trusted internal version of protected constructor.


 
Method Detail

addAll

public ParallelArray addAll(java.lang.Object[] other)
Equivalent to asList().addAll but specialized for array arguments and likely to be more efficient.
Parameters:
other - the elements to add
Returns:
this (to simplify use in expressions)


addAll

public ParallelArray addAll(ParallelArrayWithMapping other)
Appends all (possibly bounded, filtered, or mapped) elements of the given ParallelArray, resizing and/or reallocating this array if necessary.
Parameters:
other - the elements to add
Returns:
this (to simplify use in expressions)


all

public ParallelArray all()
Returns a new ParallelArray holding all elements
Returns:
a new ParallelArray holding all elements


all

public ParallelArray all(java.lang.Class elementType)
Returns a new ParallelArray with the given element type holding all elements
Parameters:
elementType - the type of the elements
Returns:
a new ParallelArray holding all elements


allNonidenticalElements

public ParallelArray allNonidenticalElements()
Returns a new ParallelArray containing only the non-null unique elements of this array (that is, without any duplicates), using reference identity to test for duplication.
Returns:
the new ParallelArray


allUniqueElements

public ParallelArray allUniqueElements()
Returns a new ParallelArray containing only the non-null unique elements of this array (that is, without any duplicates), using each element's equals method to test for duplication.
Returns:
the new ParallelArray


appendElement

final void appendElement(java.lang.Object e)


apply

public void apply(Procedure procedure)
Applies the given procedure to elements
Parameters:
procedure - the procedure


asList

public java.util.List asList()
Returns a view of this ParallelArray as a List. This List has the same structural and performance characteristics as java.util.ArrayList, and may be used to modify, replace or extend the bounds of the array underlying this ParallelArray. The methods supported by this list view are not in general implemented as parallel operations. This list is also not itself thread-safe. In particular, performing list updates while other parallel operations are in progress has undefined (and surely undesired) effects.
Returns:
a list view


binarySearch

public int binarySearch(java.lang.Object target)
Assuming this array is sorted, returns the index of an element equal to given target, or -1 if not present. If the array is not sorted, the results are undefined.
Parameters:
target - the element to search for
Returns:
the index or -1 if not present


binarySearch

public int binarySearch(java.lang.Object target, java.util.Comparator comparator)
Assuming this array is sorted with respect to the given comparator, returns the index of an element equal to given target, or -1 if not present. If the array is not sorted, the results are undefined.
Parameters:
target - the element to search for
comparator - the comparator
Returns:
the index or -1 if not present


create

public static ParallelArray create(int size, java.lang.Class elementType, ForkJoinPool executor)
Creates a new ParallelArray using the given executor and an array of the given size constructed using the indicated base element type.
Parameters:
size - the array size
elementType - the type of the elements
executor - the executor


createEmpty

public static ParallelArray createEmpty(int size, java.lang.Class elementType, ForkJoinPool executor)
Creates a new ParallelArray using the given executor and an array of the given size constructed using the indicated base element type, but with an initial effective size of zero, enabling incremental insertion via ParallelArray#asList#asList operations.
Parameters:
size - the array size
elementType - the type of the elements
executor - the executor


createFromCopy

public static ParallelArray createFromCopy(java.lang.Object[] source, ForkJoinPool executor)
Creates a new ParallelArray using the given executor and initially holding copies of the given source elements.
Parameters:
source - the source of initial elements
executor - the executor


createFromCopy

public static ParallelArray createFromCopy(int size, java.lang.Object[] source, ForkJoinPool executor)
Creates a new ParallelArray using an array of the given size, initially holding copies of the given source truncated or padded with nulls to obtain the specified length.
Parameters:
source - the source of initial elements
size - the array size
executor - the executor


createUsingHandoff

public static ParallelArray createUsingHandoff(java.lang.Object[] handoff, ForkJoinPool executor)
Creates a new ParallelArray initially using the given array and executor. In general, the handed off array should not be used for other purposes once constructing this ParallelArray. The given array may be internally replaced by another array in the course of methods that add or remove elements.
Parameters:
handoff - the array
executor - the executor


cumulate

public ParallelArray cumulate(Reducer reducer, java.lang.Object 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
Returns:
this (to simplify use in expressions)


defaultExecutor

public static ForkJoinPool defaultExecutor()
Returns a common default executor for use in ParallelArrays. This executor arranges enough parallelism to use most, but not necessarily all, of the available processors on this system.
Returns:
the executor


get

public java.lang.Object 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


getArray

public java.lang.Object[] getArray()
Returns the underlying array used for computations
Returns:
the array


getExecutor

public ForkJoinPool getExecutor()
Returns the executor used for computations.
Returns:
the executor


hasAllEqualElements

public boolean hasAllEqualElements(ParallelArrayWithMapping other)
Returns true if all elements at the same relative positions of this and other array are equal.
Parameters:
other - the other array
Returns:
true if equal


hasAllIdenticalElements

public boolean hasAllIdenticalElements(ParallelArrayWithMapping other)
Returns true if all elements at the same relative positions of this and other array are identical.
Parameters:
other - the other array
Returns:
true if equal


indexOf

public int indexOf(java.lang.Object target)
Returns the index of some element equal to given target, or -1 if not present
Parameters:
target - the element to search for
Returns:
the index or -1 if not present


insertElementAt

final void insertElementAt(int index, java.lang.Object e)


insertSlotsAt

final void insertSlotsAt(int index, int len)
Makes len slots available at index.


iterator

public java.util.Iterator iterator()
Returns an iterator stepping through each element of the array up to the current limit. This iterator does not support the remove operation. However, a full ListIterator supporting add, remove, and set operations is available via asList.
Returns:
an iterator stepping through each element.


max

public java.lang.Object max(java.util.Comparator comparator)
Returns the maximum element, or null if empty
Parameters:
comparator - the comparator
Returns:
maximum element, or null if empty


max

public java.lang.Object max()
Returns the maximum element, or null if empty assuming that all elements are Comparables
throws:
ClassCastException if any element is not Comparable.
Returns:
maximum element, or null if empty


min

public java.lang.Object min(java.util.Comparator comparator)
Returns the minimum element, or null if empty
Parameters:
comparator - the comparator
Returns:
minimum element, or null if empty


min

public java.lang.Object min()
Returns the minimum element, or null if empty, assuming that all elements are Comparables
throws:
ClassCastException if any element is not Comparable.
Returns:
minimum element, or null if empty


precumulate

public java.lang.Object precumulate(Reducer reducer, java.lang.Object 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


reduce

public java.lang.Object reduce(Reducer reducer, java.lang.Object base)
Returns reduction of elements
Parameters:
reducer - the reducer
base - the result for an empty array
Returns:
reduction


removeAll

public ParallelArray removeAll(Predicate selector)
Removes from the array all elements for which the given selector holds.
Parameters:
selector - the selector
Returns:
this (to simplify use in expressions)


removeConsecutiveDuplicates

public ParallelArray removeConsecutiveDuplicates()
Removes consecutive elements that are equal (or null), shifting others leftward, and possibly decreasing size. This method may be used after sorting to ensure that this ParallelArray contains a set of unique elements.
Returns:
this (to simplify use in expressions)


removeNulls

public ParallelArray removeNulls()
Removes null elements, shifting others leftward, and possibly decreasing size.
Returns:
this (to simplify use in expressions)


removeSlotAt

final void removeSlotAt(int index)


removeSlotsAt

final void removeSlotsAt(int fromIndex, int toIndex)


replaceElementsWith

final void replaceElementsWith(java.lang.Object[] a)


replaceWithGeneratedValue

public ParallelArray replaceWithGeneratedValue(Generator generator)
Replaces elements with the results of applying the given generator.
Parameters:
generator - the generator
Returns:
this (to simplify use in expressions)


replaceWithMappedIndex

public ParallelArray replaceWithMappedIndex(IntToObject op)
Replaces elements with the results of applying the given mapping to their indices.
Parameters:
op - the op
Returns:
this (to simplify use in expressions)


replaceWithMappedIndex

public ParallelArray replaceWithMappedIndex(IntAndObjectToObject op)
Replaces elements with the results of applying the given mapping to each index and current element value
Parameters:
op - the op
Returns:
this (to simplify use in expressions)


replaceWithMapping

public ParallelArray replaceWithMapping(Op op)
Replaces elements with the results of applying the given transform to their current values.
Parameters:
op - the op
Returns:
this (to simplify use in expressions)


replaceWithMapping

public ParallelArray replaceWithMapping(BinaryOp combiner, ParallelArrayWithMapping other)
Replaces elements with results of applying op(thisElement, otherElement)
Parameters:
other - the other array
combiner - the combiner
Returns:
this (to simplify use in expressions)


replaceWithMapping

public ParallelArray replaceWithMapping(BinaryOp combiner, java.lang.Object[] other)
Replaces elements with results of applying op(thisElement, otherElement)
Parameters:
other - the other array
combiner - the combiner
Returns:
this (to simplify use in expressions)


replaceWithValue

public ParallelArray replaceWithValue(java.lang.Object value)
Replaces elements with the given value.
Parameters:
value - the value
Returns:
this (to simplify use in expressions)


resizeArray

final void resizeArray(int newCap)


seqIndexOf

final int seqIndexOf(java.lang.Object target)


seqLastIndexOf

final int seqLastIndexOf(java.lang.Object target)


set

public void set(int i, java.lang.Object x)
Sets the element of the array at the given index to the given value
Parameters:
i - the index
x - the value


setLimit

public final void setLimit(int newLimit)
Ensures that the underlying array can be accessed up to the given upper bound, reallocating and copying the underlying array to expand if necessary. Or, if the given limit is less than the length of the underlying array, causes computations to ignore elements past the given limit.
throws:
IllegalArgumentException if newLimit less than zero.
Parameters:
newLimit - the new upper bound


size

public int size()
Returns the effective size of the underlying array. The effective size is the current limit, if used (see setLimit), or the length of the array otherwise.
Returns:
the effective size of array


sort

public ParallelArray sort(java.util.Comparator comparator)
Sorts the array. Unlike Arrays.sort, this sort does not guarantee that elements with equal keys maintain their relative position in the array.
Parameters:
comparator - the comparator to use
Returns:
this (to simplify use in expressions)


sort

public ParallelArray sort()
Sorts the array, assuming all elements are Comparable. Unlike Arrays.sort, this sort does not guarantee that elements with equal keys maintain their relative position in the array.
throws:
ClassCastException if any element is not Comparable.
Returns:
this (to simplify use in expressions)


summary

public SummaryStatistics summary(java.util.Comparator comparator)
Returns summary statistics, using the given comparator to locate minimum and maximum elements.
Parameters:
comparator - the comparator to use for locating minimum and maximum elements
Returns:
the summary.


summary

public SummaryStatistics summary()
Returns summary statistics, assuming that all elements are Comparables
Returns:
the summary.


toString

public java.lang.String toString()
Equivalent to asList().toString()
Returns:
a string representation


withBounds

public ParallelArrayWithBounds 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 ParallelArrayWithFilter withFilter(Predicate 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


withFilter

public ParallelArrayWithFilter withFilter(BinaryPredicate selector, ParallelArrayWithMapping other)
Returns an operation prefix that causes a method to operate only on elements for which the given binary selector returns true
Parameters:
selector - the selector
Returns:
operation prefix


withIndexedFilter

public ParallelArrayWithFilter withIndexedFilter(IntAndObjectPredicate selector)
Returns an operation prefix that causes a method to operate only on elements for which the given indexed selector returns true
Parameters:
selector - the selector
Returns:
operation prefix


withIndexedMapping

public ParallelArrayWithMapping withIndexedMapping(IntAndObjectToObject mapper)
Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value. Index-based mappings allow parallel computation of many common array operations. For example, you could create function to average the values at the same index of multiple arrays and apply it using this method.
Parameters:
mapper - the mapper
Returns:
operation prefix


withIndexedMapping

public ParallelArrayWithDoubleMapping withIndexedMapping(IntAndObjectToDouble mapper)
Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value.
Parameters:
mapper - the mapper
Returns:
operation prefix


withIndexedMapping

public ParallelArrayWithLongMapping withIndexedMapping(IntAndObjectToLong mapper)
Returns an operation prefix that causes a method to operate on mappings of this array using the given mapper that accepts as arguments an element's current index and value, and produces a new value.
Parameters:
mapper - the mapper
Returns:
operation prefix


withMapping

public ParallelArrayWithMapping withMapping(Op op)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.
Parameters:
op - the op
Returns:
operation prefix


withMapping

public ParallelArrayWithDoubleMapping withMapping(ObjectToDouble op)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.
Parameters:
op - the op
Returns:
operation prefix


withMapping

public ParallelArrayWithLongMapping withMapping(ObjectToLong op)
Returns an operation prefix that causes a method to operate on mapped elements of the array using the given op.
Parameters:
op - the op
Returns:
operation prefix


withMapping

public ParallelArrayWithMapping withMapping(BinaryOp combiner, ParallelArrayWithMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithMapping withMapping(ObjectAndDoubleToObject combiner, ParallelDoubleArrayWithDoubleMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithMapping withMapping(ObjectAndLongToObject combiner, ParallelLongArrayWithLongMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithDoubleMapping withMapping(ObjectAndObjectToDouble combiner, ParallelArrayWithMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithDoubleMapping withMapping(ObjectAndDoubleToDouble combiner, ParallelDoubleArrayWithDoubleMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithDoubleMapping withMapping(ObjectAndLongToDouble combiner, ParallelLongArrayWithLongMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithLongMapping withMapping(ObjectAndObjectToLong combiner, ParallelArrayWithMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithLongMapping withMapping(ObjectAndDoubleToLong combiner, ParallelDoubleArrayWithDoubleMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


withMapping

public ParallelArrayWithLongMapping withMapping(ObjectAndLongToLong combiner, ParallelLongArrayWithLongMapping other)
Returns an operation prefix that causes a method to operate on binary mappings of this array and the other array.
throws:
IllegalArgumentException if other array is a filtered view (all filters must precede all mappings).
Parameters:
combiner - the combiner
other - the other array
Returns:
operation prefix


 

Copyright © 2008–2012 Václav Pech. All Rights Reserved.