src/extra166y/ParallelDoubleArrayWithFilter.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 ParallelDoubleArray that causes operations to apply
 * only to elements for which a selector returns true.
 * Instances of this class may be constructed only via prefix
 * methods of ParallelDoubleArray or its other prefix classes.
 */
public abstract class ParallelDoubleArrayWithFilter extends ParallelDoubleArrayWithDoubleMapping {
    ParallelDoubleArrayWithFilter
        (ForkJoinPool ex, int origin, int fence, double[] array) {
        super(ex, origin, fence, array);
    }

    /**
     * Replaces elements with the results of applying the given
     * op to their current values.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithMapping(DoubleOp op) {
        ex.invoke(new PAS.FJDTransform(this, origin,
                                       fence, null, op));
        return this;
    }

    /**
     * Replaces elements with the results of applying the given
     * op to their indices.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithMappedIndex(IntToDouble op) {
        ex.invoke(new PAS.FJDIndexMap(this, origin, fence,
                                      null, op));
        return this;
    }

    /**
     * Replaces elements with the results of applying the given
     * mapping to each index and current element value.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithMappedIndex(IntAndDoubleToDouble op) {
        ex.invoke(new PAS.FJDBinaryIndexMap
                  (this, origin, fence, null, op));
        return this;
    }

    /**
     * Replaces elements with results of applying the given generator.
     * @param generator the generator
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithGeneratedValue(DoubleGenerator generator) {
        ex.invoke(new PAS.FJDGenerate
                  (this, origin, fence, null, generator));
        return this;
    }

    /**
     * Replaces elements with the given value.
     * @param value the value
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithValue(double value) {
        ex.invoke(new PAS.FJDFill(this, origin, fence,
                                  null, value));
        return this;
    }

    /**
     * Replaces elements with results of applying
     * {@code op(thisElement, otherElement)}.
     * @param other the other array
     * @param combiner the combiner
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithMapping(BinaryDoubleOp combiner,
                                   ParallelDoubleArrayWithDoubleMapping other) {
        ex.invoke(new PAS.FJDPACombineInPlace
                  (this, origin, fence, null,
                   other, other.origin - origin, combiner));
        return this;
    }

    /**
     * Replaces elements with results of applying
     * {@code op(thisElement, otherElement)}.
     * @param other the other array
     * @param combiner the combiner
     * @return this (to simplify use in expressions)
     */
    public ParallelDoubleArrayWithFilter replaceWithMapping
        (BinaryDoubleOp combiner,
         double[] other) {
        ex.invoke(new PAS.FJDCombineInPlace
                  (this, origin, fence, null, other,
                   -origin, combiner));
        return this;
    }

    /**
     * Returns a new ParallelDoubleArray containing only unique
     * elements (that is, without any duplicates).
     * @return the new ParallelDoubleArray
     */
    public ParallelDoubleArray allUniqueElements() {
        PAS.UniquifierTable tab = new PAS.UniquifierTable
            (fence - origin, this, false);
        PAS.FJDUniquifier f = new PAS.FJDUniquifier
            (this, origin, fence, null, tab);
        ex.invoke(f);
        double[] res = tab.uniqueDoubles(f.count);
        return new ParallelDoubleArray(ex, res);
    }


    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithFilter withFilter
        (DoublePredicate selector);

    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given binary selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public ParallelDoubleArrayWithFilter withFilter
        (BinaryDoublePredicate selector,
         ParallelDoubleArrayWithDoubleMapping other) {
        return withIndexedFilter(AbstractParallelAnyArray.indexedSelector(selector, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given indexed selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public abstract ParallelDoubleArrayWithFilter withIndexedFilter
        (IntAndDoublePredicate selector);

    /**
     * Returns true if all elements at the same relative positions
     * of this and other array are equal.
     * @param other the other array
     * @return true if equal
     */
    public boolean hasAllEqualElements
        (ParallelDoubleArrayWithDoubleMapping other) {
        return withFilter(CommonOps.doubleInequalityPredicate(),
                          other).anyIndex() < 0;
    }

    final void leafTransfer(int lo, int hi, double[] dest, int offset) {
        final double[] a = this.array;
        for (int i = lo; i < hi; ++i)
            dest[offset++] = (a[i]);
    }

    final void leafTransferByIndex(int[] indices, int loIdx, int hiIdx,
                                   double[] dest, int offset) {
        final double[] a = this.array;
        for (int i = loIdx; i < hiIdx; ++i)
            dest[offset++] = (a[indices[i]]);
    }

    final double dget(int i) { return this.array[i]; }

}
Revision:	1.8
Committed:	Thu Feb 26 06:53:34 2015 UTC (9 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.7:	+0 -1 lines
Log Message:	delete unused imports
#	Content
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	* http://creativecommons.org/publicdomain/zero/1.0/
5	*/
6
7	package extra166y;
8
9	import jsr166y.*;
10	import static extra166y.Ops.*;
11	import java.util.*;
12	import java.util.concurrent.atomic.*;
13
14	/**
15	* A prefix view of ParallelDoubleArray that causes operations to apply
16	* only to elements for which a selector returns true.
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 ParallelDoubleArrayWithFilter extends ParallelDoubleArrayWithDoubleMapping {
21	ParallelDoubleArrayWithFilter
22	(ForkJoinPool ex, int origin, int fence, double[] array) {
23	super(ex, origin, fence, array);
24	}
25
26	/**
27	* Replaces elements with the results of applying the given
28	* op to their current values.
29	* @param op the op
30	* @return this (to simplify use in expressions)
31	*/
32	public ParallelDoubleArrayWithFilter replaceWithMapping(DoubleOp op) {
33	ex.invoke(new PAS.FJDTransform(this, origin,
34	fence, null, op));
35	return this;
36	}
37
38	/**
39	* Replaces elements with the results of applying the given
40	* op to their indices.
41	* @param op the op
42	* @return this (to simplify use in expressions)
43	*/
44	public ParallelDoubleArrayWithFilter replaceWithMappedIndex(IntToDouble op) {
45	ex.invoke(new PAS.FJDIndexMap(this, origin, fence,
46	null, op));
47	return this;
48	}
49
50	/**
51	* Replaces elements with the results of applying the given
52	* mapping to each index and current element value.
53	* @param op the op
54	* @return this (to simplify use in expressions)
55	*/
56	public ParallelDoubleArrayWithFilter replaceWithMappedIndex(IntAndDoubleToDouble op) {
57	ex.invoke(new PAS.FJDBinaryIndexMap
58	(this, origin, fence, null, op));
59	return this;
60	}
61
62	/**
63	* Replaces elements with results of applying the given generator.
64	* @param generator the generator
65	* @return this (to simplify use in expressions)
66	*/
67	public ParallelDoubleArrayWithFilter replaceWithGeneratedValue(DoubleGenerator generator) {
68	ex.invoke(new PAS.FJDGenerate
69	(this, origin, fence, null, generator));
70	return this;
71	}
72
73	/**
74	* Replaces elements with the given value.
75	* @param value the value
76	* @return this (to simplify use in expressions)
77	*/
78	public ParallelDoubleArrayWithFilter replaceWithValue(double value) {
79	ex.invoke(new PAS.FJDFill(this, origin, fence,
80	null, value));
81	return this;
82	}
83
84	/**
85	* Replaces elements with results of applying
86	* {@code op(thisElement, otherElement)}.
87	* @param other the other array
88	* @param combiner the combiner
89	* @return this (to simplify use in expressions)
90	*/
91	public ParallelDoubleArrayWithFilter replaceWithMapping(BinaryDoubleOp combiner,
92	ParallelDoubleArrayWithDoubleMapping other) {
93	ex.invoke(new PAS.FJDPACombineInPlace
94	(this, origin, fence, null,
95	other, other.origin - origin, combiner));
96	return this;
97	}
98
99	/**
100	* Replaces elements with results of applying
101	* {@code op(thisElement, otherElement)}.
102	* @param other the other array
103	* @param combiner the combiner
104	* @return this (to simplify use in expressions)
105	*/
106	public ParallelDoubleArrayWithFilter replaceWithMapping
107	(BinaryDoubleOp combiner,
108	double[] other) {
109	ex.invoke(new PAS.FJDCombineInPlace
110	(this, origin, fence, null, other,
111	-origin, combiner));
112	return this;
113	}
114
115	/**
116	* Returns a new ParallelDoubleArray containing only unique
117	* elements (that is, without any duplicates).
118	* @return the new ParallelDoubleArray
119	*/
120	public ParallelDoubleArray allUniqueElements() {
121	PAS.UniquifierTable tab = new PAS.UniquifierTable
122	(fence - origin, this, false);
123	PAS.FJDUniquifier f = new PAS.FJDUniquifier
124	(this, origin, fence, null, tab);
125	ex.invoke(f);
126	double[] res = tab.uniqueDoubles(f.count);
127	return new ParallelDoubleArray(ex, res);
128	}
129
130
131	/**
132	* Returns an operation prefix that causes a method to operate
133	* only on elements for which the current selector (if
134	* present) and the given selector returns true.
135	* @param selector the selector
136	* @return operation prefix
137	*/
138	public abstract ParallelDoubleArrayWithFilter withFilter
139	(DoublePredicate selector);
140
141	/**
142	* Returns an operation prefix that causes a method to operate
143	* only on elements for which the current selector (if
144	* present) and the given binary selector returns true.
145	* @param selector the selector
146	* @return operation prefix
147	*/
148	public ParallelDoubleArrayWithFilter withFilter
149	(BinaryDoublePredicate selector,
150	ParallelDoubleArrayWithDoubleMapping other) {
151	return withIndexedFilter(AbstractParallelAnyArray.indexedSelector(selector, other, origin));
152	}
153
154	/**
155	* Returns an operation prefix that causes a method to operate
156	* only on elements for which the current selector (if
157	* present) and the given indexed selector returns true.
158	* @param selector the selector
159	* @return operation prefix
160	*/
161	public abstract ParallelDoubleArrayWithFilter withIndexedFilter
162	(IntAndDoublePredicate selector);
163
164	/**
165	* Returns true if all elements at the same relative positions
166	* of this and other array are equal.
167	* @param other the other array
168	* @return true if equal
169	*/
170	public boolean hasAllEqualElements
171	(ParallelDoubleArrayWithDoubleMapping other) {
172	return withFilter(CommonOps.doubleInequalityPredicate(),
173	other).anyIndex() < 0;
174	}
175
176	final void leafTransfer(int lo, int hi, double[] dest, int offset) {
177	final double[] a = this.array;
178	for (int i = lo; i < hi; ++i)
179	dest[offset++] = (a[i]);
180	}
181
182	final void leafTransferByIndex(int[] indices, int loIdx, int hiIdx,
183	double[] dest, int offset) {
184	final double[] a = this.array;
185	for (int i = loIdx; i < hiIdx; ++i)
186	dest[offset++] = (a[indices[i]]);
187	}
188
189	final double dget(int i) { return this.array[i]; }
190
191	}