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

Comparing jsr166/src/extra166y/ParallelDoubleArray.java (file contents):
Revision 1.7 by jsr166, Sat Dec 29 23:55:19 2012 UTC vs.
Revision 1.9 by jsr166, Wed Jan 16 00:51:11 2013 UTC

# Line 61 | Line 61 | public class ParallelDoubleArray extends
61  
62      /**
63       * Creates a new ParallelDoubleArray using the given executor and
64 <     * an array of the given size
64 >     * an array of the given size.
65       * @param size the array size
66       * @param executor the executor
67       */
# Line 154 | Line 154 | public class ParallelDoubleArray extends
154      }
155  
156      /**
157 <     * Returns the executor used for computations
157 >     * Returns the executor used for computations.
158       * @return the executor
159       */
160      public ForkJoinPool getExecutor() { return ex; }
161  
162      /**
163 <     * Applies the given procedure to elements
163 >     * Applies the given procedure to elements.
164       * @param procedure the procedure
165       */
166      public void apply(DoubleProcedure procedure) {
# Line 168 | Line 168 | public class ParallelDoubleArray extends
168      }
169  
170      /**
171 <     * Returns reduction of elements
171 >     * Returns reduction of elements.
172       * @param reducer the reducer
173       * @param base the result for an empty array
174       * @return reduction
# Line 178 | Line 178 | public class ParallelDoubleArray extends
178      }
179  
180      /**
181 <     * Returns a new ParallelDoubleArray holding all elements
181 >     * Returns a new ParallelDoubleArray holding all elements.
182       * @return a new ParallelDoubleArray holding all elements
183       */
184      public ParallelDoubleArray all() {
# Line 209 | Line 209 | public class ParallelDoubleArray extends
209  
210      /**
211       * Replaces elements with the results of applying the given
212 <     * mapping to each index and current element value
212 >     * mapping to each index and current element value.
213       * @param op the op
214       * @return this (to simplify use in expressions)
215       */
# Line 222 | Line 222 | public class ParallelDoubleArray extends
222       * Replaces elements with the results of applying the given
223       * generator. For example, to fill the array with uniform random
224       * values, use
225 <     * <tt>replaceWithGeneratedValue(Ops.doubleRandom())</tt>
225 >     * {@code replaceWithGeneratedValue(Ops.doubleRandom())}.
226       * @param generator the generator
227       * @return this (to simplify use in expressions)
228       */
# Line 243 | Line 243 | public class ParallelDoubleArray extends
243  
244      /**
245       * Replaces elements with results of applying
246 <     * <tt>op(thisElement, otherElement)</tt>
246 >     * {@code op(thisElement, otherElement)}.
247       * @param other the other array
248       * @param combiner the combiner
249       * @return this (to simplify use in expressions)
# Line 258 | Line 258 | public class ParallelDoubleArray extends
258  
259      /**
260       * Replaces elements with results of applying
261 <     * <tt>op(thisElement, otherElement)</tt>
261 >     * {@code op(thisElement, otherElement)}.
262       * @param other the other array
263       * @param combiner the combiner
264       * @return this (to simplify use in expressions)
# Line 273 | Line 273 | public class ParallelDoubleArray extends
273  
274      /**
275       * Returns the index of some element equal to given target, or -1
276 <     * if not present
276 >     * if not present.
277       * @param target the element to search for
278       * @return the index or -1 if not present
279       */
# Line 362 | Line 362 | public class ParallelDoubleArray extends
362      /**
363       * Replaces each element with the running cumulation of applying
364       * the given reducer. For example, if the contents are the numbers
365 <     * <tt>1, 2, 3</tt>, and the reducer operation adds numbers, then
366 <     * after invocation of this method, the contents would be <tt>1,
367 <     * 3, 6</tt> (that is, <tt>1, 1+2, 1+2+3</tt>);
365 >     * {@code 1, 2, 3}, and the reducer operation adds numbers, then
366 >     * after invocation of this method, the contents would be {@code 1,
367 >     * 3, 6} (that is, {@code 1, 1+2, 1+2+3});
368       * @param reducer the reducer
369       * @param base the result for an empty array
370       * @return this (to simplify use in expressions)
# Line 377 | Line 377 | public class ParallelDoubleArray extends
377      /**
378       * Replaces each element with the cumulation of applying the given
379       * reducer to all previous values, and returns the total
380 <     * reduction. For example, if the contents are the numbers <tt>1,
381 <     * 2, 3</tt>, and the reducer operation adds numbers, then after
382 <     * invocation of this method, the contents would be <tt>0, 1,
383 <     * 3</tt> (that is, <tt>0, 0+1, 0+1+2</tt>, and the return value
384 <     * would be 6 (that is, <tt> 1+2+3</tt>);
380 >     * reduction. For example, if the contents are the numbers {@code 1,
381 >     * 2, 3}, and the reducer operation adds numbers, then after
382 >     * invocation of this method, the contents would be {@code 0, 1,
383 >     * 3} (that is, {@code 0, 0+1, 0+1+2}, and the return value
384 >     * would be 6 (that is, {@code  1+2+3});
385       * @param reducer the reducer
386       * @param base the result for an empty array
387       * @return the total reduction
# Line 439 | Line 439 | public class ParallelDoubleArray extends
439      }
440  
441      /**
442 <     * Equivalent to <tt>asList().addAll</tt> but specialized for
442 >     * Equivalent to {@code asList().addAll} but specialized for
443       * array arguments and likely to be more efficient.
444       * @param other the elements to add
445       * @return this (to simplify use in expressions)
# Line 797 | Line 797 | public class ParallelDoubleArray extends
797       * Returns an iterator stepping through each element of the array
798       * up to the current limit. This iterator does <em>not</em>
799       * support the remove operation. However, a full
800 <     * <tt>ListIterator</tt> supporting add, remove, and set
800 >     * {@code ListIterator} supporting add, remove, and set
801       * operations is available via {@link #asList}.
802       * @return an iterator stepping through each element
803       */
# Line 852 | Line 852 | public class ParallelDoubleArray extends
852      public int size() { return fence; }
853  
854      /**
855 <     * Returns the underlying array used for computations
855 >     * Returns the underlying array used for computations.
856       * @return the array
857       */
858      public double[] getArray() { return array; }
859  
860      /**
861 <     * Returns the element of the array at the given index
861 >     * Returns the element of the array at the given index.
862       * @param i the index
863       * @return the element of the array at the given index
864       */
865      public double get(int i) { return array[i]; }
866  
867      /**
868 <     * Sets the element of the array at the given index to the given value
868 >     * Sets the element of the array at the given index to the given value.
869       * @param i the index
870       * @param x the value
871       */
872      public void set(int i, double x) { array[i] = x; }
873  
874      /**
875 <     * Equivalent to <tt>asList().toString()</tt>
875 >     * Equivalent to {@code asList().toString()}.
876       * @return a string representation
877       */
878      public String toString() {

Diff Legend

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