\function{all} \synopsis{Tests if all elements of an array are non-zero} \usage{Char_Type all (Array_Type a [,Int_Type dim])} \description The \ifun{all} function examines the elements of a numeric array and returns 1 if all elements are non-zero, otherwise it returns 0. If a second argument is given, then it specifies the dimension of the array over which the function is to be applied. In this case, the result will be an array with the same shape as the input array minus the specified dimension. \example Consider the 2-d array #v+ 1 2 3 4 5 6 7 8 9 10 #v- generated by #v+ a = _reshape ([1:10], [2, 5]); #v- Then \exmp{all(a)} will return 1, and \exmp{all(a>3, 0)} will return a 1-d array #v+ [0, 0, 0, 1, 1] #v- Similarly, \exmp{all(a>3, 1)} will return the 1-d array #v+ [0,1] #v- \seealso{where, any, wherediff} \done \function{any} \synopsis{Test if any element of an array is non-zero} \usage{Char_Type any (Array_Type a [,Int_Type dim])} \description The \ifun{any} function examines the elements of a numeric array and returns 1 if any element is both non-zero and not a NaN, otherwise it returns 0. If a second argument is given, then it specifies the dimension of the array to be tested. \example Consider the 2-d array #v+ 1 2 3 4 5 6 7 8 9 10 #v- generated by #v+ a = _reshape ([1:10], [2, 5]); #v- Then \exmp{any(a==3)} will return 1, and \exmp{any(a==3, 0)} will return a 1-d array with elements: #v+ 0 0 1 0 0 #v- \seealso{all, where, wherediff} \done \function{array_info} \synopsis{Returns information about an array} \usage{(Array_Type, Integer_Type, DataType_Type) array_info (Array_Type a)} \description The \ifun{array_info} function returns information about the array \exmp{a}. It returns three values: an 1-d integer array specifying the size of each dimension of \exmp{a}, the number of dimensions of \exmp{a}, and the data type of \exmp{a}. \example The \ifun{array_info} function may be used to find the number of rows of an array: #v+ define num_rows (a) { variable dims, num_dims, data_type; (dims, num_dims, data_type) = array_info (a); return dims [0]; } #v- \seealso{typeof, array_shape, length, reshape, _reshape} \done \function{array_map} \synopsis{Apply a function to each element of an array} \usage{Array_Type array_map (type, func, args...)} \altusage{(Array_Type, ...) array_map (type, ..., func, args...)} #v+ DataType_Type type, ...; Ref_Type func; #v- \description The \ifun{array_map} function may be used to apply a function to each element of an array and returns the resulting values as an array of the specified type. The \exmp{type} parameter indicates what kind of array should be returned and generally corresponds to the return type of the function. If the function returns multiple values, then the type of each return value must be given. The first array-valued argument is used to determine the dimensions of the resulting array(s). If any subsequent arguments correspond to an array of the same size, then those array elements will be passed in parallel with the elements of the first array argument. To use \ifun{array_map} with functions that return no value, either omit the \exmp{type} argument, or explicitly indicate that it returns no value using the \dtype{Void_Type} type. \example The first example illustrates how to apply the \ifun{strlen} function to an array of strings. #v+ S = ["", "Train", "Subway", "Car"]; L = array_map (Integer_Type, &strlen, S); #v- This is equivalent to: #v+ S = ["", "Train", "Subway", "Car"]; L = Integer_Type [length (S)]; for (i = 0; i < length (S); i++) L[i] = strlen (S[i]); #v- Now consider an example involving the \ifun{strcat} function: #v+ files = ["slang", "slstring", "slarray"]; exts = ".c"; cfiles = array_map (String_Type, &strcat, files, exts); % ==> cfiles = ["slang.c", "slstring.c", "slarray.c"]; exts = [".a",".b",".c"]; xfiles = array_map (String_Type, &strcat, files, exts); % ==> xfiles = ["slang.a", "slstring.b", "slarray.c"]; #v- Here is an example of its application to a function that returns 3 values. Suppose \exmp{A} is an array of arrays whose types and sizes are arbitrary, and we wish to find the indices of \exmp{A} that contain arrays of type \exmp{String_Type}. For this purpose, the \ifun{array_info} function will be used: #v+ (dims, ndims, types) = array_map (Array_Type, Int_Type, DataType_Type, &array_info, A); i = where (types == String_Type); #v- The \ifun{message} function prints a string and returns no value. This example shows how it may be used to print an array of strings: #v+ a = ["Line 1", "Line 2", "Line 3"]; array_map (&message, a); % Form 1 array_map (Void_Type, &message, a); % Form 2 #v- \notes Many mathematical functions already work transparently on arrays. For example, the following two statements produce identical results: #v+ B = sin (A); B = array_map (Double_Type, &sin, A); #v- \notes A number of the string functions have been vectorized, including the \ifun{strlen} function. This means that there is no need to use the \ifun{array_map} function with the \ifun{strlen} function. \seealso{array_info, strlen, strcat, sin} \done \function{array_reverse} \synopsis{Reverse the elements of an array} \usage{array_reverse (Array_Type a [,Int_Type i0, Int_Type i1] [,Int_Type dim])} \description In its simplest form, the \ifun{array_reverse} function reverses the elements of an array. If passed 2 or 4 arguments, \ifun{array_reverse} reverses the elements of the specified dimension of a multi-dimensional array. If passed 3 or 4 arguments, the parameters \exmp{i0} and \exmp{i1} specify a range of elements to reverse. \example If \exmp{a} is a one dimensional array, then #v+ array_reverse (a, i, j); a[[i:j]] = a[[j:i:-1]]; #v- are equivalent to one another. However, the form using \ifun{array_reverse} is about 10 times faster than the version that uses explicit array indexing. \seealso{array_swap, transpose} \done \function{array_shape} \synopsis{Get the shape or dimensions of an array} \usage{dims = array_shape (Array_Type a)} \description This function returns an array representing the dimensionality or shape of a specified array. The \ifun{array_info} function also returns this information but for many purposes the \ifun{array_shape} function is more convenient. \seealso{array_info, reshape} \done \function{array_sort} \synopsis{Sort an array or opaque object} \usage{Array_Type array_sort (obj [, &func [, n]])} \description The \ifun{array_sort} function may be used to sort an object and returns an integer index array that represents the result of the sort as a permutation. If a single parameter is passed, that parameter must be an array, which will be sorted into ascending order using a built-in type-specific comparison function. If two parameters are passed (\exmp{obj} and \exmp{func}), then the first parameter must be the array to be sorted, and the second is a reference to the comparison function. In this case, the comparison function represented by \exmp{func} must take two arguments representing two array elements to be compared, and must return an integer that represents the result of the comparison. The return value must be less than zero if the first parameter is less than the second, zero if they are equal, and a value greater than zero if the first is greater than the second. If three parameters are passed, then the first argument will be regarded as an opaque object by the sorting algorithm. For this reason, the number of elements represented by the object must also be passed to \ifun{array_sort} function as the third function argument. The second function argument must be a reference to comparison function. In this case, the comparison function will be passed three values: the opaque object, the (0-based) index of the first element to be compared, and the (0-based) index of the second element. The return value must be less than zero if the value of the element at the first index considered to be less than the value of the element at the second index, zero if the values are equal, and a value greater than zero if the first value is greater than the second. \ifun{array_sort} sorts the array \exmp{a} into ascending order and returns an integer array that represents the result of the sort. If the optional second parameter \exmp{f} is present, the function specified by \exmp{f} will be used to compare elements of \exmp{a}; otherwise, a built-in sorting function will be used. The integer array returned by this function is simply an index array that indicates the order of the sorted object. The input object \exmp{obj} is not changed. \qualifiers By default, elements are sorted in ascending order. The \exmp{dir} qualifier may be used to specify the sort direction. Specifically if \exmp{dir>=0}, the sort will be an ascending one, otherwise it will be descending. The \exmp{method} qualifier may be used to select between the available sorting algorithms. There are currently two algorithms supported: merge-sort and quick-sort. Using \exmp{method="msort"} will cause the merge-sort algorithm to be used. The quick-sort algorithm may be selected using \exmp{method="qsort"}. \example An array of strings may be sorted using the \ifun{strcmp} function since it fits the specification for the sorting function described above: #v+ A = ["gamma", "alpha", "beta"]; I = array_sort (A, &strcmp); #v- Alternatively, one may use #v+ variable I = array_sort (A); #v- to use the built-in comparison function. After the \ifun{array_sort} has executed, the variable \exmp{I} will have the values \exmp{[2, 0, 1]}. This array can be used to re-shuffle the elements of \exmp{A} into the sorted order via the array index expression \exmp{A = A[I]}. This operation may also be written: #v+ A = A[array_sort(A)]; #v- \example A homogeneous list may be sorted by using the opaque form of the \ifun{array_sort} function: #v+ private define cmp_function (s, i, j) { if (s[i] > s[j]) return 1; if (s[i] < s[j]) return -1; return 0; } list = {}; % fill list .... % now sort it i = array_sort (list, &cmp_function, length(list)); % Create a new sorted list list = list[i]; #v- Alternatively one may first convert it to an array and use the built-in comparison function: #v+ a = list_to_array (list); i = array_sort(a); % Rearrange the elements list[*] = a[i]; #v- to get the effect of an "in-place" sort. \notes The default sorting algorithm is merge-sort. It has an N*log(N) worst-case runtime compared to quick-sort's worst-case N^2 runtime. The primary advantage of quick-sort is that it uses O(1) additional memory, whereas merge-sort requires O(N) additional memory. A stable sorting algorithm is one that preserves the order of equal elements. Merge-sort is an inherently stable algorithm, whereas quick-sort is not. Nevertheless, the slang library ensures the stability of the results because it uses the indices themselves as tie-breakers. As a result, the following two statements may not produce the same results: #v+ i = array_sort (a; dir=-1); i = array_reverse (array_sort (a; dir=1)); #v- \seealso{set_default_sort_method, get_default_sort_method, strcmp, list_to_array} \done \function{array_swap} \synopsis{Swap elements of an array} \usage{array_swap (Array_Type a, Int_Type i, Int_Type j)} \description The \ifun{array_swap} function swaps the specified elements of an array. It is equivalent to #v+ (a[i], a[j]) = (a[j], a[i]); #v- except that it executes several times faster than the above construct. \seealso{array_reverse, transpose} \done \function{cumsum} \synopsis{Compute the cumulative sum of an array} \usage{result = cumsum (Array_Type a [, Int_Type dim])} \description The \ifun{cumsum} function performs a cumulative sum over the elements of a numeric array and returns the result. If a second argument is given, then it specifies the dimension of the array to be summed over. For example, the cumulative sum of \exmp{[1,2,3,4]}, is the array \exmp{[1,1+2,1+2+3,1+2+3+4]}, i.e., \exmp{[1,3,6,10]}. \seealso{sum, sumsq} \done \function{get_default_sort_method} \synopsis{Get the default sorting method} \usage{String_Type get_default_sort_method ()} \description This function may be used to get the default sorting method used by \ifun{array_sort}. It will return one of the following strings: #v+ "msort" Merge-Sort "qsort" Quick-Sort #v- \seealso{set_default_sort_method, array_sort} \done \function{init_char_array} \synopsis{Initialize an array of characters} \usage{init_char_array (Array_Type a, String_Type s)} \description The \ifun{init_char_array} function may be used to initialize a Char_Type array \exmp{a} by setting the elements of the array \exmp{a} to the corresponding bytes of the string \exmp{s}. \example The statements #v+ variable a = Char_Type [10]; init_char_array (a, "HelloWorld"); #v- creates an character array and initializes its elements to the bytes in the string \exmp{"HelloWorld"}. \notes The character array must be large enough to hold all the characters of the initialization string. This function uses byte-semantics. \seealso{bstring_to_array, strlen, strcat} \done \function{_isnull} \synopsis{Check an array for NULL elements} \usage{Char_Type[] = _isnull (a[])} \description This function may be used to test for the presence of \NULL elements of an array. Specifically, it returns a \dtype{Char_Type} array of with the same number of elements and dimensionality of the input array. If an element of the input array is \NULL, then the corresponding element of the output array will be set to \1, otherwise it will be set to \0. \example Set all \NULL elements of a string array \exmp{A} to the empty string \exmp{""}: #v+ A[where(_isnull(A))] = ""; #v- \notes It is important to understand the difference between \exmp{A==NULL} and \exmp{_isnull(A)}. The latter tests all elements of \exmp{A} against \NULL, whereas the former only tests \exmp{A} itself. \seealso{where, array_map} \done \function{length} \synopsis{Get the length of an object} \usage{Integer_Type length (obj)} \description The \ifun{length} function may be used to get information about the length of an object. For simple scalar data-types, it returns 1. For arrays, it returns the total number of elements of the array. \notes If \exmp{obj} is a string, \ifun{length} returns \1 because a \dtype{String_Type} object is considered to be a scalar. To get the number of characters in a string, use the \ifun{strlen} function. \seealso{array_info, array_shape, typeof, strlen} \done \function{max} \synopsis{Get the maximum value of an array} \usage{result = max (Array_Type a [,Int_Type dim])} \description The \ifun{max} function examines the elements of a numeric array and returns the value of the largest element. If a second argument is given, then it specifies the dimension of the array to be searched. In this case, an array of dimension one less than that of the input array will be returned with the corresponding elements in the specified dimension replaced by the maximum value in that dimension. \example Consider the 2-d array #v+ 1 2 3 4 5 6 7 8 9 10 #v- generated by #v+ a = _reshape ([1:10], [2, 5]); #v- Then \exmp{max(a)} will return \exmp{10}, and \exmp{max(a,0)} will return a 1-d array with elements #v+ 6 7 8 9 10 #v- \notes This function ignores NaNs in the input array. \seealso{min, maxabs, sum, reshape} \done \function{maxabs} \synopsis{Get the maximum absolute value of an array} \usage{result = maxabs (Array_Type a [,Int_Type dim])} \description The \ifun{maxabs} function behaves like the \ifun{max} function except that it returns the maximum absolute value of the array. That is, \exmp{maxabs(x)} is equivalent to \exmp{max(abs(x)}. See the documentation for the \ifun{max} function for more information. \seealso{min, max, minabs} \done \function{min} \synopsis{Get the minimum value of an array} \usage{result = min (Array_Type a [,Int_Type dim])} \description The \ifun{min} function examines the elements of a numeric array and returns the value of the smallest element. If a second argument is given, then it specifies the dimension of the array to be searched. In this case, an array of dimension one less than that of the input array will be returned with the corresponding elements in the specified dimension replaced by the minimum value in that dimension. \example Consider the 2-d array #v+ 1 2 3 4 5 6 7 8 9 10 #v- generated by #v+ a = _reshape ([1:10], [2, 5]); #v- Then \exmp{min(a)} will return \exmp{1}, and \exmp{min(a,0)} will return a 1-d array with elements #v+ 1 2 3 4 5 #v- \notes This function ignores NaNs in the input array. \seealso{max, sum, reshape} \done \function{minabs} \synopsis{Get the minimum absolute value of an array} \usage{result = minabs (Array_Type a [,Int_Type dim])} \description The \ifun{minabs} function behaves like the \ifun{min} function except that it returns the minimum absolute value of the array. That is, \exmp{minabs(x)} is equivalent to \exmp{min(abs(x)}. See the documentation for the \ifun{min} function for more information. \seealso{min, max, maxabs} \done \function{prod} \synopsis{Compute the product of the elements of an array} \usage{result = prod (Array_Type a [, Int_Type dim])} \description The \ifun{prod} function computes the product of the elements of a numeric array and returns the result. If a second argument is given, then it specifies the dimension of the array over which the product is to be taken. In this case, an array of dimension one less than that of the input array will be returned. If the input array is an integer type, then the resulting value will be a \dtype{Double_Type}. If the input array is a \dtype{Complex_Type}, then the result will be a \dtype{Complex_Type}. \seealso{sum, sumsq} \done \function{_reshape} \synopsis{Copy an array to a new shape} \usage{Array_Type _reshape (Array_Type A, Array_Type I)} \description The \ifun{_reshape} function creates a copy of an array \exmp{A}, reshapes it to the form specified by \exmp{I} and returns the result. The elements of \exmp{I} specify the new dimensions of the copy of \exmp{A} and must be consistent with the number of elements \exmp{A}. \example If \exmp{A} is a \exmp{100} element 1-d array, a new 2-d array of size \exmp{20} by \exmp{5} may be created from the elements of \exmp{A} by #v+ B = _reshape (A, [20, 5]); #v- \notes The \ifun{reshape} function performs a similar function to \ifun{_reshape}. In fact, the \ifun{_reshape} function could have been implemented via: #v+ define _reshape (a, i) { a = @a; % Make a new copy reshape (a, i); return a; } #v- \seealso{reshape, array_shape, array_info} \done \function{reshape} \synopsis{Reshape an array} \usage{reshape (Array_Type A, Array_Type I)} \description The \ifun{reshape} function changes the shape of \exmp{A} to have the shape specified by the 1-d integer array \exmp{I}. The elements of \exmp{I} specify the new dimensions of \exmp{A} and must be consistent with the number of elements \exmp{A}. \example If \exmp{A} is a \exmp{100} element 1-d array, it can be changed to a 2-d \exmp{20} by \exmp{5} array via #v+ reshape (A, [20, 5]); #v- However, \exmp{reshape(A, [11,5])} will result in an error because the \exmp{[11,5]} array specifies \exmp{55} elements. \notes Since \ifun{reshape} modifies the shape of an array, and arrays are treated as references, then all references to the array will reference the new shape. If this effect is unwanted, then use the \ifun{_reshape} function instead. \seealso{_reshape, array_info, array_shape} \done \function{set_default_sort_method} \synopsis{Set the default sorting method} \usage{set_default_sort_method (String_Type method)} \description This function may be used to set the default sorting method used by \ifun{array_sort}. The following methods are supported: #v+ "msort" Merge-Sort "qsort" Quick-Sort #v- \seealso{get_default_sort_method, array_sort} \done \function{sum} \synopsis{Sum over the elements of an array} \usage{result = sum (Array_Type a [, Int_Type dim])} \description The \ifun{sum} function sums over the elements of a numeric array and returns its result. If a second argument is given, then it specifies the dimension of the array to be summed over. In this case, an array of dimension one less than that of the input array will be returned. If the input array is an integer type, then the resulting value will be a \dtype{Double_Type}. If the input array is a \dtype{Float_Type}, then the result will be a \dtype{Float_Type}. \example The mean of an array \exmp{a} of numbers is #v+ sum(a)/length(a) #v- \seealso{cumsum, sumsq, transpose, reshape} \done \function{sumsq} \synopsis{Sum over the squares of the elements of an array} \usage{result = sumsq (Array_Type a [, Int_Type dim])} \description The \ifun{sumsq} function sums over the squares of the elements of a numeric array and returns its result. If a second argument is given, then it specifies the dimension of the array to be summed over. In this case, an array of dimension one less than that of the input array will be returned. If the input array is an integer type, then the resulting value will be a \dtype{Double_Type}. If the input array is a \dtype{Float_Type}, then the result will be a \dtype{Float_Type}. For complex arrays, the sum will be over the squares of the moduli of the complex elements. \seealso{cumsum, sumsq, hypot, transpose, reshape} \done \function{transpose} \synopsis{Transpose an array} \usage{Array_Type transpose (Array_Type a)} \description The \ifun{transpose} function returns the transpose of a specified array. By definition, the transpose of an array, say one with elements \exmp{a[i,j,...k]} is an array whose elements are \exmp{a[k,...,j,i]}. \seealso{_reshape, reshape, sum, array_info, array_shape} \done \function{where} \usage{Array_Type where (Array_Type a [, Ref_Type jp])} \description The \ifun{where} function examines a numeric array \exmp{a} and returns an integer array giving the indices of \exmp{a} where the corresponding element of \exmp{a} is non-zero. The function accepts an optional \dtype{Ref_Type} argument that will be set to complement set of indices, that is, the indices where \exmp{a} is zero. In fact #v+ i = where (a); j = where (not a); #v- and #v+ i = where (a, &j); #v- are equivalent, but the latter form is preferred since it executes about twice as fast as the former. The \ifun{where} function can also be used with relational operators and with the boolean binary \exmp{or} and \exmp{and} operators, e.g., #v+ a = where (array == "a string"); a = where (array <= 5); a = where (2 <= array <= 10); a = where ((array == "a string") or (array == "another string")); #v- Using in the last example the short-circuiting \exmp{||} and \exmp{&&} operators, will result in a \exc{TypeMismatchError} exception. Although this function may appear to be simple or even trivial, it is arguably one of the most important and powerful functions for manipulating arrays. \example Consider the following: #v+ variable X = [0.0:10.0:0.01]; variable A = sin (X); variable I = where (A < 0.0); A[I] = cos (X) [I]; #v- Here the variable \exmp{X} has been assigned an array of doubles whose elements range from \exmp{0.0} through \exmp{10.0} in increments of \exmp{0.01}. The second statement assigns \exmp{A} to an array whose elements are the \ifun{sin} of the elements of \exmp{X}. The third statement uses the \ifun{where} function to get the indices of the elements of \exmp{A} that are less than 0. Finally, the last statement replaces those elements of \exmp{A} by the cosine of the corresponding elements of \exmp{X}. \notes Support for the optional argument was added to version 2.1.0. \seealso{wherefirst, wherelast, wherenot, wherediff, array_info, array_shape, _isnull} \done \function{wherediff} \synopsis{Get the indices where adjacent elements differ} \usage{Array_Type wherediff (Array_Type A [, Ref_Type jp])} \description This function returns an array of the indices where adjacent elements of the array \exmp{A} differ. If the optional second argument is given, it must be a reference to a variable whose value will be set to the complement indices (those where adjacient elements are the same). The returned array of indices will consist of those elements \exmp{i} where \exmp{A[i] != A[i-1]}. Since no element preceeds the 0th element, \exmp{A[0]} differs from its non-existing preceeding element; hence the index \exmp{0} will a member of the returned array. \example Suppose that \exmp{A = [1, 1, 3, 0, 0, 4, 7, 7]}. Then, #v+ i = wherediff (A, &j); #v- will result in \exmp{i = [0, 2, 3, 5, 6]} and \exmp{j = [1, 4, 7]}. \notes Higher dimensional arrays are treated as a 1-d array of contiguous elements. \seealso{where, wherenot} \done \function{wherefirst} \synopsis{Get the index of the first non-zero array element} \usage{Int_Type wherefirst (Array_Type a [,start_index])} \description The \ifun{wherefirst} function returns the index of the first non-zero element of a specified array. If the optional parameter \exmp{start_index} is given, the search will take place starting from that index. If a non-zero element is not found, the function will return \NULL. \notes The single parameter version of this function is equivalent to #v+ define wherefirst (a) { variable i = where (a); if (length(i)) return i[0]; else return NULL; } #v- \seealso{where, wherelast, wherefirstmin, wherefirstmax, wherefirst_eq} \done \function{wherefirst_eq, wherefirst_ne, wherefirst_ge, wherefirst_gt, wherefirst_le, wherefirst_lt, wherelast_eq, wherelast_ne, wherelast_ge, wherelast_gt, wherelast_le, wherelast_lt } \synopsis{Get the first or last matching element of an array} \usage{Int_Type wherefirst_eq (A, b [,istart]) Int_Type wherefirst_ne (A, b [,istart]) Int_Type wherefirst_ge (A, b [,istart]) Int_Type wherefirst_gt (A, b [,istart]) Int_Type wherefirst_le (A, b [,istart]) Int_Type wherefirst_lt (A, b [,istart]) Int_Type wherelast_eq (A, b [,istart]) Int_Type wherelast_ne (A, b [,istart]) Int_Type wherelast_ge (A, b [,istart]) Int_Type wherelast_gt (A, b [,istart]) Int_Type wherelast_le (A, b [,istart]) Int_Type wherelast_lt (A, b [,istart]) } \description These functions perform the indicated binary operation between the elements of numeric array \exmp{A} and a number \exmp{b}. The \exmp{wherefirst_*} functions return the index of the first element for which the comparison is true. The \exmp{wherelast_*} functions return the last index where the binary operation is true. If no matching elements are found, the functions return \NULL. If the optional third parameter, \exmp{istart}, is given, then it indicates the index into the array where the search is to start. These functions have the following equivalent forms: #v+ wherefirst_eq (A, b, istart) <==> wherefirst (A == b, istart) wherefirst_ne (A, b, istart) <==> wherefirst (A != b, istart) wherefirst_ge (A, b, istart) <==> wherefirst (A >= b, istart) wherefirst_gt (A, b, istart) <==> wherefirst (A > b, istart) wherefirst_le (A, b, istart) <==> wherefirst (A <= b, istart) wherefirst_lt (A, b, istart) <==> wherefirst (A < b, istart) wherelast_eq (A, b, istart) <==> wherelast (A == b, istart) wherelast_ne (A, b, istart) <==> wherelast (A != b, istart) wherelast_ge (A, b, istart) <==> wherelast (A >= b, istart) wherelast_gt (A, b, istart) <==> wherelast (A > b, istart) wherelast_le (A, b, istart) <==> wherelast (A <= b, istart) wherelast_lt (A, b, istart) <==> wherelast (A < b, istart) #v- However, the \exmp{wherefirst_*} and \exmp{wherelast_*} function can execute several orders of magnitude faster, depending upon the context. \notes The current implementation of these functions is limited to numeric types. \seealso{wherefirst, wherelast} \function{wherefirstmax} \synopsis{Get the index of the first maximum array value} \usage{Int_Type wherefirstmax (Array_Type a)} \description This function is equivalent to #v+ index = wherefirst (a == max(a)); #v- It executes about 3 times faster, and does not require the creation of temporary arrays. \seealso{wherefirst, wherefirstmax, wherelastmin, min, max} \done \function{wherefirstmin} \synopsis{Get the index of the first minimum array value} \usage{Int_Type wherefirstmin (Array_Type a)} \description This function is equivalent to #v+ index = wherefirst (a == min(a)); #v- It executes about 3 times faster, and does not require the creation of temporary arrays. \seealso{wherefirst, wherelastmin, wherefirstmax, min, max} \done \function{wherelast} \synopsis{Get the index of the last non-zero array element} \usage{Int_Type wherelast (Array_Type a [,start_index])} \description The \ifun{wherelast} function returns the index of the last non-zero element of a specified array. If the optional parameter \exmp{start_index} is given, the backward search will take place starting from that index. If a non-zero element is not found, the function will return \NULL. \notes The single parameter version of this function is equivalent to #v+ define wherelast (a) { variable i = where (a); if (length(i)) return i[-1]; else return NULL; } #v- \seealso{where, wherefirst, wherelastmin, wherelastmax, wherefirst_eq} \done \function{wherelastmax} \synopsis{Get the index of the last maximum array value} \usage{Int_Type wherelastmax (Array_Type a)} \description This function is equivalent to #v+ index = wherelast (a == max(a)); #v- It executes about 3 times faster, and does not require the creation of temporary arrays. \seealso{wherelast, wherefirstmin, wherelastmin, min, max} \done \function{wherelastmin} \synopsis{Get the index of the last minimum array value} \usage{Int_Type wherelastmin (Array_Type a)} \description This function is equivalent to #v+ index = wherelast (a == min(a)); #v- It executes about 3 times faster, and does not require the creation of temporary arrays. \seealso{wherelast, wherefirstmin, wherelastmax, min, max} \done \function{wherenot} \synopsis{Get indices where a numeric array is 0} \usage{Array_Type wherenot (Array_Type a)} \description This function is equivalent to \exmp{where(not a)}. See the documentation for \ifun{where} for more information. \seealso{where, wherediff, wherefirst, wherelast} \done