src/extra166y/ParallelDoubleArrayWithLongMapping.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package extra166y;
import jsr166y.*;
import static extra166y.Ops.*;
import java.util.*;
import java.util.concurrent.atomic.*;
import java.lang.reflect.Array;

/**
 * A prefix view of ParallelDoubleArray that causes operations to apply
 * to mappings of elements, not to the elements themselves.
 * Instances of this class may be constructed only via prefix
 * methods of ParallelDoubleArray or its other prefix classes.
 */
public abstract class ParallelDoubleArrayWithLongMapping extends AbstractParallelAnyArray.DPap {
    ParallelDoubleArrayWithLongMapping
        (ForkJoinPool ex, int origin, int fence, double[] array) {
        super(ex, origin, fence, array);
    }

    /**
     * Applies the given procedure.
     * @param procedure the procedure
     */
    public void apply(LongProcedure procedure) {
        ex.invoke(new PAS.FJLApply(this, origin, fence, null, procedure));
    }

    /**
     * Returns reduction of mapped elements.
     * @param reducer the reducer
     * @param base the result for an empty array
     * @return reduction
     */
    public long reduce(LongReducer reducer, long base) {
        PAS.FJLReduce f = new PAS.FJLReduce
            (this, origin, fence, null, reducer, base);
        ex.invoke(f);
        return f.result;
    }

    /**
     * Returns the minimum element, or Long.MAX_VALUE if empty.
     * @return minimum element, or Long.MAX_VALUE if empty
     */
    public long min() {
        return reduce(CommonOps.naturalLongMinReducer(), Long.MAX_VALUE);
    }

    /**
     * Returns the minimum element, or Long.MAX_VALUE if empty.
     * @param comparator the comparator
     * @return minimum element, or Long.MAX_VALUE if empty
     */
    public long min(LongComparator comparator) {
        return reduce(CommonOps.longMinReducer(comparator), Long.MAX_VALUE);
    }

    /**
     * Returns the maximum element, or Long.MIN_VALUE if empty.
     * @return maximum element, or Long.MIN_VALUE if empty
     */
    public long max() {
        return reduce(CommonOps.naturalLongMaxReducer(), Long.MIN_VALUE);
    }

    /**
     * Returns the maximum element, or Long.MIN_VALUE if empty.
     * @param comparator the comparator
     * @return maximum element, or Long.MIN_VALUE if empty
     */
    public long max(LongComparator comparator) {
        return reduce(CommonOps.longMaxReducer(comparator), Long.MIN_VALUE);
    }

    /**
     * Returns the sum of elements.
     * @return the sum of elements
     */
    public long sum() {
        return reduce(CommonOps.longAdder(), 0);
    }

    /**
     * Returns summary statistics.
     * @param comparator the comparator to use for
     * locating minimum and maximum elements
     * @return the summary
     */
    public ParallelLongArray.SummaryStatistics summary
        (LongComparator comparator) {
        PAS.FJLStats f = new PAS.FJLStats
            (this, origin, fence, null, comparator);
        ex.invoke(f);
        return f;
    }

    /**
     * Returns summary statistics, using natural comparator.
     * @return the summary
     */
    public ParallelLongArray.SummaryStatistics summary() {
        return summary(CommonOps.naturalLongComparator());
    }

    /**
     * Returns a new ParallelLongArray holding mappings.
     * @return a new ParallelLongArray holding mappings
     */
    public ParallelLongArray all() {
        return new ParallelLongArray(ex, allLongs());
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on mapped elements of the array using the given op.
     * @param op the op
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithDoubleMapping withMapping
        (LongToDouble op);

    /**
     * Returns an operation prefix that causes a method to operate
     * on mapped elements of the array using the given op.
     * @param op the op
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithLongMapping withMapping
        (LongOp op);

    /**
     * Returns an operation prefix that causes a method to operate
     * on mapped elements of the array using the given op.
     * @param op the op
     * @return operation prefix
     */
    public abstract <U> ParallelDoubleArrayWithMapping<U> withMapping
        (LongToObject<? extends U> op);

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public <V,W,X> ParallelDoubleArrayWithMapping<W> withMapping
        (LongAndObjectToObject<? super V, ? extends W> combiner,
         ParallelArrayWithMapping<X,V> other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public <V> ParallelDoubleArrayWithMapping<V> withMapping
        (LongAndDoubleToObject<? extends V> combiner,
         ParallelDoubleArrayWithDoubleMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public <V> ParallelDoubleArrayWithMapping<V> withMapping
        (LongAndLongToObject<? extends V> combiner,
         ParallelLongArrayWithLongMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public <V,W> ParallelDoubleArrayWithDoubleMapping withMapping
        (LongAndObjectToDouble<? super V> combiner,
         ParallelArrayWithMapping<W,V> other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public ParallelDoubleArrayWithDoubleMapping withMapping
        (LongAndDoubleToDouble combiner,
         ParallelDoubleArrayWithDoubleMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public ParallelDoubleArrayWithDoubleMapping withMapping
        (LongAndLongToDouble combiner,
         ParallelLongArrayWithLongMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public <V,W> ParallelDoubleArrayWithLongMapping withMapping
        (LongAndObjectToLong<? super V> combiner,
         ParallelArrayWithMapping<W,V> other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public ParallelDoubleArrayWithLongMapping withMapping
        (LongAndDoubleToLong combiner,
         ParallelDoubleArrayWithDoubleMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * on binary mappings of this array and the other array.
     * @param combiner the combiner
     * @param other the other array
     * @return operation prefix
     * @throws IllegalArgumentException if other array is a
     * filtered view (all filters must precede all mappings)
     */
    public ParallelDoubleArrayWithLongMapping withMapping
        (BinaryLongOp combiner,
         ParallelLongArrayWithLongMapping other) {
        if (other.hasFilter()) throw new IllegalArgumentException();
        return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
    }

    /**
     * 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
     * (as mapped by preceding mappings, if any), and produces a
     * new value.
     * @param mapper the mapper
     * @return operation prefix
     */
    public abstract <V> ParallelDoubleArrayWithMapping<V> withIndexedMapping
        (IntAndLongToObject<? extends V> 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
     * (as mapped by preceding mappings, if any), and produces a
     * new value.
     * @param mapper the mapper
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithDoubleMapping withIndexedMapping
        (IntAndLongToDouble 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
     * (as mapped by preceding mappings, if any), and produces a
     * new value.
     * @param mapper the mapper
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithLongMapping withIndexedMapping
        (IntAndLongToLong mapper);

    /**
     * Returns an Iterable view to sequentially step through mapped
     * elements also obeying bound and filter constraints, without
     * performing computations to evaluate them in parallel.
     * @return the Iterable view
     */
    public Iterable<Long> sequentially() {
        return new SequentiallyAsLong();
    }
}
Revision:	1.4
Committed:	Sat Dec 29 23:55:19 2012 UTC (11 years, 4 months ago) by jsr166
Branch:	MAIN
Changes since 1.3:	+22 -22 lines
Log Message:	punctuation
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.2	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6
7			package extra166y;
8			import jsr166y.*;
9			import static extra166y.Ops.*;
10			import java.util.*;
11			import java.util.concurrent.atomic.*;
12			import java.lang.reflect.Array;
13
14			/**
15			* A prefix view of ParallelDoubleArray that causes operations to apply
16			* to mappings of elements, not to the elements themselves.
17			* Instances of this class may be constructed only via prefix
18			* methods of ParallelDoubleArray or its other prefix classes.
19			*/
20			public abstract class ParallelDoubleArrayWithLongMapping extends AbstractParallelAnyArray.DPap {
21			ParallelDoubleArrayWithLongMapping
22			(ForkJoinPool ex, int origin, int fence, double[] array) {
23			super(ex, origin, fence, array);
24			}
25
26			/**
27	jsr166	1.4	* Applies the given procedure.
28	dl	1.1	* @param procedure the procedure
29			*/
30			public void apply(LongProcedure procedure) {
31			ex.invoke(new PAS.FJLApply(this, origin, fence, null, procedure));
32			}
33
34			/**
35	jsr166	1.4	* Returns reduction of mapped elements.
36	dl	1.1	* @param reducer the reducer
37			* @param base the result for an empty array
38			* @return reduction
39			*/
40			public long reduce(LongReducer reducer, long base) {
41			PAS.FJLReduce f = new PAS.FJLReduce
42			(this, origin, fence, null, reducer, base);
43			ex.invoke(f);
44			return f.result;
45			}
46
47			/**
48	jsr166	1.4	* Returns the minimum element, or Long.MAX_VALUE if empty.
49	dl	1.1	* @return minimum element, or Long.MAX_VALUE if empty
50			*/
51			public long min() {
52			return reduce(CommonOps.naturalLongMinReducer(), Long.MAX_VALUE);
53			}
54
55			/**
56	jsr166	1.4	* Returns the minimum element, or Long.MAX_VALUE if empty.
57	dl	1.1	* @param comparator the comparator
58			* @return minimum element, or Long.MAX_VALUE if empty
59			*/
60			public long min(LongComparator comparator) {
61			return reduce(CommonOps.longMinReducer(comparator), Long.MAX_VALUE);
62			}
63
64			/**
65	jsr166	1.4	* Returns the maximum element, or Long.MIN_VALUE if empty.
66	dl	1.1	* @return maximum element, or Long.MIN_VALUE if empty
67			*/
68			public long max() {
69			return reduce(CommonOps.naturalLongMaxReducer(), Long.MIN_VALUE);
70			}
71
72			/**
73	jsr166	1.4	* Returns the maximum element, or Long.MIN_VALUE if empty.
74	dl	1.1	* @param comparator the comparator
75			* @return maximum element, or Long.MIN_VALUE if empty
76			*/
77			public long max(LongComparator comparator) {
78			return reduce(CommonOps.longMaxReducer(comparator), Long.MIN_VALUE);
79			}
80
81			/**
82	jsr166	1.4	* Returns the sum of elements.
83	dl	1.1	* @return the sum of elements
84			*/
85			public long sum() {
86			return reduce(CommonOps.longAdder(), 0);
87			}
88
89			/**
90	jsr166	1.4	* Returns summary statistics.
91	dl	1.1	* @param comparator the comparator to use for
92			* locating minimum and maximum elements
93	jsr166	1.4	* @return the summary
94	dl	1.1	*/
95			public ParallelLongArray.SummaryStatistics summary
96			(LongComparator comparator) {
97			PAS.FJLStats f = new PAS.FJLStats
98			(this, origin, fence, null, comparator);
99			ex.invoke(f);
100			return f;
101			}
102
103			/**
104	jsr166	1.4	* Returns summary statistics, using natural comparator.
105			* @return the summary
106	dl	1.1	*/
107			public ParallelLongArray.SummaryStatistics summary() {
108			return summary(CommonOps.naturalLongComparator());
109			}
110
111			/**
112	jsr166	1.4	* Returns a new ParallelLongArray holding mappings.
113	dl	1.1	* @return a new ParallelLongArray holding mappings
114			*/
115			public ParallelLongArray all() {
116			return new ParallelLongArray(ex, allLongs());
117			}
118
119			/**
120			* Returns an operation prefix that causes a method to operate
121			* on mapped elements of the array using the given op.
122			* @param op the op
123			* @return operation prefix
124			*/
125			public abstract ParallelDoubleArrayWithDoubleMapping withMapping
126			(LongToDouble op);
127
128			/**
129			* Returns an operation prefix that causes a method to operate
130			* on mapped elements of the array using the given op.
131			* @param op the op
132			* @return operation prefix
133			*/
134			public abstract ParallelDoubleArrayWithLongMapping withMapping
135			(LongOp op);
136
137			/**
138			* Returns an operation prefix that causes a method to operate
139			* on mapped elements of the array using the given op.
140			* @param op the op
141			* @return operation prefix
142			*/
143			public abstract <U> ParallelDoubleArrayWithMapping<U> withMapping
144			(LongToObject<? extends U> op);
145
146			/**
147			* Returns an operation prefix that causes a method to operate
148			* on binary mappings of this array and the other array.
149			* @param combiner the combiner
150			* @param other the other array
151			* @return operation prefix
152			* @throws IllegalArgumentException if other array is a
153	jsr166	1.4	* filtered view (all filters must precede all mappings)
154	dl	1.1	*/
155			public <V,W,X> ParallelDoubleArrayWithMapping<W> withMapping
156			(LongAndObjectToObject<? super V, ? extends W> combiner,
157			ParallelArrayWithMapping<X,V> other) {
158			if (other.hasFilter()) throw new IllegalArgumentException();
159			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
160			}
161
162			/**
163			* Returns an operation prefix that causes a method to operate
164			* on binary mappings of this array and the other array.
165			* @param combiner the combiner
166			* @param other the other array
167			* @return operation prefix
168			* @throws IllegalArgumentException if other array is a
169	jsr166	1.4	* filtered view (all filters must precede all mappings)
170	dl	1.1	*/
171			public <V> ParallelDoubleArrayWithMapping<V> withMapping
172			(LongAndDoubleToObject<? extends V> combiner,
173			ParallelDoubleArrayWithDoubleMapping other) {
174			if (other.hasFilter()) throw new IllegalArgumentException();
175			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
176			}
177
178			/**
179			* Returns an operation prefix that causes a method to operate
180			* on binary mappings of this array and the other array.
181			* @param combiner the combiner
182			* @param other the other array
183			* @return operation prefix
184			* @throws IllegalArgumentException if other array is a
185	jsr166	1.4	* filtered view (all filters must precede all mappings)
186	dl	1.1	*/
187			public <V> ParallelDoubleArrayWithMapping<V> withMapping
188			(LongAndLongToObject<? extends V> combiner,
189			ParallelLongArrayWithLongMapping other) {
190			if (other.hasFilter()) throw new IllegalArgumentException();
191			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
192			}
193
194			/**
195			* Returns an operation prefix that causes a method to operate
196			* on binary mappings of this array and the other array.
197			* @param combiner the combiner
198			* @param other the other array
199			* @return operation prefix
200			* @throws IllegalArgumentException if other array is a
201	jsr166	1.4	* filtered view (all filters must precede all mappings)
202	dl	1.1	*/
203			public <V,W> ParallelDoubleArrayWithDoubleMapping withMapping
204			(LongAndObjectToDouble<? super V> combiner,
205			ParallelArrayWithMapping<W,V> other) {
206			if (other.hasFilter()) throw new IllegalArgumentException();
207			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
208			}
209
210			/**
211			* Returns an operation prefix that causes a method to operate
212			* on binary mappings of this array and the other array.
213			* @param combiner the combiner
214			* @param other the other array
215			* @return operation prefix
216			* @throws IllegalArgumentException if other array is a
217	jsr166	1.4	* filtered view (all filters must precede all mappings)
218	dl	1.1	*/
219			public ParallelDoubleArrayWithDoubleMapping withMapping
220			(LongAndDoubleToDouble combiner,
221			ParallelDoubleArrayWithDoubleMapping other) {
222			if (other.hasFilter()) throw new IllegalArgumentException();
223			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
224			}
225
226			/**
227			* Returns an operation prefix that causes a method to operate
228			* on binary mappings of this array and the other array.
229			* @param combiner the combiner
230			* @param other the other array
231			* @return operation prefix
232			* @throws IllegalArgumentException if other array is a
233	jsr166	1.4	* filtered view (all filters must precede all mappings)
234	dl	1.1	*/
235			public ParallelDoubleArrayWithDoubleMapping withMapping
236			(LongAndLongToDouble combiner,
237			ParallelLongArrayWithLongMapping other) {
238			if (other.hasFilter()) throw new IllegalArgumentException();
239			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
240			}
241
242			/**
243			* Returns an operation prefix that causes a method to operate
244			* on binary mappings of this array and the other array.
245			* @param combiner the combiner
246			* @param other the other array
247			* @return operation prefix
248			* @throws IllegalArgumentException if other array is a
249	jsr166	1.4	* filtered view (all filters must precede all mappings)
250	dl	1.1	*/
251			public <V,W> ParallelDoubleArrayWithLongMapping withMapping
252			(LongAndObjectToLong<? super V> combiner,
253			ParallelArrayWithMapping<W,V> other) {
254			if (other.hasFilter()) throw new IllegalArgumentException();
255			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
256			}
257
258			/**
259			* Returns an operation prefix that causes a method to operate
260			* on binary mappings of this array and the other array.
261			* @param combiner the combiner
262			* @param other the other array
263			* @return operation prefix
264			* @throws IllegalArgumentException if other array is a
265	jsr166	1.4	* filtered view (all filters must precede all mappings)
266	dl	1.1	*/
267			public ParallelDoubleArrayWithLongMapping withMapping
268			(LongAndDoubleToLong combiner,
269			ParallelDoubleArrayWithDoubleMapping other) {
270			if (other.hasFilter()) throw new IllegalArgumentException();
271			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
272			}
273
274			/**
275			* Returns an operation prefix that causes a method to operate
276			* on binary mappings of this array and the other array.
277			* @param combiner the combiner
278			* @param other the other array
279			* @return operation prefix
280			* @throws IllegalArgumentException if other array is a
281	jsr166	1.4	* filtered view (all filters must precede all mappings)
282	dl	1.1	*/
283			public ParallelDoubleArrayWithLongMapping withMapping
284			(BinaryLongOp combiner,
285			ParallelLongArrayWithLongMapping other) {
286			if (other.hasFilter()) throw new IllegalArgumentException();
287			return withIndexedMapping(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
288			}
289
290			/**
291			* Returns an operation prefix that causes a method to operate
292			* on mappings of this array using the given mapper that
293			* accepts as arguments an element's current index and value
294			* (as mapped by preceding mappings, if any), and produces a
295			* new value.
296			* @param mapper the mapper
297			* @return operation prefix
298			*/
299			public abstract <V> ParallelDoubleArrayWithMapping<V> withIndexedMapping
300			(IntAndLongToObject<? extends V> mapper);
301
302			/**
303			* Returns an operation prefix that causes a method to operate
304			* on mappings of this array using the given mapper that
305			* accepts as arguments an element's current index and value
306			* (as mapped by preceding mappings, if any), and produces a
307			* new value.
308			* @param mapper the mapper
309			* @return operation prefix
310			*/
311			public abstract ParallelDoubleArrayWithDoubleMapping withIndexedMapping
312			(IntAndLongToDouble mapper);
313
314			/**
315			* Returns an operation prefix that causes a method to operate
316			* on mappings of this array using the given mapper that
317			* accepts as arguments an element's current index and value
318			* (as mapped by preceding mappings, if any), and produces a
319			* new value.
320			* @param mapper the mapper
321			* @return operation prefix
322			*/
323			public abstract ParallelDoubleArrayWithLongMapping withIndexedMapping
324			(IntAndLongToLong mapper);
325
326			/**
327			* Returns an Iterable view to sequentially step through mapped
328			* elements also obeying bound and filter constraints, without
329	jsr166	1.4	* performing computations to evaluate them in parallel.
330	dl	1.1	* @return the Iterable view
331			*/
332			public Iterable<Long> sequentially() {
333			return new SequentiallyAsLong();
334			}
335			}