src/extra166y/ParallelArrayWithLongMapping.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.*;

/**
 * A prefix view of ParallelArray 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 ParallelArray or its other prefix classes.
 */
public abstract class ParallelArrayWithLongMapping<T> extends AbstractParallelAnyArray.OPap<T> {
    ParallelArrayWithLongMapping
        (ForkJoinPool ex, int origin, int fence, T[] 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(), 0L);
    }

    /**
     * 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 ParallelArrayWithDoubleMapping<T> 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 ParallelArrayWithLongMapping<T> 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> ParallelArrayWithMapping<T,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> ParallelArrayWithMapping<T,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> ParallelArrayWithMapping<T,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> ParallelArrayWithMapping<T,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> ParallelArrayWithDoubleMapping<T> 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 ParallelArrayWithDoubleMapping<T> 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 ParallelArrayWithDoubleMapping<T> 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> ParallelArrayWithLongMapping<T> 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 ParallelArrayWithLongMapping<T> 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 ParallelArrayWithLongMapping<T> 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> ParallelArrayWithMapping<T,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 ParallelArrayWithDoubleMapping<T> 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 ParallelArrayWithLongMapping<T> 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.7
Committed:	Thu Feb 26 06:53:34 2015 UTC (9 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.6:	+0 -1 lines
Log Message:	delete unused imports
#	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	jsr166	1.6
9	dl	1.1	import jsr166y.*;
10			import static extra166y.Ops.*;
11			import java.util.*;
12			import java.util.concurrent.atomic.*;
13
14			/**
15			* A prefix view of ParallelArray 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 ParallelArray or its other prefix classes.
19			*/
20			public abstract class ParallelArrayWithLongMapping<T> extends AbstractParallelAnyArray.OPap<T> {
21			ParallelArrayWithLongMapping
22			(ForkJoinPool ex, int origin, int fence, T[] 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(), 0L);
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 ParallelArrayWithDoubleMapping<T> withMapping(LongToDouble op);
126
127			/**
128			* Returns an operation prefix that causes a method to operate
129			* on mapped elements of the array using the given op.
130			* @param op the op
131			* @return operation prefix
132			*/
133			public abstract ParallelArrayWithLongMapping<T> withMapping(LongOp op);
134
135			/**
136			* Returns an operation prefix that causes a method to operate
137			* on mapped elements of the array using the given op.
138			* @param op the op
139			* @return operation prefix
140			*/
141	jsr166	1.5	public abstract <U> ParallelArrayWithMapping<T,U> withMapping
142	dl	1.1	(LongToObject<? extends U> op);
143
144			/**
145			* Returns an operation prefix that causes a method to operate
146			* on binary mappings of this array and the other array.
147			* @param combiner the combiner
148			* @param other the other array
149			* @return operation prefix
150			* @throws IllegalArgumentException if other array is a
151	jsr166	1.4	* filtered view (all filters must precede all mappings)
152	dl	1.1	*/
153			public <V,W,X> ParallelArrayWithMapping<T,W> withMapping
154			(LongAndObjectToObject<? super V, ? extends W> combiner,
155			ParallelArrayWithMapping<X,V> other) {
156			if (other.hasFilter()) throw new IllegalArgumentException();
157			return withIndexedMapping
158			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
159			}
160
161			/**
162			* Returns an operation prefix that causes a method to operate
163			* on binary mappings of this array and the other array.
164			* @param combiner the combiner
165			* @param other the other array
166			* @return operation prefix
167			* @throws IllegalArgumentException if other array is a
168	jsr166	1.4	* filtered view (all filters must precede all mappings)
169	dl	1.1	*/
170			public <V> ParallelArrayWithMapping<T,V> withMapping
171			(LongAndDoubleToObject<? extends V> combiner,
172			ParallelDoubleArrayWithDoubleMapping other) {
173			if (other.hasFilter()) throw new IllegalArgumentException();
174			return withIndexedMapping
175			(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> ParallelArrayWithMapping<T,V> withMapping
188			(LongAndLongToObject<? extends V> combiner,
189			ParallelLongArrayWithLongMapping other) {
190			if (other.hasFilter()) throw new IllegalArgumentException();
191			return withIndexedMapping
192			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
193			}
194
195			/**
196			* Returns an operation prefix that causes a method to operate
197			* on binary mappings of this array and the other array.
198			* @param combiner the combiner
199			* @param other the other array
200			* @return operation prefix
201			* @throws IllegalArgumentException if other array is a
202	jsr166	1.4	* filtered view (all filters must precede all mappings)
203	dl	1.1	*/
204			public <V,W> ParallelArrayWithDoubleMapping<T> withMapping
205			(LongAndObjectToDouble<? super V> combiner,
206			ParallelArrayWithMapping<W,V> other) {
207			if (other.hasFilter()) throw new IllegalArgumentException();
208			return withIndexedMapping
209			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
210			}
211
212			/**
213			* Returns an operation prefix that causes a method to operate
214			* on binary mappings of this array and the other array.
215			* @param combiner the combiner
216			* @param other the other array
217			* @return operation prefix
218			* @throws IllegalArgumentException if other array is a
219	jsr166	1.4	* filtered view (all filters must precede all mappings)
220	dl	1.1	*/
221			public ParallelArrayWithDoubleMapping<T> withMapping
222			(LongAndDoubleToDouble combiner,
223			ParallelDoubleArrayWithDoubleMapping other) {
224			if (other.hasFilter()) throw new IllegalArgumentException();
225			return withIndexedMapping
226			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
227			}
228
229
230			/**
231			* Returns an operation prefix that causes a method to operate
232			* on binary mappings of this array and the other array.
233			* @param combiner the combiner
234			* @param other the other array
235			* @return operation prefix
236			* @throws IllegalArgumentException if other array is a
237	jsr166	1.4	* filtered view (all filters must precede all mappings)
238	dl	1.1	*/
239			public ParallelArrayWithDoubleMapping<T> withMapping
240			(LongAndLongToDouble combiner,
241			ParallelLongArrayWithLongMapping other) {
242			if (other.hasFilter()) throw new IllegalArgumentException();
243			return withIndexedMapping
244			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
245			}
246
247			/**
248			* Returns an operation prefix that causes a method to operate
249			* on binary mappings of this array and the other array.
250			* @param combiner the combiner
251			* @param other the other array
252			* @return operation prefix
253			* @throws IllegalArgumentException if other array is a
254	jsr166	1.4	* filtered view (all filters must precede all mappings)
255	dl	1.1	*/
256			public <V,W> ParallelArrayWithLongMapping<T> withMapping
257			(LongAndObjectToLong<? super V> combiner,
258			ParallelArrayWithMapping<W,V> other) {
259			if (other.hasFilter()) throw new IllegalArgumentException();
260			return withIndexedMapping
261			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
262			}
263
264
265			/**
266			* Returns an operation prefix that causes a method to operate
267			* on binary mappings of this array and the other array.
268			* @param combiner the combiner
269			* @param other the other array
270			* @return operation prefix
271			* @throws IllegalArgumentException if other array is a
272	jsr166	1.4	* filtered view (all filters must precede all mappings)
273	dl	1.1	*/
274			public ParallelArrayWithLongMapping<T> withMapping
275			(LongAndDoubleToLong combiner,
276			ParallelDoubleArrayWithDoubleMapping other) {
277			if (other.hasFilter()) throw new IllegalArgumentException();
278			return withIndexedMapping
279			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
280			}
281
282
283			/**
284			* Returns an operation prefix that causes a method to operate
285			* on binary mappings of this array and the other array.
286			* @param combiner the combiner
287			* @param other the other array
288			* @return operation prefix
289			* @throws IllegalArgumentException if other array is a
290	jsr166	1.4	* filtered view (all filters must precede all mappings)
291	dl	1.1	*/
292			public ParallelArrayWithLongMapping<T> withMapping
293			(BinaryLongOp combiner,
294			ParallelLongArrayWithLongMapping other) {
295			if (other.hasFilter()) throw new IllegalArgumentException();
296			return withIndexedMapping
297			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
298			}
299
300			/**
301			* Returns an operation prefix that causes a method to operate
302			* on mappings of this array using the given mapper that
303			* accepts as arguments an element's current index and value
304			* (as mapped by preceding mappings, if any), and produces a
305			* new value.
306			* @param mapper the mapper
307			* @return operation prefix
308			*/
309			public abstract <V> ParallelArrayWithMapping<T,V> withIndexedMapping
310			(IntAndLongToObject<? extends V> mapper);
311
312			/**
313			* Returns an operation prefix that causes a method to operate
314			* on mappings of this array using the given mapper that
315			* accepts as arguments an element's current index and value
316			* (as mapped by preceding mappings, if any), and produces a
317			* new value.
318			* @param mapper the mapper
319			* @return operation prefix
320			*/
321			public abstract ParallelArrayWithDoubleMapping<T> withIndexedMapping
322			(IntAndLongToDouble mapper);
323
324			/**
325			* Returns an operation prefix that causes a method to operate
326			* on mappings of this array using the given mapper that
327			* accepts as arguments an element's current index and value
328			* (as mapped by preceding mappings, if any), and produces a
329			* new value.
330			* @param mapper the mapper
331			* @return operation prefix
332			*/
333			public abstract ParallelArrayWithLongMapping<T> withIndexedMapping
334			(IntAndLongToLong mapper);
335
336			/**
337			* Returns an Iterable view to sequentially step through mapped
338			* elements also obeying bound and filter constraints, without
339	jsr166	1.4	* performing computations to evaluate them in parallel.
340	dl	1.1	* @return the Iterable view
341			*/
342			public Iterable<Long> sequentially() {
343			return new SequentiallyAsLong();
344			}
345			}