The PRODUCT function returns the product of elements within an array. The product of the array elements over a given dimension is returned if the Dimension argument is present. Because the product can easily overflow, the product is computed using double-precision arithmetic and the Result is double precision.
Tip: If your array has a mix of very large and very small values, the product may underflow or overflow during the computation, even though the final result would be within double-precision limits. In this case, you should not use PRODUCT, but instead compute the product by taking the logarithm, using the TOTAL function, and then taking the exponential: Result = EXP(TOTAL(ALOG(Array))).
To find the product of all elements in a one-dimensional array:
; Define a one-dimensional array:
array = [20, 10, 5, 5, 3]
; Find the product of the array elements:
prod = PRODUCT(array)
; Print the results:
PRINT, 'Product of Array = ', prod
Product of Array = 15000.000
Now find the product of elements in a two-dimensional array:
; Define a two-dimensional array:
array = FINDGEN(4,4) + 1
; Find the product of all array elements:
prodAll = PRODUCT(array)
; Find the product along the first dimension:
prod1 = PRODUCT(array, 1)
; Find the product along the second dimension:
prod2 = PRODUCT(array, 2)
; Print the results:
PRINT, 'Product of all elements = ', prodAll
PRINT, 'Product along first dimension: '
PRINT, 'Product along second dimension: '
Product of all elements 2.0922790e+013
Product along first dimension:
24.000000 1680.0000 11880.000 43680.000
Product along second dimension:
585.00000 1680.0000 3465.0000 6144.0000
Returns the product of the elements of Array.
The array for which to compute the product. This array can be of any basic type except string.
An optional argument specifying the dimension over which to compute the product, starting at one. If this argument is not present or zero, the product of all the array elements is returned. If this argument is present, the result is an array with one less dimension than Array.
For example, if the dimensions of Array are N1, N2, N3, and Dimension is 2, the dimensions of the result are (N1, N3), and element (i,j) of the result contains the product:
If this keyword is set, the result is an array of the same size as the input, with each element, i, containing the product of the input array elements 0 to i. This keyword also works with the Dimension parameter, in which case the cumulative product is performed over the given dimension. Note that if the input only has a single element, then a scalar is returned.
Tip: If the input array is a temporary variable or an expression, and the result type matches the input type (for example by using the PRESERVE_TYPE keyword), then PRODUCT will perform the cumulative product in place and no additional memory will be used.
Set this keyword to perform the PRODUCT using integer arithmetic, and to return an integer result. If Array is of type ULONG64 then unsigned 64-bit integers are used for the computation and the Result is of type ULONG64, otherwise signed 64-bit integers are used and the Result is of type LONG64. If Array is complex and INTEGER is set, then only the real part of each value is used for the computation.
Note: If Array has a large number of values or the values themselves are large, then the PRODUCT with the INTEGER keyword may easily overflow the largest 64-bit integer and return an incorrect result. In this case you may want to avoid using the INTEGER keyword.
Set this keyword to cause the routine to check for occurrences of the IEEE floating-point values NaN or Infinity in the input data. Elements with the value NaN or Infinity are treated as missing data with the value 1.
Set this keyword to perform the PRODUCT using the input type, and to return a result of the same type. The INTEGER keyword is ignored if PRESERVE_TYPE is set.
Note: For byte or integer data the PRODUCT with PRESERVE_TYPE may easily overflow the largest value for that type. In these cases you may want to use the INTEGER keyword instead.
Thread Pool Keywords
This routine is written to make use of IDL's thread pool, which can increase execution speed on systems with multiple CPUs. The values stored in the !CPU system variable control whether IDL uses the thread pool for a given computation. In addition, you can use the thread pool keywords TPOOL_MAX_ELTS, TPOOL_MIN_ELTS, and TPOOL_NOTHREAD to override the defaults established by !CPU for a single invocation of this routine. See Thread Pool Keywords.
Added INTEGER and PRESERVE_TYPE keywords