Locates the first element of an array along a dimension that has the minimum value of all elements corresponding to the true values of the mask. MINLOC will return the index referable to the position of the element using a positive integer.

**ARRAY**- is an array of type integer or real.
**+---------------------------------Fortran 95---------------------------------+**

**DIM (optional)**- is a scalar integer in the range 1<=DIM<=
`n`, where`n`is the rank of ARRAY.**+-----------------------------End of Fortran 95------------------------------+** **MASK (optional)**- is of type logical and conforms to ARRAY in shape. If it is absent,
the default mask evaluation is
`.TRUE.`; that is, the entire array is evaluated.

**Class**

Transformational function

**Result Type and Attributes**

If DIM is absent, the result is an integer array of rank one with a size
equal to the rank of ARRAY. If DIM is present, the result is an integer
array of rank rank(ARRAY)-1, and the shape is (s_{1}, ...,
s_{DIM-1}, s_{DIM+1}, ..., s_{n}), where n is the
rank of ARRAY.

If there is no minimum value, perhaps because the array is zero-sized or
the mask array has all `.FALSE.` values or there is no
DIM argument, the return value is a zero-sized one-dimensional entity.
If DIM is present, the result shape depends on the rank of
ARRAY.

**Result Value**

The result indicates the subscript of the location of the minimum masked element of ARRAY. If more than one element is equal to this minimum value, the function finds the location of the first (in array element order). If DIM is specified, the result indicates the location of the minimum masked element along each vector of the dimension.

+---------------------------------Fortran 95---------------------------------+

Because both DIM and MASK are optional, various combinations of
arguments are possible. When the **-qintlog** option is specified
with two arguments, the second argument refers to one of the following:

- MASK if it is an array of type integer, logical, byte or typeless
- DIM if it is a scalar of type integer, byte or typeless
- MASK if it is a scalar or type logical

The addition of the DIM argument modifies the behavior from XL Fortran Version 3.

+-----------------------------End of Fortran 95------------------------------+

**Examples**

```
! A is the array | 4 9 8 -8 |
! | 2 1 -1 5 |
! | 9 4 -1 9 |
! | -7 5 7 -3 |
! Where is the smallest element of A?
RES = MINLOC(A)
! The result is | 1 4 | because -8 is located at A(1,4).
! Where is the smallest element in each row of A that
! is not equal to -7?
RES = MINLOC(A, DIM = 2, MASK = A .NE. -7)
! The result is | 4 3 3 4 | because these are the
! corresponding column locations of the smallest value
! in each row not equal ! to -7 (the values being
! -8,-1,-1,-3).
```

Regardless of the defined upper and lower bounds of the array, MINLOC will determine the lower bound index as '1'. Both MAXLOC and MINLOC index using positive integers. To find an actual index:

```
INTEGER B(-100:100)
! Minloc views the bounds as (1:201)
! If the smallest element is located at index '-49'
I = MINLOC(B)
! Will return the index '52'
! To return the exact index for the smallest element, insert:
INDEX = LBOUND(B) - 1 + I
! Which is: INDEX = (-100) - 1 + 52 = (-49)
PRINT*, B(INDEX)
```