ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/extra166y/ParallelArray.java
(Generate patch)

Comparing jsr166/src/extra166y/ParallelArray.java (file contents):
Revision 1.1 by dl, Tue Jan 6 14:30:57 2009 UTC vs.
Revision 1.7 by jsr166, Sat Dec 29 23:55:19 2012 UTC

# Line 1 | Line 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 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7   package extra166y;
# Line 22 | Line 22 | import java.lang.reflect.Array;
22   * matching a predicate or ranges of indices, and to <em>reduce</em>
23   * all elements into a single value such as a sum.
24   *
25 < * <p> A ParallelArray is constructed by allocating, using, or copying
25 > * <p>A ParallelArray is constructed by allocating, using, or copying
26   * an array, using one of the static factory methods {@link #create},
27   * {@link #createEmpty}, {@link #createUsingHandoff} and {@link
28   * #createFromCopy}. Upon construction, the encapsulated array managed
# Line 31 | Line 31 | import java.lang.reflect.Array;
31   * array, access by another thread of an element of a ParallelArray
32   * while another operation is in progress has undefined effects.
33   *
34 < * <p> The ForkJoinPool used to construct a ParallelArray can be
34 > * <p>The ForkJoinPool used to construct a ParallelArray can be
35   * shared safely by other threads (and used in other
36   * ParallelArrays). To avoid the overhead associated with creating
37   * multiple executors, it is often a good idea to use the {@link
# Line 67 | Line 67 | import java.lang.reflect.Array;
67   * significantly improving performance beyond that of the Long and
68   * Double versions.)
69   *
70 < * <p> Most usages of ParallelArray involve sets of operations prefixed
70 > * <p>Most usages of ParallelArray involve sets of operations prefixed
71   * with range bounds, filters, and mappings (including mappings that
72   * combine elements from other ParallelArrays), using
73   * <tt>withBounds</tt>, <tt>withFilter</tt>, and <tt>withMapping</tt>,
# Line 139 | Line 139 | import java.lang.reflect.Array;
139   *   static final GpaField gpaField = new GpaField();
140   * }
141   * </pre>
142 – *
142   */
143   public class ParallelArray<T> extends AbstractParallelAnyArray.OUPap<T> implements Iterable<T> {
144      /*
# Line 273 | Line 272 | public class ParallelArray<T> extends Ab
272       * mapped ParallelArray.
273       */
274      public static interface SummaryStatistics<T> {
275 <        /** Return the number of elements */
275 >        /** Returns the number of elements */
276          public int size();
277 <        /** Return the minimum element, or null if empty */
277 >        /** Returns the minimum element, or null if empty */
278          public T min();
279 <        /** Return the maximum element, or null if empty */
279 >        /** Returns the maximum element, or null if empty */
280          public T max();
281 <        /** Return the index of the minimum element, or -1 if empty */
281 >        /** Returns the index of the minimum element, or -1 if empty */
282          public int indexOfMin();
283 <        /** Return the index of the maximum element, or -1 if empty */
283 >        /** Returns the index of the maximum element, or -1 if empty */
284          public int indexOfMax();
285      }
286  
287      /**
288 <     * Returns the executor used for computations
288 >     * Returns the executor used for computations.
289       * @return the executor
290       */
291      public ForkJoinPool getExecutor() { return ex; }
# Line 451 | Line 450 | public class ParallelArray<T> extends Ab
450       * to locate minimum and maximum elements.
451       * @param comparator the comparator to use for
452       * locating minimum and maximum elements
453 <     * @return the summary.
453 >     * @return the summary
454       */
455      public ParallelArray.SummaryStatistics<T> summary
456          (Comparator<? super T> comparator) {
# Line 460 | Line 459 | public class ParallelArray<T> extends Ab
459  
460      /**
461       * Returns summary statistics, assuming that all elements are
462 <     * Comparables
463 <     * @return the summary.
462 >     * Comparables.
463 >     * @return the summary
464       */
465      public ParallelArray.SummaryStatistics<T> summary() {
466          return super.summary();
467      }
468  
469      /**
470 <     * Returns the minimum element, or null if empty
470 >     * Returns the minimum element, or null if empty.
471       * @param comparator the comparator
472       * @return minimum element, or null if empty
473       */
# Line 478 | Line 477 | public class ParallelArray<T> extends Ab
477  
478      /**
479       * Returns the minimum element, or null if empty,
480 <     * assuming that all elements are Comparables
480 >     * assuming that all elements are Comparables.
481       * @return minimum element, or null if empty
482 <     * @throws ClassCastException if any element is not Comparable.
482 >     * @throws ClassCastException if any element is not Comparable
483       */
484      public T min() {
485          return super.min();
486      }
487  
488      /**
489 <     * Returns the maximum element, or null if empty
489 >     * Returns the maximum element, or null if empty.
490       * @param comparator the comparator
491       * @return maximum element, or null if empty
492       */
# Line 496 | Line 495 | public class ParallelArray<T> extends Ab
495      }
496  
497      /**
498 <     * Returns the maximum element, or null if empty
499 <     * assuming that all elements are Comparables
498 >     * Returns the maximum element, or null if empty,
499 >     * assuming that all elements are Comparables.
500       * @return maximum element, or null if empty
501 <     * @throws ClassCastException if any element is not Comparable.
501 >     * @throws ClassCastException if any element is not Comparable
502       */
503      public T max() {
504          return super.max();
# Line 552 | Line 551 | public class ParallelArray<T> extends Ab
551       * Sorts the array, assuming all elements are Comparable. Unlike
552       * Arrays.sort, this sort does not guarantee that elements
553       * with equal keys maintain their relative position in the array.
554 <     * @throws ClassCastException if any element is not Comparable.
554 >     * @throws ClassCastException if any element is not Comparable
555       * @return this (to simplify use in expressions)
556       */
557      public ParallelArray<T> sort() {
# Line 663 | Line 662 | public class ParallelArray<T> extends Ab
662       * @param other the elements to add
663       * @return this (to simplify use in expressions)
664       */
665 <    public  ParallelArray<T> addAll(T[] other) {
665 >    public ParallelArray<T> addAll(T[] other) {
666          int csize = other.length;
667          int end = fence;
668          insertSlotsAt(end, csize);
# Line 716 | Line 715 | public class ParallelArray<T> extends Ab
715      /**
716       * Returns an operation prefix that causes a method to operate
717       * only on the elements of the array for which the given selector
718 <     * returns true
718 >     * returns true.
719       * @param selector the selector
720       * @return operation prefix
721       */
# Line 728 | Line 727 | public class ParallelArray<T> extends Ab
727      /**
728       * Returns an operation prefix that causes a method to operate
729       * only on elements for which the given binary selector returns
730 <     * true
730 >     * true.
731       * @param selector the selector
732       * @return operation prefix
733       */
# Line 741 | Line 740 | public class ParallelArray<T> extends Ab
740      /**
741       * Returns an operation prefix that causes a method to operate
742       * only on elements for which the given indexed selector returns
743 <     * true
743 >     * true.
744       * @param selector the selector
745       * @return operation prefix
746       */
# Line 790 | Line 789 | public class ParallelArray<T> extends Ab
789       * @param other the other array
790       * @return operation prefix
791       * @throws IllegalArgumentException if other array is a
792 <     * filtered view (all filters must precede all mappings).
792 >     * filtered view (all filters must precede all mappings)
793       */
794      public <U,V,W> ParallelArrayWithMapping<T,V> withMapping
795          (BinaryOp<? super T, ? super U, ? extends V> combiner,
# Line 805 | Line 804 | public class ParallelArray<T> extends Ab
804       * @param other the other array
805       * @return operation prefix
806       * @throws IllegalArgumentException if other array is a
807 <     * filtered view (all filters must precede all mappings).
807 >     * filtered view (all filters must precede all mappings)
808       */
809      public <V> ParallelArrayWithMapping<T,V> withMapping
810          (ObjectAndDoubleToObject<? super T, ? extends V> combiner,
# Line 820 | Line 819 | public class ParallelArray<T> extends Ab
819       * @param other the other array
820       * @return operation prefix
821       * @throws IllegalArgumentException if other array is a
822 <     * filtered view (all filters must precede all mappings).
822 >     * filtered view (all filters must precede all mappings)
823       */
824      public <V> ParallelArrayWithMapping<T,V> withMapping
825          (ObjectAndLongToObject<? super T, ? extends V> combiner,
# Line 835 | Line 834 | public class ParallelArray<T> extends Ab
834       * @param other the other array
835       * @return operation prefix
836       * @throws IllegalArgumentException if other array is a
837 <     * filtered view (all filters must precede all mappings).
837 >     * filtered view (all filters must precede all mappings)
838       */
839      public <U,W> ParallelArrayWithDoubleMapping<T> withMapping
840          (ObjectAndObjectToDouble<? super T, ? super U> combiner,
# Line 850 | Line 849 | public class ParallelArray<T> extends Ab
849       * @param other the other array
850       * @return operation prefix
851       * @throws IllegalArgumentException if other array is a
852 <     * filtered view (all filters must precede all mappings).
852 >     * filtered view (all filters must precede all mappings)
853       */
854      public ParallelArrayWithDoubleMapping<T> withMapping
855          (ObjectAndDoubleToDouble<? super T> combiner,
# Line 865 | Line 864 | public class ParallelArray<T> extends Ab
864       * @param other the other array
865       * @return operation prefix
866       * @throws IllegalArgumentException if other array is a
867 <     * filtered view (all filters must precede all mappings).
867 >     * filtered view (all filters must precede all mappings)
868       */
869      public ParallelArrayWithDoubleMapping<T> withMapping
870          (ObjectAndLongToDouble<? super T> combiner,
# Line 880 | Line 879 | public class ParallelArray<T> extends Ab
879       * @param other the other array
880       * @return operation prefix
881       * @throws IllegalArgumentException if other array is a
882 <     * filtered view (all filters must precede all mappings).
882 >     * filtered view (all filters must precede all mappings)
883       */
884      public <U,W> ParallelArrayWithLongMapping<T> withMapping
885          (ObjectAndObjectToLong<? super T, ? super U> combiner,
# Line 895 | Line 894 | public class ParallelArray<T> extends Ab
894       * @param other the other array
895       * @return operation prefix
896       * @throws IllegalArgumentException if other array is a
897 <     * filtered view (all filters must precede all mappings).
897 >     * filtered view (all filters must precede all mappings)
898       */
899      public ParallelArrayWithLongMapping<T> withMapping
900          (ObjectAndDoubleToLong<? super T> combiner,
# Line 910 | Line 909 | public class ParallelArray<T> extends Ab
909       * @param other the other array
910       * @return operation prefix
911       * @throws IllegalArgumentException if other array is a
912 <     * filtered view (all filters must precede all mappings).
912 >     * filtered view (all filters must precede all mappings)
913       */
914      public ParallelArrayWithLongMapping<T> withMapping
915          (ObjectAndLongToLong<? super T> combiner,
# Line 966 | Line 965 | public class ParallelArray<T> extends Ab
965       * support the remove operation. However, a full
966       * <tt>ListIterator</tt> supporting add, remove, and set
967       * operations is available via {@link #asList}.
968 <     * @return an iterator stepping through each element.
968 >     * @return an iterator stepping through each element
969       */
970      public Iterator<T> iterator() {
971          return new ParallelArrayIterator<T>(array, fence);
# Line 1018 | Line 1017 | public class ParallelArray<T> extends Ab
1017      public int size() { return fence; }
1018  
1019      /**
1020 <     * Returns the element of the array at the given index
1020 >     * Returns the element of the array at the given index.
1021       * @param i the index
1022       * @return the element of the array at the given index
1023       */
1024      public T get(int i) { return array[i]; }
1025  
1026      /**
1027 <     * Sets the element of the array at the given index to the given value
1027 >     * Sets the element of the array at the given index to the given value.
1028       * @param i the index
1029       * @param x the value
1030       */
1031      public void set(int i, T x) { array[i] = x; }
1032  
1033      /**
1034 <     * Returns the underlying array used for computations
1034 >     * Returns the underlying array used for computations.
1035       * @return the array
1036       */
1037      public T[] getArray() { return array; }
# Line 1053 | Line 1052 | public class ParallelArray<T> extends Ab
1052       * than the length of the underlying array, causes computations to
1053       * ignore elements past the given limit.
1054       * @param newLimit the new upper bound
1055 <     * @throws IllegalArgumentException if newLimit less than zero.
1055 >     * @throws IllegalArgumentException if newLimit less than zero
1056       */
1057      public final void setLimit(int newLimit) {
1058          if (newLimit < 0)
# Line 1096 | Line 1095 | public class ParallelArray<T> extends Ab
1095      }
1096  
1097      /**
1098 <     * Make len slots available at index
1098 >     * Makes len slots available at index.
1099       */
1100      final void insertSlotsAt(int index, int len) {
1101          if (len <= 0)

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines