; Copyright (c) 1988-2009, ITT Visual Information Solutions. All
;       rights reserved. Unauthorized reproduction is prohibited.

;+
; NAME:
;	UNIQQ
;
; PURPOSE:
;	Return the subscripts of the unique elements in an array.
;
;	Note that repeated elements must be adjacent in order to be
;	found.  This routine is intended to be used with the SORT
;	function.  See the discussion of the IDX argument below.
;
;	This command is inspired by the Unix uniq(1) command.
;
; CATEGORY:
;	Array manipulation.
;
; CALLING SEQUENCE:
;	UNIQQ(Array [, Idx[, INDICES=indices]])
;
; INPUTS:
;	Array:	The array to be scanned.  The type and number of dimensions
;		of the array are not important.  The array must be sorted
;		into monotonic order unless the optional parameter Idx is 
;		supplied.
;
; OPTIONAL INPUT PARAMETERS:
;	IDX:	This optional parameter is an array of indices into Array
;		that order the elements into monotonic order.
;		That is, the expression:
;
;			Array(Idx)
;
;		yields an array in which the elements of Array are
;		rearranged into monotonic order.  If the array is not
;		already in monotonic order, use the command:
;
;			UNIQQ(Array, SORT(Array))
;
;		The expression below finds the unique elements of an unsorted
;		array:
;
;			Array(UNIQQ(Array, SORT(Array)))
;
; OUTPUTS:
;	An array of indicies into ARRAY is returned.  The expression:
;
;		ARRAY(UNIQQ(ARRAY))
;
;	will be a copy of the sorted Array with duplicate adjacent
;	elements removed.
;   
;       INDICES return indices in sorted array
;
; COMMON BLOCKS:
;	None.
;
; MODIFICATION HISTORY:
;	1988, AB, Written.
;	29 July 1992, ACY - Corrected for case of all elements the same.
;	Nov, 1995.  DMS, Return a 0 if argument is a scalar.
;       20090722 A. Heger, Return forward pointers in keyword INDICES.
;       20111215 A. Heger, Fix IDX case with all equal elements
;-
;

function UNIQQ, ARRAY, IDX, INDICES=indices

; Check the arguments.
  s = size(ARRAY)
  if (s[0] eq 0) then return, 0		;A scalar
  if n_params() ge 2 then begin		;IDX supplied?
     q = array[idx]
     indices = where(q ne shift(q,-1), count)
     if (count GT 0) then return, idx[indices] $
     else begin 
        indices = idx[n_elements(idx)-1]
        return, n_elements(q)-1
     endelse
  endif else begin
     indices = where(array ne shift(array, -1), count)
     if (count GT 0) then return, indices $
     else begin 
        indices = n_elements(ARRAY)-1
        return, n_elements(ARRAY)-1
     endelse
  endelse
end