src/extra166y/ParallelDoubleArrayWithBounds.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
 * only to elements within a given range.
 * Instances of this class may be constructed only via prefix
 * methods of ParallelDoubleArray or its other prefix classes.
 */
public abstract class ParallelDoubleArrayWithBounds extends ParallelDoubleArrayWithFilter {
    ParallelDoubleArrayWithBounds
        (ForkJoinPool ex, int origin, int fence, double[] array) {
        super(ex, origin, fence, array);
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * only on the elements of the array between firstIndex
     * (inclusive) and upperBound (exclusive).  The bound
     * arguments are relative to the current bounds.  For example
     * <tt>pa.withBounds(2, 8).withBounds(3, 5)</tt> indexes the
     * 5th (= 2+3) and 6th elements of pa. However, indices
     * returned by methods such as <tt>indexOf</tt> are
     * with respect to the underlying ParallelDoubleArray.
     * @param firstIndex the lower bound (inclusive)
     * @param upperBound the upper bound (exclusive)
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithBounds withBounds
        (int firstIndex, int upperBound);

    /**
     * Returns the index of some element equal to given target,
     * or -1 if not present.
     * @param target the element to search for
     * @return the index or -1 if not present
     */
    public abstract int indexOf(double 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.
     * @param target the element to search for
     * @return the index or -1 if not present
     */
    public abstract int binarySearch(double target);

    /**
     * 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.
     * @param target the element to search for
     * @param comparator the comparator
     * @return the index or -1 if not present
     */
    public abstract int binarySearch(double target,
                                     DoubleComparator comparator);

    /**
     * Replaces each element with the running cumulation of applying
     * the given reducer.
     * @param reducer the reducer
     * @param base the result for an empty array
     * @return this (to simplify use in expressions)
     */
    public abstract ParallelDoubleArrayWithBounds cumulate(DoubleReducer reducer, double base);

    /**
     * Replaces each element with the running sum.
     * @return this (to simplify use in expressions)
     */
    public abstract ParallelDoubleArrayWithBounds cumulateSum();

    /**
     * Replaces each element with the cumulation of applying the given
     * reducer to all previous values, and returns the total
     * reduction.
     * @param reducer the reducer
     * @param base the result for an empty array
     * @return the total reduction
     */
    public abstract double precumulate(DoubleReducer reducer, double base);

    /**
     * Replaces each element with its prefix sum.
     * @return the total sum
     */
    public abstract double precumulateSum();

    /**
     * Sorts the elements.
     * Unlike Arrays.sort, this sort does
     * not guarantee that elements with equal keys maintain their
     * relative position in the array.
     * @param cmp the comparator to use
     * @return this (to simplify use in expressions)
     */
    public abstract ParallelDoubleArrayWithBounds sort(DoubleComparator cmp);

    /**
     * Sorts the elements, 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
     * @return this (to simplify use in expressions)
     */
    public abstract ParallelDoubleArrayWithBounds sort();
}
Revision:	1.5
Committed:	Sun Dec 30 02:05:53 2012 UTC (11 years, 4 months ago) by jsr166
Branch:	MAIN
Changes since 1.4:	+3 -3 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			* only to elements within a given range.
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 ParallelDoubleArrayWithBounds extends ParallelDoubleArrayWithFilter {
21			ParallelDoubleArrayWithBounds
22			(ForkJoinPool ex, int origin, int fence, double[] array) {
23			super(ex, origin, fence, array);
24			}
25
26			/**
27			* Returns an operation prefix that causes a method to operate
28			* only on the elements of the array between firstIndex
29			* (inclusive) and upperBound (exclusive). The bound
30			* arguments are relative to the current bounds. For example
31			* <tt>pa.withBounds(2, 8).withBounds(3, 5)</tt> indexes the
32			* 5th (= 2+3) and 6th elements of pa. However, indices
33			* returned by methods such as <tt>indexOf</tt> are
34			* with respect to the underlying ParallelDoubleArray.
35			* @param firstIndex the lower bound (inclusive)
36			* @param upperBound the upper bound (exclusive)
37			* @return operation prefix
38			*/
39			public abstract ParallelDoubleArrayWithBounds withBounds
40			(int firstIndex, int upperBound);
41
42			/**
43			* Returns the index of some element equal to given target,
44	jsr166	1.5	* or -1 if not present.
45	dl	1.1	* @param target the element to search for
46			* @return the index or -1 if not present
47			*/
48			public abstract int indexOf(double target);
49
50			/**
51			* Assuming this array is sorted, returns the index of an
52			* element equal to given target, or -1 if not present. If the
53			* array is not sorted, the results are undefined.
54			* @param target the element to search for
55			* @return the index or -1 if not present
56			*/
57			public abstract int binarySearch(double target);
58
59			/**
60			* Assuming this array is sorted with respect to the given
61			* comparator, returns the index of an element equal to given
62			* target, or -1 if not present. If the array is not sorted,
63			* the results are undefined.
64			* @param target the element to search for
65			* @param comparator the comparator
66			* @return the index or -1 if not present
67			*/
68			public abstract int binarySearch(double target,
69			DoubleComparator comparator);
70
71			/**
72			* Replaces each element with the running cumulation of applying
73			* the given reducer.
74			* @param reducer the reducer
75			* @param base the result for an empty array
76			* @return this (to simplify use in expressions)
77			*/
78			public abstract ParallelDoubleArrayWithBounds cumulate(DoubleReducer reducer, double base);
79
80			/**
81	jsr166	1.5	* Replaces each element with the running sum.
82	dl	1.1	* @return this (to simplify use in expressions)
83			*/
84			public abstract ParallelDoubleArrayWithBounds cumulateSum();
85
86			/**
87			* Replaces each element with the cumulation of applying the given
88			* reducer to all previous values, and returns the total
89			* reduction.
90			* @param reducer the reducer
91			* @param base the result for an empty array
92			* @return the total reduction
93			*/
94			public abstract double precumulate(DoubleReducer reducer, double base);
95
96			/**
97	jsr166	1.5	* Replaces each element with its prefix sum.
98	dl	1.1	* @return the total sum
99			*/
100			public abstract double precumulateSum();
101
102			/**
103			* Sorts the elements.
104			* Unlike Arrays.sort, this sort does
105			* not guarantee that elements with equal keys maintain their
106			* relative position in the array.
107			* @param cmp the comparator to use
108			* @return this (to simplify use in expressions)
109			*/
110			public abstract ParallelDoubleArrayWithBounds sort(DoubleComparator cmp);
111
112			/**
113			* Sorts the elements, assuming all elements are
114			* Comparable. Unlike Arrays.sort, this sort does not
115			* guarantee that elements with equal keys maintain their relative
116			* position in the array.
117	jsr166	1.4	* @throws ClassCastException if any element is not Comparable
118	dl	1.1	* @return this (to simplify use in expressions)
119			*/
120			public abstract ParallelDoubleArrayWithBounds sort();
121			}