### 16.1 Finding Elements and Checking Conditions ¶

The functions `any` and `all` are useful for determining whether any or all of the elements of a matrix satisfy some condition. The `find` function is also useful in determining which elements of a matrix meet a specified condition.

`tf =` any `(x)` ¶
`tf =` any `(x, dim)` ¶
`tf =` any `(x, vecdim)` ¶
`tf =` any `(x, "all")` ¶

  Return true (logical 1) if any elements are nonzero or true.

  If x is a vector, then `any (x)` returns true (logical 1) if any elements of the vector are nonzero.

  If x is a matrix, then `any (x)` returns a row vector of logical ones and zeros where each element indicates whether any of the elements of the corresponding column of the matrix are nonzero.

  If x is an array, then `any(x)` operates along the first non-singleton dimension of x and returns a logical array, whose size is equal to x except for the operating dimension which becomes 1.

  The optional input dim specifies the dimension to operate on and must be a positive integer. Specifying any singleton dimension in x, including any dimension exceeding `ndims (x)`, will return x.

  Specifying multiple dimensions with input vecdim, a vector of non-repeating dimensions, will operate along the array slice defined by vecdim. If vecdim indexes all dimensions of x, then it is equivalent to the option `"all"`. Any dimension in vecdim greater than `ndims (x)` is ignored. The size of the dimensions specified by vecdim become 1 in the returned logical array.

  Specifying the dimension as `"all"` will cause `any` to operate on all elements of x, and is equivalent to `any (x(:))`.

  See also: all.

`tf =` all `(x)` ¶
`tf =` all `(x, dim)` ¶
`tf =` all `(x, vecdim)` ¶
`tf =` all `(x, "all")` ¶

  Return true (logical 1) if all elements are nonzero or true.

  If x is a vector, then `all (x)` returns true (logical 1) if all elements of the vector are nonzero.

  If x is a matrix, then `all (x)` returns a row vector of logical ones and zeros where each element indicates whether all of the elements of the corresponding column of the matrix are nonzero.

  If x is an array, then `all(x)` operates along the first non-singleton dimension of x and returns a logical array, whose size is equal to x except for the operating dimension which becomes 1.

  The optional input dim specifies the dimension to operate on and must be a positive integer. Specifying any singleton dimension in x, including any dimension exceeding `ndims (x)`, will return x.

  Specifying multiple dimensions with input vecdim, a vector of non-repeating dimensions, will operate along the array slice defined by vecdim. If vecdim indexes all dimensions of x, then it is equivalent to the option `"all"`. Any dimension in vecdim greater than `ndims (x)` is ignored. The size of the dimensions specified by vecdim become 1 in the returned logical array.

  Specifying the dimension as `"all"` will cause `all` to operate on all elements of x, and is equivalent to `all (x(:))`.

  See also: any.

Since the comparison operators (see Comparison Operators) return matrices of ones and zeros, it is easy to test a matrix for many things, not just whether the elements are nonzero. For example,

    all (all (rand (5) < 0.9))
         ⇒  0

tests a random 5 by 5 matrix to see if all of its elements are less than 0.9.

Note that in conditional contexts (like the test clause of `if` and `while` statements) Octave treats the test as if you had typed `all (all (condition))`.

`z =` xor `(x, y)` ¶
`z =` xor `(x1, x2, …)` ¶

  Return the exclusive or of x and y.

  For boolean expressions x and y, `xor (x, y)` is true if and only if one of x or y is true. Otherwise, if x and y are both true or both false, `xor` returns false.

  The truth table for the xor operation is

  | x | y | z |
  | - | - | - |
  | 0 | 0 | 0 |
  | 1 | 0 | 1 |
  | 0 | 1 | 1 |
  | 1 | 1 | 0 |

  If more than two arguments are given the xor operation is applied cumulatively from left to right:

      (...((x1 XOR x2) XOR x3) XOR ...)

  See also: and, or, not.

`y =` diff `(x)` ¶
`y =` diff `(x, k)` ¶
`y =` diff `(x, k, dim)` ¶

  If x is a vector of length n, `diff (x)` is the vector of first differences x(2) - x(1), …, x(n) - x(n-1).

  If x is a matrix, `diff (x)` is the matrix of column differences along the first non-singleton dimension.

  The second argument is optional. If supplied, `diff (x, k)`, where k is a non-negative integer, returns the k-th differences. It is possible that k is larger than the first non-singleton dimension of the matrix. In this case, `diff` continues to take the differences along the next non-singleton dimension.

  The dimension along which to take the difference can be explicitly stated with the optional variable dim. In this case the k-th order differences are calculated along this dimension. In the case where k exceeds `size (x, dim)` an empty matrix is returned.

  See also: sort, merge.

`tf =` isinf `(x)` ¶

  Return a logical array which is true where the elements of x are infinite and false where they are not.

  For example:

      isinf ([13, Inf, NA, NaN])
            ⇒  [ 0, 1, 0, 0 ]

  See also: isfinite, isnan, isna.

`tf =` isnan `(x)` ¶

  Return a logical array which is true where the elements of x are NaN values and false where they are not.

  NA values are also considered NaN values. For example:

      isnan ([13, Inf, NA, NaN])
            ⇒  [ 0, 0, 1, 1 ]

  See also: isna, isinf, isfinite.

`tf =` isfinite `(x)` ¶

  Return a logical array which is true where the elements of x are finite values and false where they are not.

  For example:

      isfinite ([13, Inf, NA, NaN])
           ⇒  [ 1, 0, 0, 0 ]

  See also: isinf, isnan, isna.

`[err, yi, …] =` common_size `(xi, …)` ¶

  Determine if all input arguments are either scalar or of common size.

  If true, err is zero, and yi is a matrix of the common size with all entries equal to xi if this is a scalar or xi otherwise. If the inputs cannot be brought to a common size, err is 1, and yi is xi. For example:

      [err, a, b] = common_size ([1 2; 3 4], 5)
           ⇒  err = 0
           ⇒  a = [ 1, 2; 3, 4 ]
           ⇒  b = [ 5, 5; 5, 5 ]

  This is useful for implementing functions where arguments can either be scalars or of common size.

  See also: size, size_equal, numel, ndims.

`idx =` find `(x)` ¶
`idx =` find `(x, n)` ¶
`idx =` find `(x, n, direction)` ¶
`[i, j] =` find `(…)` ¶
`[i, j, v] =` find `(…)` ¶

  Return a vector of indices of nonzero elements of a matrix, as a row if x is a row vector or as a column otherwise.

  To obtain a single index for each matrix element, Octave pretends that the columns of a matrix form one long vector (like Fortran arrays are stored). For example:

      find (eye (2))
        ⇒  [ 1; 4 ]

  If two inputs are given, n indicates the maximum number of elements to find from the beginning of the matrix or vector.

  If three inputs are given, direction should be one of `"first"` or `"last"`, requesting only the first or last n indices, respectively. However, the indices are always returned in ascending order.

  If two outputs are requested, `find` returns the row and column indices of nonzero elements of a matrix. For example:

      [i, j] = find (2 * eye (2))
          ⇒  i = [ 1; 2 ]
          ⇒  j = [ 1; 2 ]

  If three outputs are requested, `find` also returns a vector containing the nonzero values. For example:

      [i, j, v] = find (3 * eye (2))
             ⇒  i = [ 1; 2 ]
             ⇒  j = [ 1; 2 ]
             ⇒  v = [ 3; 3 ]

  If x is a multi-dimensional array of size m x n x p x …, j contains the column locations as if x was flattened into a two-dimensional matrix of size m x (n + p + …).

  Note that this function is particularly useful for sparse matrices, as it extracts the nonzero elements as vectors, which can then be used to create the original matrix. For example:

      sz = size (a);
      [i, j, v] = find (a);
      b = sparse (i, j, v, sz(1), sz(2));

  See also: nonzeros.

`idx =` lookup `(table, y)` ¶
`idx =` lookup `(table, y, opt)` ¶

  Lookup values in a sorted table.

  This function is usually used as a prelude to interpolation.

  If table is increasing, of length N and `idx = lookup (table, y)`, then `table(idx(i)) <= y(i) < table(idx(i+1))` for all `y(i)` within the table. If `y(i) < table(1)` then `idx(i)` is 0. If `y(i) >= table(end)` or `isnan (y(i))` then `idx(i)` is N.

  If the table is decreasing, then the tests are reversed. For non-strictly monotonic tables, empty intervals are always skipped. The result is undefined if table is not monotonic, or if table contains a NaN.

  The complexity of the lookup is O(M*log(N)) where M is the size of y. In the special case when y is also sorted, the complexity is O(min (M*log(N), M+N)).

  table and y can also be cell arrays of strings (or y can be a single string). In this case, string lookup is performed using lexicographical comparison.

  If opts is specified, it must be a string with letters indicating additional options.

  `m`

    Match. `table(idx(i)) == y(i)` if `y(i)` occurs in table; otherwise, `idx(i)` is zero.

  `b`

    Boolean. `idx(i)` is a logical 1 or 0, indicating whether `y(i)` is contained in table or not.

  `l`

    Left. For numeric lookups the leftmost subinterval shall be extended to minus infinity (i.e., all indices at least 1).

  `r`

    Right. For numeric lookups the rightmost subinterval shall be extended to infinity (i.e., all indices at most N-1).

  Note: If table is not sorted the results from `lookup` will be unpredictable.

If you wish to check if a variable exists at all, instead of properties its elements may have, see Status of Variables.