The WHERE function returns a vector that contains the one-dimensional subscripts of the nonzero elements of Array_Expression. The length of the resulting vector is equal to the number of nonzero elements in Array_Expression. Frequently the result of WHERE is used as a vector subscript to select elements of an array using given criteria.

Note: When WHERE Returns –1

If the NULL keyword is not set, and all the elements of Array_Expression are zero, then WHERE returns a scalar integer with a value of –1. If you use this result as an index into another array without checking for –1 first, then this will return the last element of the array. To avoid this problem, you should either use /NULL or check the Count argument before indexing. For example:

; Use /NULL, if no elements match then array will not be modified:
array[WHERE(array GT 5, /NULL)] = 5


; Use Count to get the number of nonzero elements:
index = WHERE(array GT 5, count)
; Only subscript the array if it is safe:
IF count NE 0 THEN array[index] = 5


See Additional Examples for more information on using WHERE.

Example 1

; Create an integer array 0,1,2,...9
array = INDGEN(10)
PRINT, 'array = ', array
; Find the subscripts of all elements that are greater than 5
B = WHERE(array GT 5, count, COMPLEMENT=B_C, NCOMPLEMENT=count_c)
; Print how many and which elements met the search criteria:
PRINT, 'Number of elements > 5: ', count
PRINT, 'Subscripts of elements > 5: ', B
PRINT, 'Number of elements <= 5: ', count_c
PRINT, 'Subscripts of elements <= 5: ', B_C

IDL prints:

array =  0  1  2  3  4  5  6  7  8  9
Number of elements > 5:  4
Subscripts of elements > 5:  6  7  8  9
Number of elements <= 5:  6
Subscripts of elements <= 5:  0  1  2  3  4  5


Result = WHERE( Array_Expression [, Count] [, COMPLEMENT=variable] [, /L64] [, NCOMPLEMENT=variable] [, /NULL] )

Return Value

Returns a longword vector containing the subscripts of non-zero array elements matching the specified conditions. If /NULL is set, and no matches are found, then WHERE returns the value !NULL.



The array to be searched. Both the real and imaginary parts of a complex number must be zero for the number to be considered zero.


A named variable that will receive the number of nonzero elements found in Array_Expression. This value is returned as a longword integer.

Note: The system variable !ERR is set to the number of nonzero elements. This effect is for compatibility with previous versions of IDL and should not be used in new code. Use the COUNT argument to return this value instead.



Set this keyword to a named variable that receives the subscripts of the zero elements of Array_Expression. These are the subscripts that are not returned in Result. Together, Result and COMPLEMENT specify every subscript in Array_Expression. If there are no zero elements in Array_Expression, COMPLEMENT returns a scalar integer with the value -1, or the value !NULL if the NULL keyword is set.


By default, the result of WHERE is 32-bit integer when possible, and 64-bit integer if the number of elements being processed requires it. Set L64 to force 64-bit integers to be returned in all cases.

Note: Only 64-bit versions of IDL are capable of creating variables requiring a 64-bit result. Check the value of !VERSION.MEMORY_BITS to see if your IDL is 64-bit or not.


Set this keyword to a named variable that receives the number of zero elements found in Array_Expression. This value is the number of subscripts that will be returned via the COMPLEMENT keyword if it is specified.


Set this keyword to have WHERE return !NULL instead of -1 when no matches are found.

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 for details.

Additional Examples

Example 2

; Create an integer array 0,1,2,...9
array = INDGEN(10)
; Change all elements that are greater than 5 to 5
array[WHERE(array GT 5, /NULL)] = 5
PRINT, array
; Change all elements that are greater than 10 to 10.
; Since there are none, WHERE will return !NULL and array will be unchanged:
array[WHERE(array GT 10, /NULL)] = 10
PRINT, array

IDL prints:

  0  1  2  3  4  5  5  5  5  5
  0  1  2  3  4  5  5  5  5  5

Version History


Added NULL keyword.

See Also

ARRAY_INDICES, UNIQ, Conditionally Altering Array Elements


Fernando Santoro
The following example shows how to use WHERE and the MOD operator to search in a 2-D and a 3-D array:

In other words, the example code provides a function WHERE_XYZ, which takes the same arguments and keywords as the WHERE function, but in addition it has 3 keywords that return the X, Y, Z locations for 1-D, 2-D or 3-D arrays.

4th January 2013 10:47am
Page 1 of 1  (1 comment)

This information is not subject to the controls of the International Traffic in Arms Regulations (ITAR) or the Export Administration Regulations (EAR). However, it may be restricted from transfer to various embargoed countries under U.S. laws and regulations.
© 2014 Exelis Visual Information Solutions