## PRODUCT

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))).

### Syntax

Result = PRODUCT(Array [, Dimension] [, /CUMULATIVE] [, /INTEGER] [, /NAN] [, /PRESERVE_TYPE] )

### Return Value

Returns the product of the elements of Array.

### Arguments

#### Array

The array for which to compute the product. This array can be of any basic type except string.

#### Dimension

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:

### Keywords

#### CUMULATIVE

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.

 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.

#### INTEGER

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.

#### NAN

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. Elements with the value NaN are treated as missing data with the value 1. (See Special Floating-Point Values for more information on IEEE floating-point values.)

#### PRESERVE_TYPE

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.

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.

### Examples

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
```

IDL prints:

```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, prod1
PRINT, 'Product along second dimension: '
PRINT, prod2
```

IDL prints:

```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
```

### Version History

Introduced: 5.6

INTEGER and PRESERVE_TYPE keywords: 6.1