src/extra166y/ParallelDoubleArrayWithDoubleMapping.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 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 ParallelDoubleArray or its other prefix classes.
 */
public abstract class ParallelDoubleArrayWithDoubleMapping extends AbstractParallelAnyArray.DPap {
    ParallelDoubleArrayWithDoubleMapping
        (ForkJoinPool ex, int origin, int fence, double[] array) {
        super(ex, origin, fence, array);
    }

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

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

    /**
     * Returns the minimum element, or Double.MAX_VALUE if empty.
     * @return minimum element, or Double.MAX_VALUE if empty
     */
    public double min() {
        return reduce(CommonOps.naturalDoubleMinReducer(), Double.MAX_VALUE);
    }

    /**
     * Returns the minimum element, or Double.MAX_VALUE if empty.
     * @param comparator the comparator
     * @return minimum element, or Double.MAX_VALUE if empty
     */
    public double min(DoubleComparator comparator) {
        return reduce(CommonOps.doubleMinReducer(comparator), Double.MAX_VALUE);
    }

    /**
     * Returns the maximum element, or -Double.MAX_VALUE if empty.
     * @return maximum element, or -Double.MAX_VALUE if empty
     */
    public double max() {
        return reduce(CommonOps.naturalDoubleMaxReducer(), -Double.MAX_VALUE);
    }

    /**
     * Returns the maximum element, or -Double.MAX_VALUE if empty.
     * @param comparator the comparator
     * @return maximum element, or -Double.MAX_VALUE if empty
     */
    public double max(DoubleComparator comparator) {
        return reduce(CommonOps.doubleMaxReducer(comparator), -Double.MAX_VALUE);
    }

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

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

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

    /**
     * Returns a new ParallelDoubleArray holding elements.
     * @return a new ParallelDoubleArray holding elements
     */
    public ParallelDoubleArray all() {
        return new ParallelDoubleArray(ex, allDoubles());
    }

    /**
     * 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
        (DoubleOp 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
        (DoubleToLong 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
        (DoubleToObject<? 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
        (DoubleAndObjectToObject<? 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
        (DoubleAndDoubleToObject<? 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
        (DoubleAndLongToObject<? 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
        (DoubleAndObjectToDouble<? 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
        (BinaryDoubleOp 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
        (DoubleAndLongToDouble 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
        (DoubleAndObjectToLong<? 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
        (DoubleAndDoubleToLong 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
        (DoubleAndLongToLong 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
        (IntAndDoubleToObject<? 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
        (IntAndDoubleToDouble 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
        (IntAndDoubleToLong 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<Double> sequentially() {
        return new SequentiallyAsDouble();
    }
}
Revision:	1.5
Committed:	Sun Jan 18 20:17:32 2015 UTC (9 years, 3 months ago) by jsr166
Branch:	MAIN
Changes since 1.4:	+1 -0 lines
Log Message:	exactly one blank line before and after package statements
#	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.5
9	dl	1.1	import jsr166y.*;
10			import static extra166y.Ops.*;
11			import java.util.*;
12			import java.util.concurrent.atomic.*;
13			import java.lang.reflect.Array;
14
15			/**
16			* A prefix view of ParallelArray that causes operations to apply
17			* to mappings of elements, not to the elements themselves.
18			* Instances of this class may be constructed only via prefix
19			* methods of ParallelDoubleArray or its other prefix classes.
20			*/
21			public abstract class ParallelDoubleArrayWithDoubleMapping extends AbstractParallelAnyArray.DPap {
22			ParallelDoubleArrayWithDoubleMapping
23			(ForkJoinPool ex, int origin, int fence, double[] array) {
24			super(ex, origin, fence, array);
25			}
26
27			/**
28	jsr166	1.4	* Applies the given procedure to elements.
29	dl	1.1	* @param procedure the procedure
30			*/
31			public void apply(DoubleProcedure procedure) {
32			ex.invoke(new PAS.FJDApply(this, origin, fence, null, procedure));
33			}
34
35			/**
36	jsr166	1.4	* Returns reduction of elements.
37	dl	1.1	* @param reducer the reducer
38			* @param base the result for an empty array
39			* @return reduction
40			*/
41			public double reduce(DoubleReducer reducer, double base) {
42			PAS.FJDReduce f = new PAS.FJDReduce
43			(this, origin, fence, null, reducer, base);
44			ex.invoke(f);
45			return f.result;
46			}
47
48			/**
49	jsr166	1.4	* Returns the minimum element, or Double.MAX_VALUE if empty.
50	dl	1.1	* @return minimum element, or Double.MAX_VALUE if empty
51			*/
52			public double min() {
53			return reduce(CommonOps.naturalDoubleMinReducer(), Double.MAX_VALUE);
54			}
55
56			/**
57	jsr166	1.4	* Returns the minimum element, or Double.MAX_VALUE if empty.
58	dl	1.1	* @param comparator the comparator
59			* @return minimum element, or Double.MAX_VALUE if empty
60			*/
61			public double min(DoubleComparator comparator) {
62			return reduce(CommonOps.doubleMinReducer(comparator), Double.MAX_VALUE);
63			}
64
65			/**
66	jsr166	1.4	* Returns the maximum element, or -Double.MAX_VALUE if empty.
67	dl	1.1	* @return maximum element, or -Double.MAX_VALUE if empty
68			*/
69			public double max() {
70			return reduce(CommonOps.naturalDoubleMaxReducer(), -Double.MAX_VALUE);
71			}
72
73			/**
74	jsr166	1.4	* Returns the maximum element, or -Double.MAX_VALUE if empty.
75	dl	1.1	* @param comparator the comparator
76			* @return maximum element, or -Double.MAX_VALUE if empty
77			*/
78			public double max(DoubleComparator comparator) {
79			return reduce(CommonOps.doubleMaxReducer(comparator), -Double.MAX_VALUE);
80			}
81
82			/**
83	jsr166	1.4	* Returns the sum of elements.
84	dl	1.1	* @return the sum of elements
85			*/
86			public double sum() {
87			return reduce(CommonOps.doubleAdder(), 0);
88			}
89
90			/**
91	jsr166	1.4	* Returns summary statistics.
92	dl	1.1	* @param comparator the comparator to use for
93			* locating minimum and maximum elements
94	jsr166	1.4	* @return the summary
95	dl	1.1	*/
96			public ParallelDoubleArray.SummaryStatistics summary
97			(DoubleComparator comparator) {
98			PAS.FJDStats f = new PAS.FJDStats
99			(this, origin, fence, null, comparator);
100			ex.invoke(f);
101			return f;
102			}
103
104			/**
105	jsr166	1.4	* Returns summary statistics, using natural comparator.
106			* @return the summary
107	dl	1.1	*/
108			public ParallelDoubleArray.SummaryStatistics summary() {
109			return summary(CommonOps.naturalDoubleComparator());
110			}
111
112			/**
113	jsr166	1.4	* Returns a new ParallelDoubleArray holding elements.
114	dl	1.1	* @return a new ParallelDoubleArray holding elements
115			*/
116			public ParallelDoubleArray all() {
117			return new ParallelDoubleArray(ex, allDoubles());
118			}
119
120			/**
121			* Returns an operation prefix that causes a method to operate
122			* on mapped elements of the array using the given op.
123			* @param op the op
124			* @return operation prefix
125			*/
126			public abstract ParallelDoubleArrayWithDoubleMapping withMapping
127			(DoubleOp op);
128
129			/**
130			* Returns an operation prefix that causes a method to operate
131			* on mapped elements of the array using the given op.
132			* @param op the op
133			* @return operation prefix
134			*/
135			public abstract ParallelDoubleArrayWithLongMapping withMapping
136			(DoubleToLong op);
137
138			/**
139			* Returns an operation prefix that causes a method to operate
140			* on mapped elements of the array using the given op.
141			* @param op the op
142			* @return operation prefix
143			*/
144			public abstract <U> ParallelDoubleArrayWithMapping<U> withMapping
145			(DoubleToObject<? extends U> op);
146
147			/**
148			* Returns an operation prefix that causes a method to operate
149			* on binary mappings of this array and the other array.
150			* @param combiner the combiner
151			* @param other the other array
152			* @return operation prefix
153			* @throws IllegalArgumentException if other array is a
154	jsr166	1.4	* filtered view (all filters must precede all mappings)
155	dl	1.1	*/
156			public <V,W,X> ParallelDoubleArrayWithMapping<W> withMapping
157			(DoubleAndObjectToObject<? super V, ? extends W> combiner,
158			ParallelArrayWithMapping<X,V> other) {
159			if (other.hasFilter()) throw new IllegalArgumentException();
160			return withIndexedMapping
161			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
162			}
163
164			/**
165			* Returns an operation prefix that causes a method to operate
166			* on binary mappings of this array and the other array.
167			* @param combiner the combiner
168			* @param other the other array
169			* @return operation prefix
170			* @throws IllegalArgumentException if other array is a
171	jsr166	1.4	* filtered view (all filters must precede all mappings)
172	dl	1.1	*/
173			public <V> ParallelDoubleArrayWithMapping<V> withMapping
174			(DoubleAndDoubleToObject<? extends V> combiner,
175			ParallelDoubleArrayWithDoubleMapping other) {
176			if (other.hasFilter()) throw new IllegalArgumentException();
177			return withIndexedMapping
178			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
179			}
180
181			/**
182			* Returns an operation prefix that causes a method to operate
183			* on binary mappings of this array and the other array.
184			* @param combiner the combiner
185			* @param other the other array
186			* @return operation prefix
187			* @throws IllegalArgumentException if other array is a
188	jsr166	1.4	* filtered view (all filters must precede all mappings)
189	dl	1.1	*/
190			public <V> ParallelDoubleArrayWithMapping<V> withMapping
191			(DoubleAndLongToObject<? extends V> combiner,
192			ParallelLongArrayWithLongMapping other) {
193			if (other.hasFilter()) throw new IllegalArgumentException();
194			return withIndexedMapping
195			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
196			}
197
198			/**
199			* Returns an operation prefix that causes a method to operate
200			* on binary mappings of this array and the other array.
201			* @param combiner the combiner
202			* @param other the other array
203			* @return operation prefix
204			* @throws IllegalArgumentException if other array is a
205	jsr166	1.4	* filtered view (all filters must precede all mappings)
206	dl	1.1	*/
207			public <V,W> ParallelDoubleArrayWithDoubleMapping withMapping
208			(DoubleAndObjectToDouble<? super V> combiner,
209			ParallelArrayWithMapping<W,V> other) {
210			if (other.hasFilter()) throw new IllegalArgumentException();
211			return withIndexedMapping
212			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
213			}
214
215			/**
216			* Returns an operation prefix that causes a method to operate
217			* on binary mappings of this array and the other array.
218			* @param combiner the combiner
219			* @param other the other array
220			* @return operation prefix
221			* @throws IllegalArgumentException if other array is a
222	jsr166	1.4	* filtered view (all filters must precede all mappings)
223	dl	1.1	*/
224			public ParallelDoubleArrayWithDoubleMapping withMapping
225			(BinaryDoubleOp combiner,
226			ParallelDoubleArrayWithDoubleMapping other) {
227			if (other.hasFilter()) throw new IllegalArgumentException();
228			return withIndexedMapping
229			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
230			}
231
232			/**
233			* Returns an operation prefix that causes a method to operate
234			* on binary mappings of this array and the other array.
235			* @param combiner the combiner
236			* @param other the other array
237			* @return operation prefix
238			* @throws IllegalArgumentException if other array is a
239	jsr166	1.4	* filtered view (all filters must precede all mappings)
240	dl	1.1	*/
241			public ParallelDoubleArrayWithDoubleMapping withMapping
242			(DoubleAndLongToDouble combiner,
243			ParallelLongArrayWithLongMapping other) {
244			if (other.hasFilter()) throw new IllegalArgumentException();
245			return withIndexedMapping
246			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
247			}
248
249			/**
250			* Returns an operation prefix that causes a method to operate
251			* on binary mappings of this array and the other array.
252			* @param combiner the combiner
253			* @param other the other array
254			* @return operation prefix
255			* @throws IllegalArgumentException if other array is a
256	jsr166	1.4	* filtered view (all filters must precede all mappings)
257	dl	1.1	*/
258			public <V,W> ParallelDoubleArrayWithLongMapping withMapping
259			(DoubleAndObjectToLong<? super V> combiner,
260			ParallelArrayWithMapping<W,V> other) {
261			if (other.hasFilter()) throw new IllegalArgumentException();
262			return withIndexedMapping
263			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
264			}
265
266			/**
267			* Returns an operation prefix that causes a method to operate
268			* on binary mappings of this array and the other array.
269			* @param combiner the combiner
270			* @param other the other array
271			* @return operation prefix
272			* @throws IllegalArgumentException if other array is a
273	jsr166	1.4	* filtered view (all filters must precede all mappings)
274	dl	1.1	*/
275			public ParallelDoubleArrayWithLongMapping withMapping
276			(DoubleAndDoubleToLong combiner,
277			ParallelDoubleArrayWithDoubleMapping other) {
278			if (other.hasFilter()) throw new IllegalArgumentException();
279			return withIndexedMapping
280			(AbstractParallelAnyArray.indexedMapper(combiner, other, origin));
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 ParallelDoubleArrayWithLongMapping withMapping
293			(DoubleAndLongToLong 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> ParallelDoubleArrayWithMapping<V> withIndexedMapping
310			(IntAndDoubleToObject<? 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 ParallelDoubleArrayWithDoubleMapping withIndexedMapping
322			(IntAndDoubleToDouble 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 ParallelDoubleArrayWithLongMapping withIndexedMapping
334			(IntAndDoubleToLong 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<Double> sequentially() {
343			return new SequentiallyAsDouble();
344			}
345			}