ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/extra166y/ParallelArray.java

Comparing jsr166/src/extra166y/ParallelArray.java (file contents):
Revision 1.6 by jsr166, Sun Nov 18 18:03:10 2012 UTC vs.
Revision 1.7 by jsr166, Sat Dec 29 23:55:19 2012 UTC

#	Line 450 | 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 459 | 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 477 | 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 495 | 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 551 | 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 715 | 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 727 | 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 740 | 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 789 | 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 804 | 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 819 | 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 834 | 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 849 | 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 864 | 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 879 | 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 894 | 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 909 | 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 965 | 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 1017 | 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 1052 | 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)

Diff Legend

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